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