summaryrefslogtreecommitdiff
path: root/src/modules/m_lockserv.cpp
blob: cbc454778d0157195f4fb9b0dbc9e5f6830f133c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
/*       +------------------------------------+
 *       | Inspire Internet Relay Chat Daemon |
 *       +------------------------------------+
 *
 *  InspIRCd: (C) 2002-2007 InspIRCd Development Team
 * See: http://www.inspircd.org/wiki/index.php/Credits
 *
 * This program is free but copyrighted software; see
 *            the file COPYING for details.
 *
 * ---------------------------------------------------
 */

#include "inspircd.h"
#include "users.h"
#include "channels.h"
#include "modules.h"

/* $ModDesc: Allows locking of the server to stop all incoming connections till unlocked again */

/** Adds numerics
 * 988 <nick> <servername> :Closed for new connections
 * 989 <nick> <servername> :Open for new connections
*/


class cmd_lockserv : public command_t
{
private:
	bool& locked;

public:
	cmd_lockserv (InspIRCd* Instance, bool &lock)
	: command_t(Instance, "LOCKSERV", 'o', 0), locked(lock)
	{
		this->source = "m_lockserv.so";
		syntax = "";
	}

	CmdResult Handle (const char** parameters, int pcnt, userrec *user)
	{
		locked = true;
		user->WriteServ("988 %s %s :Closed for new connections", user->nick, user->server);
		ServerInstance->WriteOpers("*** Oper %s used LOCKSERV to temporarily close for new connections", user->nick);
		/* Dont send to the network */
		return CMD_LOCALONLY;
	}
};

class cmd_unlockserv : public command_t
{
private:
	bool& locked;

public:
	cmd_unlockserv (InspIRCd* Instance, bool &lock)
	: command_t(Instance, "UNLOCKSERV", 'o', 0), locked(lock)
	{
		this->source = "m_lockserv.so";
		syntax = "";
	}

	CmdResult Handle (const char** parameters, int pcnt, userrec *user)
	{
		locked = false;
		user->WriteServ("989 %s %s :Open for new connections", user->nick, user->server);
		ServerInstance->WriteOpers("*** Oper %s used UNLOCKSERV to allow for new connections", user->nick);
		/* Dont send to the network */
		return CMD_LOCALONLY;
	}
};

class ModuleLockserv : public Module
{
private:
	bool locked;
	cmd_lockserv* lockcommand;
	cmd_unlockserv* unlockcommand;

	virtual void ResetLocked()
	{
		locked = false;
	}

public:
	ModuleLockserv(InspIRCd* Me) : Module(Me)
	{
		ResetLocked();
		lockcommand = new cmd_lockserv(ServerInstance, locked);
		ServerInstance->AddCommand(lockcommand);

		unlockcommand = new cmd_unlockserv(ServerInstance, locked);
		ServerInstance->AddCommand(unlockcommand);
	}

	virtual ~ModuleLockserv()
	{
	}

	void Implements(char* List)
	{
		List[I_OnUserRegister] = List[I_OnRehash] = List[I_OnCheckReady] = 1;
	}

	virtual void OnRehash(userrec* user, const std::string &parameter)
	{
		ResetLocked();
	}

	virtual int OnUserRegister(userrec* user)
	{
		if (locked)
		{
			userrec::QuitUser(ServerInstance, user, "Server is temporarily closed. Please try again later.");
			return 1;
		}
		return 0;
	}

	virtual bool OnCheckReady(userrec* user)
	{
		return !locked;
	}

	virtual Version GetVersion()
	{
		return Version(1, 0, 0, 1, VF_VENDOR, API_VERSION);
	}
};

class ModuleLockservFactory : public ModuleFactory
{
public:
	ModuleLockservFactory()
	{
	}

	~ModuleLockservFactory()
	{
	}

	virtual Module * CreateModule(InspIRCd* Me)
	{
		return new ModuleLockserv(Me);
	}
};

extern "C" DllExport void * init_module( void )
{
	return new ModuleLockservFactory;
}