D:/pwsrc2.0/docs/gauthd/gmysqlclient.hpp

Go to the documentation of this file.

 
 #ifndef __GNET_GMYSQLCLIENT_HPP
 #define __GNET_GMYSQLCLIENT_HPP
 
 #include <mysql/mysql.h>
 #include <vector>
 #include "protocol.h"
 #include "thread.h"
 #include "timersender.h"
 #include "octets.h"
 #include "base64.h"
 
 using namespace GNET;
 
 class GMysqlClient
 {
 private:
     bool active;                
     int mysql_state;            
     pthread_mutex_t mysql_mutex;
     pthread_mutex_t online_mutex;
     pthread_mutex_t cash_mutex; 
     pthread_mutex_t antibrut_mutex;
     
     MYSQL *DBMysql;            
     MYSQL_RES * result;        
     MYSQL_ROW row;             
     int query_state;           
 
     // Конфигурационные параметры
     char ip[20];              
     int  port;                
     char user[128];           
     char passwd[128];         
     char db[128];             
     int  hash;                
 
     char zoneid;              
     char aid;                 
     
     bool lkmod;               
     bool loginlog;            
     char logoutshell[1024];   
     
     struct ONLINE_USER
     {
         int userid;           
         int zoneid;           
         int ipaddr;           
         char login[64];       
 
         ONLINE_USER(int userid, int zoneid, char * login, int ipaddr)
         {
             this->userid = userid;
             this->zoneid = zoneid;
             this->ipaddr = ipaddr;
             memset(this->login,0x00,64);
             memcpy(this->login,login,strlen(login));
         }
     };  
     std::vector <ONLINE_USER> online_user; 
     
     struct CASH_USER
     {
         int userid;           
         int zoneid;           
         int sn;               
         int point;            
         int cash;             
         char creatime[20];    
 
         CASH_USER(int userid, int zoneid, int sn, int point, int cash, char * creatime)
         {
             this->userid = userid;
             this->zoneid = zoneid;
             this->cash = cash;
             this->sn = sn;
             this->point = point;
             memset(this->creatime,0x00,20);
             memcpy(this->creatime,creatime,19);
         }
     };  
     std::vector <CASH_USER> cash_user; 
 
     struct ANTIBRUT_USER
     {
         int ip;               
         int count;           
 
         ANTIBRUT_USER(int ip)
         {
             this->ip = ip;
             this->count = 0;
         }
     };  
     std::vector <ANTIBRUT_USER> antibrut_user; 
 
 public:
     void Init(const char * ip, const int port, const char * user, const char * passwd, const char * db, const int h);
     
     void AlexPatch(const bool lkmod, const bool log, const char * shell);
     
     bool Connect();           
     void Disconnect();        
     bool IsActive() { return active; } 
     char GetAid() { return aid; }      
     char GetZoneid() { return zoneid; }
     
     bool MysqlQuery(char * ptr, size_t len);
     
     // Далее идут методы для работы с базой данных
     bool DeleteErrorRow(int status, int uid, char * creatime);
     bool MatrixPasswd(int &uid, char * login, char * passwd, int ipaddr);
     bool ClearOnlineRecord(char zoneid, char aid);
     bool OnlineRecord(int uid, char aid, char &zoneid, int &zonelocalid, int &overwrite);
     bool OnfflineRecord(int uid, char aid, char &zoneid, int &zonelocalid, int &overwrite);
     bool UserCreatime(int uid, int &timestamp);
     bool UserGMPrivilege(int uid, char zoneid, bool &IsGM);
     bool QueryGMPrivilege(int uid, char zoneid, unsigned char * gm_auth, int &count);
     bool GetUseCashNow(int status, int &count);
     bool SetUseCashNow(int status, int sn, int userid, char * creatime);
     bool DelUseCashNow(int status, int uid, int sn);
     bool AddCashLog(int uid, int zoneid, int sn, int aid, int point, int cash, int status, char * creatime);
     bool AlexAddLogin(int uid, int action);
     bool AlexShell(int uid);
     
     inline int GetUser(int userid)
     {
         int res = -1;
         pthread_mutex_lock(&online_mutex);
         for (unsigned int i = 0; i < online_user.size(); i++)
         if  (online_user.at(i).userid == userid) res = i;
         pthread_mutex_unlock(&online_mutex);
         return res;
     }
     
     inline int DelUser(int userid)
     {
         int idx =  GetUser(userid);
         pthread_mutex_lock(&online_mutex);
         if( idx >= 0)
         online_user.erase(online_user.begin() + idx);
         pthread_mutex_unlock(&online_mutex);
         return idx;
     }
     
     inline int AddUser(int userid, int zoneid, char * login, int ipaddr)
     {
         DelUser(userid);
         pthread_mutex_lock(&online_mutex);
         online_user.push_back(ONLINE_USER(userid,zoneid,login,ipaddr));
         pthread_mutex_unlock(&online_mutex);
         return GetUser(userid);
     }    
     
     inline ONLINE_USER * GetUserData(int userid)
     {
         int idx =  GetUser(userid);
         if( idx >= 0)
         return &online_user.at(idx);
         return NULL;
     }
     
     // Методы для работы с кэшем
     inline int ClearCash()
     {
         pthread_mutex_lock(&cash_mutex);
         cash_user.clear();
         pthread_mutex_unlock(&cash_mutex);
     }
     
     inline int GetCashSize()
     { 
         int size = 0;
         pthread_mutex_lock(&cash_mutex);
         size = cash_user.size();
         pthread_mutex_unlock(&cash_mutex);
         return size;
     }
     
     inline void DelCashUser(int idx)
     {
         pthread_mutex_lock(&cash_mutex);
         if( idx >= 0 && idx < cash_user.size() )
         {
             cash_user.erase(cash_user.begin() + idx);
         }
         pthread_mutex_unlock(&cash_mutex);
     }
     
     inline void AddCashUser(int userid, int zoneid, int sn, int point, int cash, char * creatime)
     {
         pthread_mutex_lock(&cash_mutex);
         if(creatime)
         cash_user.push_back(CASH_USER( userid,zoneid,sn,point,cash,creatime));
         pthread_mutex_unlock(&cash_mutex);
     }
 
     inline int GetCashUser(int userid)
     {
         int res = -1;
         pthread_mutex_lock(&cash_mutex);
         for (unsigned int i = 0; i < cash_user.size(); i++)
         if  (cash_user.at(i).userid == userid) res = i;
         pthread_mutex_unlock(&cash_mutex);
         return res;
     }
 
     inline void GetAllCashUser(int idx, int &userid, int &zoneid)
     {
         pthread_mutex_lock(&cash_mutex);
         if ( idx >= 0 && idx < cash_user.size() )
         {
             userid = cash_user.at(idx).userid;
             zoneid = cash_user.at(idx).zoneid;
         }
         pthread_mutex_unlock(&cash_mutex);
     }
         
     inline char * GetCashCreaTime(int idx)
     {
         char * creatime = NULL;
         pthread_mutex_lock(&cash_mutex);
         if( idx >= 0 && idx < cash_user.size() )
         creatime = cash_user.at(idx).creatime;
         pthread_mutex_unlock(&cash_mutex);
         return creatime;
     }
     
     inline int GetCashCash(int idx)
     {
         int res = 0;
         pthread_mutex_lock(&cash_mutex);
         if( idx >= 0 && idx < cash_user.size() )
         res = cash_user.at(idx).cash;
         pthread_mutex_unlock(&cash_mutex);
         return res;    
     }
 
     inline int GetCashPoint(int idx)
     {
         int res = 0;
         pthread_mutex_lock(&cash_mutex);
         if( idx >= 0 && idx < cash_user.size() )
         res = cash_user.at(idx).point;
         pthread_mutex_unlock(&cash_mutex);
         return res;
     }    
 
     // Методы для защиты от brute-force
     inline void ClearAntibrutUser()
     {
         pthread_mutex_lock(&antibrut_mutex);
         antibrut_user.clear();
         pthread_mutex_unlock(&antibrut_mutex);
     }
     
     inline int SizeAntibrutUser()
     {
         int res = 0;
         pthread_mutex_lock(&antibrut_mutex);
         res = antibrut_user.size();
         pthread_mutex_unlock(&antibrut_mutex);
         return res;
     }
     
     inline int GetAntibrutUser(int ip)
     {
         int res = -1;
         pthread_mutex_lock(&antibrut_mutex);
         for (unsigned int i = 0; i < antibrut_user.size(); i++)
         if  (antibrut_user.at(i).ip == ip) res = i;
         pthread_mutex_unlock(&antibrut_mutex);
         return res;
     }
     
     inline int DelAntibrutUser(int ip)
     {
         int idx = GetAntibrutUser(ip);
         pthread_mutex_lock(&antibrut_mutex);
         if( idx >= 0)
         antibrut_user.erase(antibrut_user.begin() + idx);
         pthread_mutex_unlock(&antibrut_mutex);
         return idx;
     }    
     
     inline int AddAntibrutUser(int ip)
     {
         int res = 0;
         int idx = GetAntibrutUser(ip);
         pthread_mutex_lock(&antibrut_mutex);
         if( idx >= 0)
         res = ++antibrut_user.at(idx).count;
         else
         antibrut_user.push_back(ANTIBRUT_USER(ip));
         pthread_mutex_unlock(&antibrut_mutex);
         return res;
     }
     
     // Вспомогательные методы
     inline int ATOI(const char * ptr)
     {
         if(ptr) 
         return atoi(ptr);
         return 0;
     }
 
     inline void Auth0xMD5(char * out, char * in)
     {
         int nt = 0;
         if(in[0] == '0' && in[1] == 'x') in += 2;
         for(int i = 0; i < 16; ++i)
         {
             sscanf(&in[i*2], "%02x", &nt);
             out[i] = (char)nt;
         }
     }
 
     inline void AuthBase64(char * passwd, char * auth)
     {
         Octets in;
         Octets out;
         in.replace(auth, strlen(auth));
         Base64Decoder::Convert(out, in);
         memcpy(passwd,out.begin(),16);
     }
 
     inline bool AuthPasswd(char * passwd, char * auth)
     {
         switch (hash)
         {
         case 1: //binary
             memcpy(passwd,auth,16); 
             return true;
         case 2: //0xMD5
             Auth0xMD5(passwd,auth); 
             return true;
         case 3: //base64
             AuthBase64(passwd,auth);
             return true;
         default:
             break;
         }
         return false;
     }
 
     bool ValidLogin(char * login, int size)
     {
         for (int i = 0; i < size && i < 32; i++)
         {
             if( !(login[i] >= '0' && login[i] <= '9') &&
                 !(login[i] >= 'A' && login[i] <= 'Z') &&
                 !(login[i] >= 'a' && login[i] <= 'z')  )
             return false;
         }
         return true;
     }
 
     void AddrToStr(unsigned int ip, char * address)
     {    
         unsigned char bytes[4];
         bytes[0] = ip & 0xFF;
         bytes[1] = (ip >> 8) & 0xFF;
         bytes[2] = (ip >> 16) & 0xFF;
         bytes[3] = (ip >> 24) & 0xFF;
         sprintf(address,"%d.%d.%d.%d", bytes[3], bytes[2], bytes[1], bytes[0]);
     }
 
     static GMysqlClient * GetInstance()
     {
         if (!instance)
         instance = new GMysqlClient();
         return instance;
     }
     static GMysqlClient * instance; 
 };
 
 #endif