Changeset 509

Show
Ignore:
Timestamp:
04/10/06 15:35:52 (3 years ago)
Author:
common
Message:

library
- working on gotek2

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • library/trunk/modules/service-gotek2/service-gotek2.cpp

    r504 r509  
    163163        m_ConsumeLevel = CL_ASSIGN; 
    164164 
    165     m_State = GCS_VIRGIN; 
     165    m_State            = GCS_VIRGIN; 
    166166        m_ClientType    = GCT_UNKNOWN; 
    167167 
    168     char szHandshake[2] =  
    169                 {  
    170                         1,                              // high proto  
    171                         1,                              // low proto 
    172                 };  
    173  
    174         m_Socket->doWrite((char *)szHandshake,4); 
    175  
    176         m_SessionKey = (((unsigned long long) time(0)) << 48) | (((unsigned long long) (rand() & 0xFF)) << 32); 
    177     m_SessionKey |= (unsigned long long) rand(); 
    178         m_Socket->doWrite((char *)&m_SessionKey,8); 
    179  
    180         char *serversoftware = "Library going gotek"; 
    181         m_Socket->doWrite((char *)serversoftware,strlen(serversoftware)+1); 
    182  
    183         char *serverdescription = "none"; 
    184         m_Socket->doWrite((char *)serverdescription,strlen(serverdescription)+1); 
    185                  
    186168} 
    187169 
     
    211193        logPF(); 
    212194        m_Buffer.append(msg->getMsg(),msg->getSize()); 
    213  
    214         return CL_ASSIGN; 
    215 
     195    return process(); 
     196
     197 
     198 
     199 
     200 
     201ConsumeLevel ServiceGotek2Dialogue::process() 
     202
     203        logPF(); 
     204        ConsumeLevel cl = CL_ASSIGN; 
     205        bool needmoredata=false; 
     206        while ( needmoredata == false && cl == CL_ASSIGN ) 
     207        { 
     208                switch ( m_ClientType ) 
     209                { 
     210                case GCT_LOGIN: 
     211                        cl= processLOGIN(&needmoredata); 
     212                        break; 
     213 
     214                case GCT_CTRL: 
     215                        cl=processCTRL(&needmoredata); 
     216                        break; 
     217 
     218                case GCT_DATA: 
     219                        cl=processDATA(&needmoredata); 
     220                        break; 
     221                } 
     222        } 
     223        return cl; 
     224
     225 
     226ConsumeLevel ServiceGotek2Dialogue::processLOGIN(bool *needmoredata) 
     227
     228        logPF(); 
     229// verify the packet is complete 
     230 
     231        if (m_Buffer.size() < 5) 
     232        { 
     233                *needmoredata = true; 
     234                return CL_ASSIGN; 
     235        } 
     236 
     237        GotekPacket gp = GotekPacket(m_Buffer); 
     238 
     239        gp.readByte(); 
     240 
     241        if (m_Buffer.size() < gp.readUnsignedInt32() - 5 ) 
     242        { 
     243                *needmoredata = true; 
     244                return CL_ASSIGN; 
     245        } 
     246 
     247// parse the data 
     248        string hash; 
     249        unsigned char command; 
     250        try 
     251        { 
     252                gp.readString(); 
     253                gp.readString(); 
     254                m_Username = gp.readString(); 
     255                hash = pg.readRawString(64); 
     256                command = gp.readByte(); 
     257 
     258        } 
     259        catch ( GotekException e ) 
     260        { 
     261                return CL_DROP; 
     262        } 
     263 
     264// verfiy the data is sane 
     265        if ( command != CTYPE_CTRL && command != CTYPE_DATA ) 
     266        { 
     267                return CL_DROP; 
     268        } 
     269 
     270        for ( char * c = (char *)m_Username.c_str(); * c; ++c ) 
     271                 if ( !isalpha(* c) && * c != '.' && * c != '-' ) 
     272                         return CL_DROP; 
     273 
     274// create the query context so we know which query returns, so we can answer appropriate 
     275 
     276        SQLContext *sqlctx = new SQLContext(command,time(NULL)); 
     277 
     278// query  
     279         string query = "SELECT \"authkey\" FROM \"users-dp\".\"users\" WHERE username = '"; 
     280         query  += m_Username.c_str(); 
     281         query  += "';"; 
     282 
     283         SQLQuery *sqlquery = g_Library->getSQLMgr()->addQuery(&query,this,(void *)sqlctx); 
     284         m_QueryQueue.push_back(sqlquery); 
     285 
     286 
     287 
     288 
     289
     290 
     291 
     292 
     293 
     294 
     295ConsumeLevel ServiceGotek2Dialogue::processCTRL(bool *needmoredata) 
     296
     297        logPF();  
     298 
     299        if (m_Buffer.size() < 1 ) 
     300        { 
     301                *needmoredata = true; 
     302                return CL_ASSIGN; 
     303        } 
     304 
     305        if (m_Buffer[0] == CCMD_NOOP) 
     306        { 
     307        m_Buffer.erase(0,1); 
     308                return CL_ASSIGN; 
     309        } 
     310 
     311        if (m_Buffer.size() < 5) 
     312        { 
     313                *needmoredata = true; 
     314                return CL_ASSIGN; 
     315        } 
     316 
     317        ConsumeLevel cl = CL_ASSIGN; 
     318 
     319        GotekPacket gp = GotekPacket(m_Buffer); 
     320 
     321        uint8_t command = gp.readByte(); 
     322 
     323        if (m_Buffer.size() < gp.readUnsignedInt32() - 5 ) 
     324        { 
     325                *needmoredata = true; 
     326                 return CL_ASSIGN; 
     327        } 
     328 
     329        try 
     330        { 
     331                switch ( command ) 
     332                { 
     333                case CCMD_CHECK_PRESENCE: 
     334                        cl = processCTRL_CHECK_PRESENCE(&gp); 
     335                        break; 
     336 
     337                case CCMD_STORE_MAGNET: 
     338                        cl = processCTRL_STORE_MAGNET(&gp); 
     339                        break; 
     340 
     341                case CCMD_REQUEST_NOTIFICATION: 
     342                        cl = processCTRL_REQUEST_NOTIFICATION(&gp); 
     343                        break; 
     344 
     345                case CCMD_REQUEST_SILENCE: 
     346                        cl = processCTRL_REQUEST_SILENCE(&gp); 
     347                        break; 
     348 
     349                case CCMD_REPORT_INSTANCE: 
     350                        cl = processCTRL_REPORT_INSTANCE(&gp); 
     351                        break; 
     352                } 
     353        } 
     354        catch ( GotekException e ) 
     355        { 
     356                return CL_DROP; 
     357        } 
     358 
     359 
     360        return cl; 
     361
     362 
     363ConsumeLevel ServiceGotek2Dialogue::processCTRL_CHECK_PRESENCE(GotekPacket *gp) 
     364
     365        logPF();  
     366        return CL_DROP; 
     367
     368 
     369ConsumeLevel ServiceGotek2Dialogue::processCTRL_STORE_MAGNET(GotekPacket *gp) 
     370
     371        logPF();  
     372        return CL_DROP; 
     373
     374 
     375ConsumeLevel ServiceGotek2Dialogue::processCTRL_REQUEST_NOTIFICATION(GotekPacket *gp) 
     376
     377        logPF();  
     378        return CL_DROP; 
     379
     380 
     381ConsumeLevel ServiceGotek2Dialogue::processCTRL_REQUEST_SILENCE(GotekPacket *gp) 
     382
     383        logPF();  
     384        return CL_DROP; 
     385
     386 
     387ConsumeLevel ServiceGotek2Dialogue::processCTRL_REPORT_INSTANCE(GotekPacket *gp) 
     388
     389        logPF();  
     390        return CL_DROP; 
     391
     392 
     393 
     394 
     395 
     396ConsumeLevel ServiceGotek2Dialogue::processDATA(bool *needmoredata) 
     397
     398        logPF();  
     399        return CL_DROP; 
     400
     401 
     402ConsumeLevel ServiceGotek2Dialogue::processDATA_MAGNET(GotekPacket *gp) 
     403
     404        logPF();  
     405        return CL_DROP; 
     406
     407 
     408ConsumeLevel ServiceGotek2Dialogue::processDATA_SAMPLE_GET(GotekPacket *gp) 
     409
     410        logPF();  
     411        return CL_DROP; 
     412
     413 
     414ConsumeLevel ServiceGotek2Dialogue::processDATA_SAMPLE_ADD(GotekPacket *gp) 
     415
     416        logPF();  
     417        return CL_DROP; 
     418}      
     419 
     420ConsumeLevel ServiceGotek2Dialogue::processDATA_SAMPLE_ADD_GZIP(GotekPacket *gp) 
     421
     422        logPF();  
     423        return CL_DROP; 
     424
     425 
    216426 
    217427 
     
    261471bool ServiceGotek2Dialogue::sqlSuccess(SQLResult *sqlresult) 
    262472{ 
    263         return true; 
    264 
     473        logPF(); 
     474 
     475        if ( m_QueryQueue.size() == 0 ) 
     476        { 
     477                logCrit("unexpected Query callback for query %s\n",sqlresult->getQuery().c_str()); 
     478                m_Socket->setStatus(SS_CLOSED); 
     479                return false; 
     480        } 
     481 
     482        switch ( m_ClientType ) 
     483        { 
     484        case GCT_LOGIN: 
     485                ret = sqlSuccessLOGIN(sqlresult); 
     486                break; 
     487 
     488        case GCT_CTRL: 
     489                ret = sqlSuccessCTRL(sqlresult); 
     490                break; 
     491 
     492        case GCT_DATA: 
     493                ret = sqlSuccessDATA(sqlresult); 
     494                break; 
     495        } 
     496 
     497
     498 
     499 
     500bool ServiceGotek2Dialogue::sqlSuccessLOGIN(SQLResult *sqlresult) 
     501
     502        logPF(); 
     503        vector< map<string,string> > result = *sqlresult->getResult(); 
     504 
     505        SQLContext *sqlctx = (SQLContext *)sqlresult->getObject(); 
     506 
     507        if ( result.size() == 1 ) 
     508        { 
     509                string bkey(result[0]["authkey"].data(), result[0]["authkey"].size()); 
     510                bkey.append((char *)&m_SessionKey,8); 
     511 
     512 
     513                unsigned char hash[64]; 
     514                g_Library->getUtilities()->sha512((unsigned char *)bkey.c_str(),bkey.size(),hash); 
     515                 
     516                if ( memcmp(m_Buffer.data(),hash,64) == 0 ) 
     517                { 
     518                        logInfo("Login success: %s\n",m_Username.c_str()); 
     519                        if (sqlctx->getCommand() == CTYPE_CTRL ) 
     520                        { 
     521                                m_ClientType = GCT_CONTROL; 
     522                        }else 
     523                        if (sqlctx->getCommand() == CTYPE_DATA ) 
     524                        { 
     525                                m_ClientType = GCT_DATA; 
     526                        } 
     527 
     528                        m_Socket->doWrite(&RPL_AUTHORIZED,1); 
     529 
     530                }else 
     531                { 
     532                        // invalid login 
     533                        logInfo("Login failed: %s\n",m_Username.c_str()); 
     534                        m_Socket->doWrite(&RPL_DENIED,1); 
     535                        m_Socket->setStatus(SS_CLEANQUIT); 
     536                } 
     537 
     538        } else 
     539        { 
     540                // invalid login 
     541                logInfo("Login failed: %s\n",m_Username.c_str()); 
     542                m_Socket->doWrite(&RPL_DENIED,1); 
     543                m_Socket->setStatus(SS_CLEANQUIT); 
     544        } 
     545 
     546        delete sqlctx; 
     547 
     548 
     549        return true; 
     550
     551 
     552bool ServiceGotek2Dialogue::sqlSuccessCTRL(SQLResult *sqlresult) 
     553
     554        logPF(); 
     555 
     556        return true; 
     557
     558 
     559bool ServiceGotek2Dialogue::sqlSuccessDATA(SQLResult *sqlresult) 
     560
     561        logPF(); 
     562 
     563        return true; 
     564
     565 
     566 
     567 
     568 
     569 
    265570 
    266571bool ServiceGotek2Dialogue::sqlFailure(SQLResult *sqlresult) 
    267572{ 
     573        logPF(); 
     574 
     575        if ( m_QueryQueue.size() == 0 ) 
     576        { 
     577                logCrit("unexpected Query callback for query %s\n",sqlresult->getQuery().c_str()); 
     578                m_Socket->setStatus(SS_CLOSED); 
     579                return false; 
     580        } 
     581 
     582        switch ( m_ClientType ) 
     583        { 
     584        case GCT_LOGIN: 
     585                ret = sqlFailureLOGIN(sqlresult); 
     586                break; 
     587 
     588        case GCT_CTRL: 
     589                ret = sqlFailureCTRL(sqlresult); 
     590                break; 
     591 
     592        case GCT_DATA: 
     593                ret = sqlFailureDATA(sqlresult); 
     594                break; 
     595        } 
     596} 
     597 
     598 
     599 
     600bool ServiceGotek2Dialogue::sqlFailureLOGIN(SQLResult *sqlresult) 
     601{ 
     602        logPF(); 
     603 
     604        return true; 
     605} 
     606 
     607 
     608bool ServiceGotek2Dialogue::sqlFailureCTRL(SQLResult *sqlresult) 
     609{ 
     610        logPF(); 
     611 
     612        return true; 
     613} 
     614 
     615 
     616bool ServiceGotek2Dialogue::sqlFailureDATA(SQLResult *sqlresult) 
     617{ 
     618        logPF(); 
     619 
    268620        return true; 
    269621} 
     
    280632} 
    281633 
     634 
     635 
  • library/trunk/modules/service-gotek2/service-gotek2.hpp

    r504 r509  
    3838#include "SQLCallback.hpp" 
    3939 
     40 
    4041using namespace std; 
    4142 
     
    4647        class SQLResult; 
    4748        class SQLQuery; 
     49 
     50        enum GotekClientType 
     51        { 
     52                GCT_LOGIN, 
     53        GCT_CONTROL, 
     54            GCT_DATA, 
     55        }; 
     56 
     57 
     58        typedef enum  
     59        { 
     60 
     61                CCMD_LOGIN, 
     62                CCMD_NOOP, 
     63                CCMD_CHECK_PRESENCE, 
     64                CCMD_STORE_MAGNET, 
     65                CCMD_REQUEST_NOTIFICATION, 
     66                CCMD_REQUEST_SILENCE, 
     67                CCMD_REPORT_INSTANCE, 
     68 
     69                CTYPE_CTRL, 
     70                CTYPE_DATA, 
     71 
     72                SCMD_WELCOME, 
     73                SCMD_PING, 
     74                SCMD_NOTIFY, 
     75 
     76                RPL_AUTHORIZED, 
     77                RPL_DENIED, 
     78 
     79                RPL_ACK, 
     80                RPL_NACK, 
     81 
     82                RPL_PRESENT, 
     83                RPL_NPRESENT, 
     84                RPL_UNSUPPORTED, 
     85 
     86                RPL_SUCCESSFUL, 
     87                RPL_FAILED, 
     88 
     89                HTYPE_SHA512, 
     90                HTYPE_MD5, 
     91                HTYPE_USERDEFINED, 
     92 
     93                WMODE_NEW, 
     94                WMODE_OVERWRITE, 
     95                WMODE_APPEND, 
     96 
     97                DTYPE_MAGNET, 
     98                DTYPE_SAMPLE_GET, 
     99                DTYPE_SAMPLE_ADD, 
     100                DTYPE_SAMPLE_ADD_GZIP 
     101        }GotekPacketType; 
     102 
    48103 
    49104        class ServiceGotek2 : public Module , public DialogueFactory 
     
    58113 
    59114 
    60         enum GotekClientState 
    61         { 
    62                 GCS_VIRGIN = 0, 
    63                 GCS_AUTHED, 
    64                 GCS_DATA_RECEIVING, 
    65                 GCS_CTRL_IDLE, 
    66                 GCS_CTRL_PINGED, 
    67         }; 
    68          
    69         enum GotekClientType 
    70         { 
    71                 GCT_UNKNOWN, 
    72         GCT_CONTROL, 
    73             GCT_DATA, 
    74         }; 
    75  
    76  
    77115        class ServiceGotek2Dialogue : public Dialogue, public SQLCallback 
    78116        { 
     
    80118                ServiceGotek2Dialogue(Socket *socket); 
    81119                ~ServiceGotek2Dialogue(); 
     120 
    82121                ConsumeLevel incomingData(Message *msg); 
     122 
     123                ConsumeLevel process(); 
     124 
     125                ConsumeLevel processLOGIN(bool *needmoredata); 
     126 
     127                ConsumeLevel processCTRL(bool *needmoredata); 
     128                ConsumeLevel processCTRL_CHECK_PRESENCE(GotekPacket *gp); 
     129                ConsumeLevel processCTRL_STORE_MAGNET(GotekPacket *gp); 
     130                ConsumeLevel processCTRL_REQUEST_NOTIFICATION(GotekPacket *gp); 
     131                ConsumeLevel processCTRL_REQUEST_SILENCE(GotekPacket *gp); 
     132                ConsumeLevel processCTRL_REPORT_INSTANCE(GotekPacket *gp); 
     133 
     134                ConsumeLevel processDATA(bool *needmoredata); 
     135                ConsumeLevel processDATA_MAGNET(GotekPacket *gp); 
     136                ConsumeLevel processDATA_SAMPLE_GET(GotekPacket *gp); 
     137                ConsumeLevel processDATA_SAMPLE_ADD(GotekPacket *gp);        
     138                ConsumeLevel processDATA_SAMPLE_ADD_GZIP(GotekPacket *gp); 
     139 
    83140                ConsumeLevel handleTimeout(Message *msg); 
    84141                ConsumeLevel connectionLost(Message *msg); 
     
    87144 
    88145                bool sqlSuccess(SQLResult *result); 
     146                bool sqlSuccessLOGIN(SQLResult *result); 
     147                bool sqlSuccessCTRL(SQLResult *result); 
     148                bool sqlSuccessDATA(SQLResult *result); 
     149 
    89150                bool sqlFailure(SQLResult *result); 
     151                bool sqlSuccessLOGIN(SQLResult *result); 
     152                bool sqlFailureCTRL(SQLResult *result); 
     153                bool sqlFailureDATA(SQLResult *result); 
    90154 
    91155        protected: 
     
    93157                list<SQLQuery *>        m_QueryQueue; 
    94158 
    95                 GotekClientState        m_State; 
    96159                GotekClientType         m_ClientType; 
    97160