]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/authorization/inetaccess/inetaccess.h
0e194db6d18e6ba8b099d1365d7c448dbddc0971
[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 #include <cstring>
33 #include <ctime>
34 #include <string>
35 #include <map>
36 #include <functional>
37 #include <utility>
38
39 #include "os_int.h"
40 #include "base_auth.h"
41 #include "base_store.h"
42 #include "notifer.h"
43 #include "user_ips.h"
44 #include "../../../user.h"
45 #include "../../../users.h"
46 #include "ia_packets.h"
47 #include "blowfish.h"
48 #include "stg_logger.h"
49 #include "utime.h"
50
51 using namespace std;
52
53 extern "C" BASE_PLUGIN * GetPlugin();
54
55 #define IA_PROTO_VER    (6)
56
57 //#define IA_DEBUG (1)
58 //#define IA_PHASE_DEBUG (1)
59
60 class AUTH_IA;
61 //-----------------------------------------------------------------------------
62 enum FREEMB
63 {
64     freeMb0 = 0,
65     freeMb1,
66     freeMb2,
67     freeMb3,
68     freeMb4,
69     freeMb5,
70     freeMb6,
71     freeMb7,
72     freeMb8,
73     freeMb9,
74     freeMb10,
75     freeMb11,
76     freeMb12,
77     freeMb13,
78     freeMb14,
79     freeMb15,
80     freeMb16,
81     freeMb17,
82     freeMb18,
83     freeMb19,
84     freeMbCash = 100,
85     freeMbNone = 101
86 };
87 //-----------------------------------------------------------------------------
88 class IA_PHASE
89 {
90 public:
91     IA_PHASE();
92     ~IA_PHASE();
93
94     void    SetPhase1();
95     void    SetPhase2();
96     void    SetPhase3();
97     void    SetPhase4();
98     void    SetPhase5();
99     int     GetPhase() const;
100
101     void    UpdateTime();
102     const UTIME & GetTime() const;
103
104     #ifdef IA_PHASE_DEBUG
105     void    SetUserLogin(const string & login);
106     void    SetLogFileName(const string & logFileName);
107     #endif
108
109 private:
110     int             phase;
111     UTIME           phaseTime;
112
113     #ifdef IA_PHASE_DEBUG
114     void WritePhaseChange(int newPhase);
115     string log;
116     string login;
117     FILE * flog;
118     #endif
119 };
120 //-----------------------------------------------------------------------------
121 struct IA_USER
122 {
123     IA_USER()
124     {
125         //phase     = 1;
126         //phaseTime = 0;
127         lastSendAlive = 0;
128         rnd       = random();
129         port      = 0;
130         password = "NO PASSWORD";
131         // +++ Preparing CTX +++
132         unsigned char keyL[PASSWD_LEN];  // ðÁÒÏÌØ ÄÌÑ ÛÉÆÒÏ×ËÉ
133         memset(keyL, 0, PASSWD_LEN);
134         strncpy((char *)keyL, password.c_str(), PASSWD_LEN);
135         Blowfish_Init(&ctx, keyL, PASSWD_LEN);
136         // --- Preparing CTX ---
137         #ifdef IA_DEBUG
138         aliveSent = false;
139         #endif
140     };
141
142     IA_USER(const IA_USER & u)
143     {
144         user          = u.user;
145         phase         = u.phase;
146         //phaseTime     = u.phaseTime;
147         lastSendAlive = u.lastSendAlive;
148         rnd           = u.rnd;
149         password      = u.password;
150         protoVer      = u.protoVer;
151         port          = u.port;
152         #ifdef IA_DEBUG
153         aliveSent  = u.aliveSent;
154         #endif
155         memcpy(&ctx, &u.ctx, sizeof(BLOWFISH_CTX));
156     };
157
158     user_iter       user;
159     //int             phase;
160     //UTIME           phaseTime;
161     IA_PHASE        phase;
162     UTIME           lastSendAlive;
163     uint32_t        rnd;
164     uint16_t        port;
165     BLOWFISH_CTX    ctx;
166     list<STG_MSG>   messagesToSend;
167     int             protoVer;
168     string          password;
169     #ifdef IA_DEBUG
170     bool            aliveSent;
171     #endif
172 };
173 //-----------------------------------------------------------------------------
174 class AUTH_IA_SETTINGS
175 {
176 public:
177                     AUTH_IA_SETTINGS();
178     virtual         ~AUTH_IA_SETTINGS() {};
179     const string&   GetStrError() const { return errorStr; };
180     int             ParseSettings(const MODULE_SETTINGS & s);
181     int             GetUserDelay() const { return userDelay; };
182     int             GetUserTimeout() const { return userTimeout; };
183     int             GetUserPort() const { return port; };
184     FREEMB          GetFreeMbShowType() const { return freeMbShowType; };
185
186 private:
187     int             ParseIntInRange(const string & str, int min, int max, int * val);
188     int             userDelay;
189     int             userTimeout;
190     uint16_t        port;
191     string          errorStr;
192     FREEMB          freeMbShowType;
193 };
194 //-----------------------------------------------------------------------------
195 class AUTH_IA :public BASE_AUTH
196 {
197 public:
198                         AUTH_IA();
199     virtual             ~AUTH_IA();
200
201     void                SetUsers(USERS * u) { users = u; };
202     void                SetTariffs(TARIFFS *){};
203     void                SetAdmins(ADMINS *){};
204     void                SetTraffcounter(TRAFFCOUNTER *){};
205     void                SetStore(BASE_STORE *){};
206     void                SetStgSettings(const SETTINGS * s) { stgSettings = s; };
207     void                SetSettings(const MODULE_SETTINGS & s) { settings = s; };
208     int                 ParseSettings();
209
210     int                 Start();
211     int                 Stop();
212     int                 Reload() { return 0; };
213     bool                IsRunning() { return isRunningRunTimeouter || isRunningRun; };
214
215     const string      & GetStrError() const { return errorStr; };
216     const string        GetVersion() const { return "InetAccess authorization plugin v.1.4"; };
217     uint16_t            GetStartPosition() const { return 50; };
218     uint16_t            GetStopPosition() const { return 50; };
219
220     void                DelUser(user_iter u);
221
222     int                 SendMessage(const STG_MSG & msg, uint32_t ip) const;
223
224 private:
225     static void *       Run(void *);
226     static void *       RunTimeouter(void * d);
227     int                 PrepareNet();
228     int                 FinalizeNet();
229     int                 RecvData(char * buffer, int bufferSize);
230     int                 CheckHeader(const char * buffer, int * protoVer);
231     int                 PacketProcessor(char * buff, int dataLen, uint32_t sip, uint16_t sport, int protoVer, user_iter * user);
232
233     int                 Process_CONN_SYN_6(CONN_SYN_6 * connSyn, IA_USER * iaUser, user_iter * user, uint32_t sip);
234     int                 Process_CONN_SYN_7(CONN_SYN_7 * connSyn, IA_USER * iaUser, user_iter * user, uint32_t sip);
235     int                 Process_CONN_SYN_8(CONN_SYN_8 * connSyn, IA_USER * iaUser, user_iter * user, uint32_t sip);
236
237     int                 Process_CONN_ACK_6(CONN_ACK_6 * connAck, IA_USER * iaUser, user_iter * user, uint32_t sip);
238     int                 Process_CONN_ACK_7(CONN_ACK_7 * connAck, IA_USER * iaUser, user_iter * user, uint32_t sip);
239     int                 Process_CONN_ACK_8(CONN_ACK_8 * connAck, IA_USER * iaUser, user_iter * user, uint32_t sip);
240
241     int                 Process_ALIVE_ACK_6(ALIVE_ACK_6 * aliveAck, IA_USER * iaUser, user_iter * user, uint32_t sip);
242     int                 Process_ALIVE_ACK_7(ALIVE_ACK_7 * aliveAck, IA_USER * iaUser, user_iter * user, uint32_t sip);
243     int                 Process_ALIVE_ACK_8(ALIVE_ACK_8 * aliveAck, IA_USER * iaUser, user_iter * user, uint32_t sip);
244
245     int                 Process_DISCONN_SYN_6(DISCONN_SYN_6 * disconnSyn, IA_USER * iaUser, user_iter * user, uint32_t sip);
246     int                 Process_DISCONN_SYN_7(DISCONN_SYN_7 * disconnSyn, IA_USER * iaUser, user_iter * user, uint32_t sip);
247     int                 Process_DISCONN_SYN_8(DISCONN_SYN_8 * disconnSyn, IA_USER * iaUser, user_iter * user, uint32_t sip);
248
249     int                 Process_DISCONN_ACK_6(DISCONN_ACK_6 * disconnSyn,
250                                               IA_USER * iaUser,
251                                               user_iter * user,
252                                               uint32_t sip,
253                                               map<uint32_t, IA_USER>::iterator it);
254     int                 Process_DISCONN_ACK_7(DISCONN_ACK_7 * disconnSyn,
255                                               IA_USER * iaUser,
256                                               user_iter * user,
257                                               uint32_t sip,
258                                               map<uint32_t, IA_USER>::iterator it);
259     int                 Process_DISCONN_ACK_8(DISCONN_ACK_8 * disconnSyn,
260                                               IA_USER * iaUser,
261                                               user_iter * user,
262                                               uint32_t sip,
263                                               map<uint32_t, IA_USER>::iterator it);
264
265     int                 Send_CONN_SYN_ACK_6(IA_USER * iaUser, user_iter * user, uint32_t sip);
266     int                 Send_CONN_SYN_ACK_7(IA_USER * iaUser, user_iter * user, uint32_t sip);
267     int                 Send_CONN_SYN_ACK_8(IA_USER * iaUser, user_iter * user, uint32_t sip);
268
269     int                 Send_ALIVE_SYN_6(IA_USER * iaUser, uint32_t sip);
270     int                 Send_ALIVE_SYN_7(IA_USER * iaUser, uint32_t sip);
271     int                 Send_ALIVE_SYN_8(IA_USER * iaUser, uint32_t sip);
272
273     int                 Send_DISCONN_SYN_ACK_6(IA_USER * iaUser, uint32_t sip);
274     int                 Send_DISCONN_SYN_ACK_7(IA_USER * iaUser, uint32_t sip);
275     int                 Send_DISCONN_SYN_ACK_8(IA_USER * iaUser, uint32_t sip);
276
277     int                 Send_FIN_6(IA_USER * iaUser, uint32_t sip, map<uint32_t, IA_USER>::iterator it);
278     int                 Send_FIN_7(IA_USER * iaUser, uint32_t sip, map<uint32_t, IA_USER>::iterator it);
279     int                 Send_FIN_8(IA_USER * iaUser, uint32_t sip, map<uint32_t, IA_USER>::iterator it);
280
281     int                 Timeouter();
282
283     void                InitEncrypt(BLOWFISH_CTX * ctx, const string & password);
284     void                Decrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8);
285     void                Encrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8);
286
287     int                 SendError(uint32_t ip, uint16_t port, int protoVer, const string & text);
288     int                 Send(uint32_t ip, uint16_t port, const char * buffer, int len);
289     int                 RealSendMessage6(const STG_MSG & msg, uint32_t ip, IA_USER & user);
290     int                 RealSendMessage7(const STG_MSG & msg, uint32_t ip, IA_USER & user);
291     int                 RealSendMessage8(const STG_MSG & msg, uint32_t ip, IA_USER & user);
292
293     bool                WaitPackets(int sd) const;
294
295     BLOWFISH_CTX        ctxS;        //for loginS
296
297     mutable string      errorStr;
298     AUTH_IA_SETTINGS    iaSettings;
299     MODULE_SETTINGS     settings;
300
301     bool                nonstop;
302
303     bool                isRunningRun;
304     bool                isRunningRunTimeouter;
305
306     USERS *             users;
307     const SETTINGS *    stgSettings;
308
309     mutable map<uint32_t, IA_USER>  ip2user;
310
311     pthread_t           recvThread;
312     pthread_t           timeouterThread;
313     mutable pthread_mutex_t mutex;
314
315     int                 listenSocket;
316
317     CONN_SYN_ACK_6      connSynAck6;
318     CONN_SYN_ACK_8      connSynAck8;
319
320     DISCONN_SYN_ACK_6   disconnSynAck6;
321     DISCONN_SYN_ACK_8   disconnSynAck8;
322
323     ALIVE_SYN_6         aliveSyn6;
324     ALIVE_SYN_8         aliveSyn8;
325     FIN_6               fin6;
326     FIN_8               fin8;
327
328     map<string, int>    packetTypes;
329
330     STG_LOGGER &        WriteServLog;
331
332     uint32_t            enabledDirs;
333
334     class DEL_USER_NONIFIER: public NOTIFIER_BASE<user_iter>
335     {
336     public:
337         DEL_USER_NONIFIER(AUTH_IA & a) : auth(a) {};
338         virtual ~DEL_USER_NONIFIER(){};
339
340         void Notify(const user_iter & user)
341             {
342             auth.DelUser(user);
343             }
344
345     private:
346         AUTH_IA & auth;
347     } onDelUserNotifier;
348
349     class UnauthorizeUser : std::unary_function<const std::pair<uint32_t, IA_USER> &, void> {
350         public:
351             UnauthorizeUser(AUTH_IA * a) : auth(a) {};
352             void operator()(const std::pair<uint32_t, IA_USER> & p)
353             {
354                 p.second.user->Unauthorize(auth);
355             }
356         private:
357             AUTH_IA * auth;
358     };
359
360 };
361 //-----------------------------------------------------------------------------
362
363 #endif
364
365