#include <functional>
#include <utility>
-#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"
+#include "stg/os_int.h"
+#include "stg/auth.h"
+#include "stg/store.h"
+#include "stg/notifer.h"
+#include "stg/user_ips.h"
+#include "stg/user.h"
+#include "stg/users.h"
+#include "stg/ia_packets.h"
+#include "stg/blowfish.h"
+#include "stg/logger.h"
+#include "stg/utime.h"
extern "C" PLUGIN * GetPlugin();
//-----------------------------------------------------------------------------
struct IA_USER {
IA_USER()
- : lastSendAlive(0),
+ : login(),
+ user(NULL),
+ phase(),
+ lastSendAlive(0),
rnd(random()),
port(0),
+ ctx(),
+ messagesToSend(),
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
+ unsigned char keyL[PASSWD_LEN];
+ memset(keyL, 0, PASSWD_LEN);
+ strncpy((char *)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));
};
- USER_PTR user;
+ IA_USER(const std::string & l,
+ CONST_USER_PTR u,
+ uint16_t p,
+ int ver)
+ : login(l),
+ user(u),
+ phase(),
+ lastSendAlive(0),
+ rnd(random()),
+ port(p),
+ ctx(),
+ messagesToSend(),
+ protoVer(ver),
+ password(user->GetProperty().password.Get())
+ {
+ unsigned char keyL[PASSWD_LEN];
+ memset(keyL, 0, PASSWD_LEN);
+ strncpy((char *)keyL, password.c_str(), PASSWD_LEN);
+ Blowfish_Init(&ctx, keyL, PASSWD_LEN);
+
+ #ifdef IA_DEBUG
+ aliveSent = false;
+ #endif
+ }
+
+ std::string login;
+ CONST_USER_PTR user;
IA_PHASE phase;
UTIME lastSendAlive;
uint32_t rnd;
#ifdef IA_DEBUG
bool aliveSent;
#endif
+
+private:
+ IA_USER & operator=(const IA_USER & rvalue);
};
//-----------------------------------------------------------------------------
class AUTH_IA_SETTINGS {
FREEMB GetFreeMbShowType() const { return freeMbShowType; };
private:
- int ParseIntInRange(const std::string & str, int min, int max, int * val);
int userDelay;
int userTimeout;
uint16_t port;
void Notify(const USER_PTR & user);
private:
+ DEL_USER_NOTIFIER(const DEL_USER_NOTIFIER & rvalue);
+ DEL_USER_NOTIFIER & operator=(const DEL_USER_NOTIFIER & rvalue);
+
AUTH_IA & auth;
};
//-----------------------------------------------------------------------------
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();
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; }
+ uint16_t GetStartPosition() const { return 30; }
+ uint16_t GetStopPosition() const { return 30; }
int SendMessage(const STG_MSG & msg, uint32_t ip) const;
private:
+ AUTH_IA(const AUTH_IA & rvalue);
+ AUTH_IA & operator=(const AUTH_IA & rvalue);
+
static void * Run(void *);
static void * RunTimeouter(void * d);
int PrepareNet();
void DelUser(USER_PTR 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 PacketProcessor(char * buff, int dataLen, uint32_t sip, uint16_t sport, int protoVer, USER_PTR 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 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;
-
BLOWFISH_CTX ctxS; //for loginS
mutable std::string errorStr;
DEL_USER_NOTIFIER onDelUserNotifier;
- 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;
- };
-
+ friend class UnauthorizeUser;
+};
+//-----------------------------------------------------------------------------
+class UnauthorizeUser : std::unary_function<const std::pair<uint32_t, IA_USER> &, void> {
+ public:
+ 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;
};
//-----------------------------------------------------------------------------
inline
git.stg.codes / stg.git / blobdiff