/*
* Author : Boris Mikhailenko <stg34@stargazer.dp.ua>
*/
-
-/*
- $Revision: 1.34 $
- $Date: 2010/09/10 06:39:19 $
- $Author: faust $
- */
-
-#ifndef INETACCESS_H
-#define INETACCESS_H
-
-#include <sys/time.h>
-#include <pthread.h>
+#pragma once
+
+#include "stg/auth.h"
+#include "stg/store.h"
+#include "stg/module_settings.h"
+#include "stg/user_ips.h"
+#include "stg/user.h"
+#include "stg/users.h"
+#include "stg/user_property.h"
+#include "stg/ia_packets.h"
+#include "stg/blowfish.h"
+#include "stg/logger.h"
+#include "stg/utime.h"
+#include "stg/logger.h"
#include <cstring>
#include <ctime>
+#include <cstdint>
#include <string>
#include <map>
#include <list>
#include <functional>
#include <utility>
+#include <mutex>
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#include <jthread.hpp>
+#pragma GCC diagnostic pop
-#include "os_int.h"
-#include "auth.h"
-#include "store.h"
-#include "notifer.h"
-#include "user_ips.h"
-#include "user.h"
-#include "users.h"
-#include "ia_packets.h"
-#include "blowfish.h"
-#include "stg_logger.h"
-#include "utime.h"
-
-extern "C" PLUGIN * GetPlugin();
-
-#define IA_PROTO_VER (6)
+#include <sys/time.h>
//#define IA_DEBUG (1)
//#define IA_PHASE_DEBUG (1)
void SetPhase2();
void SetPhase3();
void SetPhase4();
- void SetPhase5();
int GetPhase() const;
void UpdateTime();
};
//-----------------------------------------------------------------------------
struct IA_USER {
+ using ConstUserPtr = const STG::User*;
IA_USER()
- : lastSendAlive(0),
- rnd(random()),
+ : user(NULL),
+ lastSendAlive(0),
+ rnd(static_cast<uint32_t>(random())),
port(0),
protoVer(0),
password("NO PASSWORD")
{
- // +++ Preparing CTX +++
- unsigned char keyL[PASSWD_LEN];
- memset(keyL, 0, PASSWD_LEN);
- strncpy((char *)keyL, password.c_str(), PASSWD_LEN);
- Blowfish_Init(&ctx, keyL, PASSWD_LEN);
- // --- Preparing CTX ---
- #ifdef IA_DEBUG
- aliveSent = false;
- #endif
- };
+ char keyL[PASSWD_LEN];
+ memset(keyL, 0, PASSWD_LEN);
+ strncpy(keyL, password.c_str(), PASSWD_LEN);
+ Blowfish_Init(&ctx, keyL, PASSWD_LEN);
+
+ #ifdef IA_DEBUG
+ aliveSent = false;
+ #endif
+ }
IA_USER(const IA_USER & u)
- : user(u.user),
+ : login(u.login),
+ user(u.user),
phase(u.phase),
lastSendAlive(u.lastSendAlive),
rnd(u.rnd),
port(u.port),
+ ctx(),
messagesToSend(u.messagesToSend),
protoVer(u.protoVer),
password(u.password)
{
- #ifdef IA_DEBUG
- aliveSent = u.aliveSent;
- #endif
- memcpy(&ctx, &u.ctx, sizeof(BLOWFISH_CTX));
- };
+ #ifdef IA_DEBUG
+ aliveSent = u.aliveSent;
+ #endif
+ memcpy(&ctx, &u.ctx, sizeof(BLOWFISH_CTX));
+ }
+
+ IA_USER(const std::string & l,
+ ConstUserPtr u,
+ uint16_t p,
+ int ver)
+ : login(l),
+ user(u),
+ lastSendAlive(0),
+ rnd(static_cast<uint32_t>(random())),
+ port(p),
+ messagesToSend(),
+ protoVer(ver),
+ password(user->GetProperties().password.Get())
+ {
+ char keyL[PASSWD_LEN];
+ memset(keyL, 0, PASSWD_LEN);
+ strncpy(keyL, password.c_str(), PASSWD_LEN);
+ Blowfish_Init(&ctx, keyL, PASSWD_LEN);
+
+ #ifdef IA_DEBUG
+ aliveSent = false;
+ #endif
+ }
- USER_PTR user;
+ std::string login;
+ ConstUserPtr user;
IA_PHASE phase;
UTIME lastSendAlive;
uint32_t rnd;
uint16_t port;
BLOWFISH_CTX ctx;
- std::list<STG_MSG> messagesToSend;
+ std::vector<STG::Message> messagesToSend;
int protoVer;
std::string password;
#ifdef IA_DEBUG
bool aliveSent;
#endif
+
+private:
+ IA_USER & operator=(const IA_USER & rvalue);
};
//-----------------------------------------------------------------------------
class AUTH_IA_SETTINGS {
public:
AUTH_IA_SETTINGS();
- virtual ~AUTH_IA_SETTINGS() {};
- const std::string & GetStrError() const { return errorStr; };
- int ParseSettings(const MODULE_SETTINGS & s);
- int GetUserDelay() const { return userDelay; };
- int GetUserTimeout() const { return userTimeout; };
- int GetUserPort() const { return port; };
- FREEMB GetFreeMbShowType() const { return freeMbShowType; };
+ virtual ~AUTH_IA_SETTINGS() {}
+ const std::string & GetStrError() const { return errorStr; }
+ int ParseSettings(const STG::ModuleSettings & s);
+ UTIME GetUserDelay() const { return UTIME(userDelay); }
+ UTIME GetUserTimeout() const { return UTIME(userTimeout); }
+ uint16_t GetUserPort() const { return port; }
+ FREEMB GetFreeMbShowType() const { return freeMbShowType; }
+ bool LogProtocolErrors() const { return logProtocolErrors; }
private:
- int ParseIntInRange(const std::string & str, int min, int max, int * val);
int userDelay;
int userTimeout;
uint16_t port;
std::string errorStr;
FREEMB freeMbShowType;
+ bool logProtocolErrors;
};
//-----------------------------------------------------------------------------
class AUTH_IA;
+using UserPtr = STG::User*;
//-----------------------------------------------------------------------------
-class DEL_USER_NOTIFIER: public NOTIFIER_BASE<USER_PTR> {
-public:
- DEL_USER_NOTIFIER(AUTH_IA & a) : auth(a) {}
- virtual ~DEL_USER_NOTIFIER() {}
-
- void Notify(const USER_PTR & user);
-private:
- AUTH_IA & auth;
-};
-//-----------------------------------------------------------------------------
-class AUTH_IA :public AUTH {
-friend class DEL_USER_NOTIFIER;
+class AUTH_IA : public STG::Auth {
public:
AUTH_IA();
- virtual ~AUTH_IA();
-
- void SetUsers(USERS * u) { users = u; }
- void SetTariffs(TARIFFS *) {}
- void SetAdmins(ADMINS *) {}
- void SetTraffcounter(TRAFFCOUNTER *) {}
- void SetStore(STORE *) {}
- void SetStgSettings(const SETTINGS * s) { stgSettings = s; }
- void SetSettings(const MODULE_SETTINGS & s) { settings = s; }
- int ParseSettings();
-
- int Start();
- int Stop();
- int Reload() { return 0; }
- bool IsRunning() { return isRunningRunTimeouter || isRunningRun; }
+ ~AUTH_IA() override;
- const std::string & GetStrError() const { return errorStr; }
- const std::string GetVersion() const { return "InetAccess authorization plugin v.1.4"; }
- uint16_t GetStartPosition() const { return 50; }
- uint16_t GetStopPosition() const { return 50; }
+ void SetUsers(STG::Users * u) override { users = u; }
+ void SetStgSettings(const STG::Settings * s) override { stgSettings = s; }
+ void SetSettings(const STG::ModuleSettings & s) override { settings = s; }
+ int ParseSettings() override;
- int SendMessage(const STG_MSG & msg, uint32_t ip) const;
+ int Start() override;
+ int Stop() override;
+ int Reload(const STG::ModuleSettings & ms) override;
+ bool IsRunning() override { return isRunningRunTimeouter || isRunningRun; }
+
+ const std::string & GetStrError() const override { return errorStr; }
+ std::string GetVersion() const override { return "InetAccess authorization plugin v.1.4"; }
+ uint16_t GetStartPosition() const override { return 30; }
+ uint16_t GetStopPosition() const override { return 30; }
+
+ int SendMessage(const STG::Message & msg, uint32_t ip) const override;
private:
- static void * Run(void *);
- static void * RunTimeouter(void * d);
+ AUTH_IA(const AUTH_IA & rvalue);
+ AUTH_IA & operator=(const AUTH_IA & rvalue);
+
+ void Run(std::stop_token token);
+ void RunTimeouter(std::stop_token token);
int PrepareNet();
int FinalizeNet();
- void DelUser(USER_PTR u);
+ void DelUser(UserPtr u);
int RecvData(char * buffer, int bufferSize);
- int CheckHeader(const char * buffer, int * protoVer);
- int PacketProcessor(char * buff, int dataLen, uint32_t sip, uint16_t sport, int protoVer, USER_PTR * user);
+ int CheckHeader(const char * buffer, uint32_t sip, int * protoVer);
+ int PacketProcessor(void * buff, size_t dataLen, uint32_t sip, uint16_t sport, int protoVer, UserPtr user);
int Process_CONN_SYN_6(CONN_SYN_6 * connSyn, IA_USER * iaUser, uint32_t sip);
int Process_CONN_SYN_7(CONN_SYN_7 * connSyn, IA_USER * iaUser, uint32_t sip);
int Process_DISCONN_ACK_6(DISCONN_ACK_6 * disconnSyn,
IA_USER * iaUser,
uint32_t sip,
- map<uint32_t, IA_USER>::iterator it);
+ std::map<uint32_t, IA_USER>::iterator it);
int Process_DISCONN_ACK_7(DISCONN_ACK_7 * disconnSyn,
IA_USER * iaUser,
uint32_t sip,
- map<uint32_t, IA_USER>::iterator it);
+ std::map<uint32_t, IA_USER>::iterator it);
int Process_DISCONN_ACK_8(DISCONN_ACK_8 * disconnSyn,
IA_USER * iaUser,
uint32_t sip,
- map<uint32_t, IA_USER>::iterator it);
+ std::map<uint32_t, IA_USER>::iterator it);
int Send_CONN_SYN_ACK_6(IA_USER * iaUser, uint32_t sip);
int Send_CONN_SYN_ACK_7(IA_USER * iaUser, uint32_t sip);
int Send_DISCONN_SYN_ACK_7(IA_USER * iaUser, uint32_t sip);
int Send_DISCONN_SYN_ACK_8(IA_USER * iaUser, uint32_t sip);
- int Send_FIN_6(IA_USER * iaUser, uint32_t sip, map<uint32_t, IA_USER>::iterator it);
- int Send_FIN_7(IA_USER * iaUser, uint32_t sip, map<uint32_t, IA_USER>::iterator it);
- int Send_FIN_8(IA_USER * iaUser, uint32_t sip, map<uint32_t, IA_USER>::iterator it);
+ int Send_FIN_6(IA_USER * iaUser, uint32_t sip, std::map<uint32_t, IA_USER>::iterator it);
+ int Send_FIN_7(IA_USER * iaUser, uint32_t sip, std::map<uint32_t, IA_USER>::iterator it);
+ int Send_FIN_8(IA_USER * iaUser, uint32_t sip, std::map<uint32_t, IA_USER>::iterator it);
int Timeouter();
int SendError(uint32_t ip, uint16_t port, int protoVer, const std::string & text);
- int Send(uint32_t ip, uint16_t port, const char * buffer, int len);
- int RealSendMessage6(const STG_MSG & msg, uint32_t ip, IA_USER & user);
- int RealSendMessage7(const STG_MSG & msg, uint32_t ip, IA_USER & user);
- int RealSendMessage8(const STG_MSG & msg, uint32_t ip, IA_USER & user);
-
- bool WaitPackets(int sd) const;
+ int Send(uint32_t ip, uint16_t port, const void* buffer, size_t len);
+ int RealSendMessage6(const STG::Message & msg, uint32_t ip, IA_USER & user);
+ int RealSendMessage7(const STG::Message & msg, uint32_t ip, IA_USER & user);
+ int RealSendMessage8(const STG::Message & msg, uint32_t ip, IA_USER & user);
BLOWFISH_CTX ctxS; //for loginS
mutable std::string errorStr;
AUTH_IA_SETTINGS iaSettings;
- MODULE_SETTINGS settings;
-
- bool nonstop;
+ STG::ModuleSettings settings;
bool isRunningRun;
bool isRunningRunTimeouter;
- USERS * users;
- const SETTINGS * stgSettings;
+ STG::Users * users;
+ const STG::Settings * stgSettings;
mutable std::map<uint32_t, IA_USER> ip2user;
- pthread_t recvThread;
- pthread_t timeouterThread;
- mutable pthread_mutex_t mutex;
+ std::jthread m_thread;
+ std::jthread m_timeouterThread;
+ mutable std::mutex m_mutex;
int listenSocket;
std::map<std::string, int> packetTypes;
- STG_LOGGER & WriteServLog;
-
uint32_t enabledDirs;
- DEL_USER_NOTIFIER onDelUserNotifier;
+ STG::ScopedConnection m_onDelUserConn;
- class UnauthorizeUser : std::unary_function<const std::pair<uint32_t, IA_USER> &, void> {
- public:
- UnauthorizeUser(AUTH_IA * a) : auth(a) {}
- void operator()(const std::pair<uint32_t, IA_USER> & p)
- {
- p.second.user->Unauthorize(auth);
- }
- private:
- AUTH_IA * auth;
- };
+ STG::PluginLogger logger;
+ friend class UnauthorizeUser;
};
//-----------------------------------------------------------------------------
-inline
-void DEL_USER_NOTIFIER::Notify(const USER_PTR & user)
-{
- auth.DelUser(user);
-}
-
-#endif
+class UnauthorizeUser : std::unary_function<const std::pair<uint32_t, IA_USER> &, void> {
+ public:
+ explicit UnauthorizeUser(AUTH_IA * a) : auth(a) {}
+ UnauthorizeUser(const UnauthorizeUser & rvalue) : auth(rvalue.auth) {}
+ void operator()(const std::pair<uint32_t, IA_USER> & p)
+ {
+ auth->users->Unauthorize(p.second.user->GetLogin(), auth);
+ }
+ private:
+ UnauthorizeUser & operator=(const UnauthorizeUser & rvalue);
+
+ AUTH_IA * auth;
+};
git.stg.codes / stg.git / blobdiff