]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/authorization/inetaccess/inetaccess.h
a13a11db2a0374b05d5e80ca6211e2de73c529e8
[stg.git] / projects / stargazer / plugins / authorization / inetaccess / inetaccess.h
1 /*
2  *    This program is free software; you can redistribute it and/or modify
3  *    it under the terms of the GNU General Public License as published by
4  *    the Free Software Foundation; either version 2 of the License, or
5  *    (at your option) any later version.
6  *
7  *    This program is distributed in the hope that it will be useful,
8  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
9  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  *    GNU General Public License for more details.
11  *
12  *    You should have received a copy of the GNU General Public License
13  *    along with this program; if not, write to the Free Software
14  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
15  */
16
17 /*
18  *    Author : Boris Mikhailenko <stg34@stargazer.dp.ua>
19  */
20
21 /*
22  $Revision: 1.34 $
23  $Date: 2010/09/10 06:39:19 $
24  $Author: faust $
25  */
26
27 #ifndef INETACCESS_H
28 #define INETACCESS_H
29
30 #include <sys/time.h>
31 #include <pthread.h>
32
33 #include <cstring>
34 #include <ctime>
35 #include <string>
36 #include <map>
37 #include <list>
38 #include <functional>
39 #include <utility>
40
41 #include "stg/os_int.h"
42 #include "stg/auth.h"
43 #include "stg/store.h"
44 #include "stg/notifer.h"
45 #include "stg/user_ips.h"
46 #include "stg/user.h"
47 #include "stg/users.h"
48 #include "stg/ia_packets.h"
49 #include "stg/blowfish.h"
50 #include "stg/logger.h"
51 #include "stg/utime.h"
52 #include "stg/logger.h"
53
54 #define IA_PROTO_VER    (6)
55
56 //#define IA_DEBUG (1)
57 //#define IA_PHASE_DEBUG (1)
58
59 class AUTH_IA;
60 //-----------------------------------------------------------------------------
61 enum FREEMB {
62     freeMb0 = 0,
63     freeMb1,
64     freeMb2,
65     freeMb3,
66     freeMb4,
67     freeMb5,
68     freeMb6,
69     freeMb7,
70     freeMb8,
71     freeMb9,
72     freeMb10,
73     freeMb11,
74     freeMb12,
75     freeMb13,
76     freeMb14,
77     freeMb15,
78     freeMb16,
79     freeMb17,
80     freeMb18,
81     freeMb19,
82     freeMbCash = 100,
83     freeMbNone = 101
84 };
85 //-----------------------------------------------------------------------------
86 class IA_PHASE {
87 public:
88     IA_PHASE();
89     ~IA_PHASE();
90
91     void    SetPhase1();
92     void    SetPhase2();
93     void    SetPhase3();
94     void    SetPhase4();
95     void    SetPhase5();
96     int     GetPhase() const;
97
98     void    UpdateTime();
99     const UTIME & GetTime() const;
100
101     #ifdef IA_PHASE_DEBUG
102     void    SetUserLogin(const std::string & login);
103     void    SetLogFileName(const std::string & logFileName);
104     #endif
105
106 private:
107     int             phase;
108     UTIME           phaseTime;
109
110     #ifdef IA_PHASE_DEBUG
111     void WritePhaseChange(int newPhase);
112     std::string log;
113     std::string login;
114     FILE * flog;
115     #endif
116 };
117 //-----------------------------------------------------------------------------
118 struct IA_USER {
119     IA_USER()
120         : login(),
121           user(NULL),
122           phase(),
123           lastSendAlive(0),
124           rnd(static_cast<uint32_t>(random())),
125           port(0),
126           ctx(),
127           messagesToSend(),
128           protoVer(0),
129           password("NO PASSWORD")
130     {
131     unsigned char keyL[PASSWD_LEN];
132     memset(keyL, 0, PASSWD_LEN);
133     strncpy((char *)keyL, password.c_str(), PASSWD_LEN);
134     Blowfish_Init(&ctx, keyL, PASSWD_LEN);
135
136     #ifdef IA_DEBUG
137     aliveSent = false;
138     #endif
139     }
140
141     IA_USER(const IA_USER & u)
142         : login(u.login),
143           user(u.user),
144           phase(u.phase),
145           lastSendAlive(u.lastSendAlive),
146           rnd(u.rnd),
147           port(u.port),
148           ctx(),
149           messagesToSend(u.messagesToSend),
150           protoVer(u.protoVer),
151           password(u.password)
152     {
153     #ifdef IA_DEBUG
154     aliveSent  = u.aliveSent;
155     #endif
156     memcpy(&ctx, &u.ctx, sizeof(BLOWFISH_CTX));
157     }
158
159     IA_USER(const std::string & l,
160             CONST_USER_PTR u,
161             uint16_t p,
162             int ver)
163         : login(l),
164           user(u),
165           phase(),
166           lastSendAlive(0),
167           rnd(static_cast<uint32_t>(random())),
168           port(p),
169           ctx(),
170           messagesToSend(),
171           protoVer(ver),
172           password(user->GetProperty().password.Get())
173     {
174     unsigned char keyL[PASSWD_LEN];
175     memset(keyL, 0, PASSWD_LEN);
176     strncpy((char *)keyL, password.c_str(), PASSWD_LEN);
177     Blowfish_Init(&ctx, keyL, PASSWD_LEN);
178
179     #ifdef IA_DEBUG
180     aliveSent = false;
181     #endif
182     }
183
184     std::string     login;
185     CONST_USER_PTR  user;
186     IA_PHASE        phase;
187     UTIME           lastSendAlive;
188     uint32_t        rnd;
189     uint16_t        port;
190     BLOWFISH_CTX    ctx;
191     std::list<STG_MSG> messagesToSend;
192     int             protoVer;
193     std::string     password;
194     #ifdef IA_DEBUG
195     bool            aliveSent;
196     #endif
197
198 private:
199     IA_USER & operator=(const IA_USER & rvalue);
200 };
201 //-----------------------------------------------------------------------------
202 class AUTH_IA_SETTINGS {
203 public:
204                     AUTH_IA_SETTINGS();
205     virtual         ~AUTH_IA_SETTINGS() {}
206     const std::string & GetStrError() const { return errorStr; }
207     int             ParseSettings(const MODULE_SETTINGS & s);
208     int             GetUserDelay() const { return userDelay; }
209     int             GetUserTimeout() const { return userTimeout; }
210     uint16_t        GetUserPort() const { return port; }
211     FREEMB          GetFreeMbShowType() const { return freeMbShowType; }
212
213 private:
214     int             userDelay;
215     int             userTimeout;
216     uint16_t        port;
217     std::string     errorStr;
218     FREEMB          freeMbShowType;
219 };
220 //-----------------------------------------------------------------------------
221 class AUTH_IA;
222 //-----------------------------------------------------------------------------
223 class DEL_USER_NOTIFIER: public NOTIFIER_BASE<USER_PTR> {
224 public:
225     DEL_USER_NOTIFIER(AUTH_IA & a) : auth(a) {}
226     virtual ~DEL_USER_NOTIFIER() {}
227
228     void Notify(const USER_PTR & user);
229 private:
230     DEL_USER_NOTIFIER(const DEL_USER_NOTIFIER & rvalue);
231     DEL_USER_NOTIFIER & operator=(const DEL_USER_NOTIFIER & rvalue);
232
233     AUTH_IA & auth;
234 };
235 //-----------------------------------------------------------------------------
236 class AUTH_IA :public AUTH {
237 friend class DEL_USER_NOTIFIER;
238 public:
239                         AUTH_IA();
240     virtual             ~AUTH_IA();
241
242     void                SetUsers(USERS * u) { users = u; }
243     void                SetStgSettings(const SETTINGS * s) { stgSettings = s; }
244     void                SetSettings(const MODULE_SETTINGS & s) { settings = s; }
245     int                 ParseSettings();
246
247     int                 Start();
248     int                 Stop();
249     int                 Reload() { return 0; }
250     bool                IsRunning() { return isRunningRunTimeouter || isRunningRun; }
251
252     const std::string & GetStrError() const { return errorStr; }
253     std::string         GetVersion() const { return "InetAccess authorization plugin v.1.4"; }
254     uint16_t            GetStartPosition() const { return 30; }
255     uint16_t            GetStopPosition() const { return 30; }
256
257     int                 SendMessage(const STG_MSG & msg, uint32_t ip) const;
258
259 private:
260     AUTH_IA(const AUTH_IA & rvalue);
261     AUTH_IA & operator=(const AUTH_IA & rvalue);
262
263     static void *       Run(void *);
264     static void *       RunTimeouter(void * d);
265     int                 PrepareNet();
266     int                 FinalizeNet();
267     void                DelUser(USER_PTR u);
268     int                 RecvData(char * buffer, int bufferSize);
269     int                 CheckHeader(const char * buffer, int * protoVer);
270     int                 PacketProcessor(void * buff, size_t dataLen, uint32_t sip, uint16_t sport, int protoVer, USER_PTR user);
271
272     int                 Process_CONN_SYN_6(CONN_SYN_6 * connSyn, IA_USER * iaUser, uint32_t sip);
273     int                 Process_CONN_SYN_7(CONN_SYN_7 * connSyn, IA_USER * iaUser, uint32_t sip);
274     int                 Process_CONN_SYN_8(CONN_SYN_8 * connSyn, IA_USER * iaUser, uint32_t sip);
275
276     int                 Process_CONN_ACK_6(CONN_ACK_6 * connAck, IA_USER * iaUser, uint32_t sip);
277     int                 Process_CONN_ACK_7(CONN_ACK_7 * connAck, IA_USER * iaUser, uint32_t sip);
278     int                 Process_CONN_ACK_8(CONN_ACK_8 * connAck, IA_USER * iaUser, uint32_t sip);
279
280     int                 Process_ALIVE_ACK_6(ALIVE_ACK_6 * aliveAck, IA_USER * iaUser, uint32_t sip);
281     int                 Process_ALIVE_ACK_7(ALIVE_ACK_7 * aliveAck, IA_USER * iaUser, uint32_t sip);
282     int                 Process_ALIVE_ACK_8(ALIVE_ACK_8 * aliveAck, IA_USER * iaUser, uint32_t sip);
283
284     int                 Process_DISCONN_SYN_6(DISCONN_SYN_6 * disconnSyn, IA_USER * iaUser, uint32_t sip);
285     int                 Process_DISCONN_SYN_7(DISCONN_SYN_7 * disconnSyn, IA_USER * iaUser, uint32_t sip);
286     int                 Process_DISCONN_SYN_8(DISCONN_SYN_8 * disconnSyn, IA_USER * iaUser, uint32_t sip);
287
288     int                 Process_DISCONN_ACK_6(DISCONN_ACK_6 * disconnSyn,
289                                               IA_USER * iaUser,
290                                               uint32_t sip,
291                                               std::map<uint32_t, IA_USER>::iterator it);
292     int                 Process_DISCONN_ACK_7(DISCONN_ACK_7 * disconnSyn,
293                                               IA_USER * iaUser,
294                                               uint32_t sip,
295                                               std::map<uint32_t, IA_USER>::iterator it);
296     int                 Process_DISCONN_ACK_8(DISCONN_ACK_8 * disconnSyn,
297                                               IA_USER * iaUser,
298                                               uint32_t sip,
299                                               std::map<uint32_t, IA_USER>::iterator it);
300
301     int                 Send_CONN_SYN_ACK_6(IA_USER * iaUser, uint32_t sip);
302     int                 Send_CONN_SYN_ACK_7(IA_USER * iaUser, uint32_t sip);
303     int                 Send_CONN_SYN_ACK_8(IA_USER * iaUser, uint32_t sip);
304
305     int                 Send_ALIVE_SYN_6(IA_USER * iaUser, uint32_t sip);
306     int                 Send_ALIVE_SYN_7(IA_USER * iaUser, uint32_t sip);
307     int                 Send_ALIVE_SYN_8(IA_USER * iaUser, uint32_t sip);
308
309     int                 Send_DISCONN_SYN_ACK_6(IA_USER * iaUser, uint32_t sip);
310     int                 Send_DISCONN_SYN_ACK_7(IA_USER * iaUser, uint32_t sip);
311     int                 Send_DISCONN_SYN_ACK_8(IA_USER * iaUser, uint32_t sip);
312
313     int                 Send_FIN_6(IA_USER * iaUser, uint32_t sip, std::map<uint32_t, IA_USER>::iterator it);
314     int                 Send_FIN_7(IA_USER * iaUser, uint32_t sip, std::map<uint32_t, IA_USER>::iterator it);
315     int                 Send_FIN_8(IA_USER * iaUser, uint32_t sip, std::map<uint32_t, IA_USER>::iterator it);
316
317     int                 Timeouter();
318
319     int                 SendError(uint32_t ip, uint16_t port, int protoVer, const std::string & text);
320     int                 Send(uint32_t ip, uint16_t port, const char * buffer, size_t len);
321     int                 RealSendMessage6(const STG_MSG & msg, uint32_t ip, IA_USER & user);
322     int                 RealSendMessage7(const STG_MSG & msg, uint32_t ip, IA_USER & user);
323     int                 RealSendMessage8(const STG_MSG & msg, uint32_t ip, IA_USER & user);
324
325     BLOWFISH_CTX        ctxS;        //for loginS
326
327     mutable std::string errorStr;
328     AUTH_IA_SETTINGS    iaSettings;
329     MODULE_SETTINGS     settings;
330
331     bool                nonstop;
332
333     bool                isRunningRun;
334     bool                isRunningRunTimeouter;
335
336     USERS *             users;
337     const SETTINGS *    stgSettings;
338
339     mutable std::map<uint32_t, IA_USER> ip2user;
340
341     pthread_t           recvThread;
342     pthread_t           timeouterThread;
343     mutable pthread_mutex_t mutex;
344
345     int                 listenSocket;
346
347     CONN_SYN_ACK_6      connSynAck6;
348     CONN_SYN_ACK_8      connSynAck8;
349
350     DISCONN_SYN_ACK_6   disconnSynAck6;
351     DISCONN_SYN_ACK_8   disconnSynAck8;
352
353     ALIVE_SYN_6         aliveSyn6;
354     ALIVE_SYN_8         aliveSyn8;
355     FIN_6               fin6;
356     FIN_8               fin8;
357
358     std::map<std::string, int> packetTypes;
359
360     uint32_t            enabledDirs;
361
362     DEL_USER_NOTIFIER   onDelUserNotifier;
363
364     PLUGIN_LOGGER       logger;
365
366     friend class UnauthorizeUser;
367 };
368 //-----------------------------------------------------------------------------
369 class UnauthorizeUser : std::unary_function<const std::pair<uint32_t, IA_USER> &, void> {
370     public:
371         UnauthorizeUser(AUTH_IA * a) : auth(a) {}
372         UnauthorizeUser(const UnauthorizeUser & rvalue) : auth(rvalue.auth) {}
373         void operator()(const std::pair<uint32_t, IA_USER> & p)
374         {
375             auth->users->Unauthorize(p.second.user->GetLogin(), auth);
376         }
377     private:
378         UnauthorizeUser & operator=(const UnauthorizeUser & rvalue);
379
380         AUTH_IA * auth;
381 };
382 //-----------------------------------------------------------------------------
383 inline
384 void DEL_USER_NOTIFIER::Notify(const USER_PTR & user)
385 {
386     auth.DelUser(user);
387 }
388
389 #endif