Changeset 514 for library

Show
Ignore:
Timestamp:
04/11/06 10:56:33 (3 years ago)
Author:
common
Message:

library
- SQLHander::escapeString(string *str)
- SQLManager::escapeString(string *str)
- TCP/UDSSocket proper dropping on CL_DROP
- Socket::doWrite(string &s)
- service-gotek2 login, checking presence, reporting magnets, adding instance *may* work

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • library/trunk/library-core/include/SQLHandler.hpp

    r491 r514  
    4646 
    4747                virtual bool runQuery(SQLQuery *query)=0; 
    48                  
     48 
     49                virtual string escapeString(string *str)=0; 
    4950                virtual string escapeBinary(string *str)=0; 
    5051                virtual string unescapeBinary(string *str)=0; 
    51  
     52                 
    5253 
    5354                virtual string getSQLHandlerName() 
  • library/trunk/library-core/include/SQLManager.hpp

    r491 r514  
    3838#define SQL_ESCAPE_BINARY(x)    g_Library->getSQLMgr()->escapeBinary((x)) 
    3939#define SQL_UNESCAPE_BINARY(x)  g_Library->getSQLMgr()->unescapeBinary((x)) 
     40#define SQL_ESCAPE_STRING(x)    g_Library->getSQLMgr()->escapeString((x)) 
    4041 
    4142using namespace std; 
     
    5455 
    5556                virtual SQLQuery *addQuery(string *query, SQLCallback *callback, void *obj); 
     57                virtual string escapeString(string *str); 
    5658                virtual string escapeBinary(string *str); 
    5759                virtual string unescapeBinary(string *str); 
  • library/trunk/library-core/include/Socket.hpp

    r474 r514  
    112112 
    113113        virtual int32_t doWrite(char *msg,uint32_t len)=0; 
     114                virtual int32_t doWrite(string &s); 
    114115 
    115116        virtual bool checkTimeout()=0; 
  • library/trunk/library-core/src/SQLManager.cpp

    r491 r514  
    9797} 
    9898 
     99string SQLManager::escapeString(string *str) 
     100{ 
     101        return m_SQLHandler->escapeString(str); 
     102} 
     103 
    99104string SQLManager::escapeBinary(string *str) 
    100105{ 
  • library/trunk/library-core/src/Socket.cpp

    r474 r514  
    492492        return sDesc; 
    493493} 
     494 
     495int32_t Socket::doWrite(string &s) 
     496{ 
     497        return doWrite((char *)s.data(),s.size()); 
     498} 
  • library/trunk/library-core/src/TCPSocket.cpp

    r474 r514  
    596596        m_LastAction = time(NULL); 
    597597 
    598         if((length == 0 || ( length == -1 && errno != EAGAIN )) && cl == CL_DROP ) 
     598        if( cl == CL_DROP ) 
    599599        { 
    600600                logDebug("Connection %s CLOSED \n",getDescription().c_str()); 
  • library/trunk/library-core/src/UDSSocket.cpp

    r486 r514  
    456456        m_LastAction = time(NULL); 
    457457 
    458         if((length == 0 || ( length == -1 && errno != EAGAIN )) && cl == CL_DROP ) 
     458        if( cl == CL_DROP ) 
    459459        { 
    460460                logDebug("Connection %s CLOSED \n",getDescription().c_str()); 
  • library/trunk/modules/service-gotek2/GotekPacket.cpp

    r512 r514  
    1717        m_data = data; 
    1818        m_options = options; 
    19  
     19/* 
    2020        m_type = (GotekPacketType)readUInt8(); 
    2121 
     
    2727                throw GotekException(string("Packet size information does not match actual packet size!")); 
    2828        } 
     29*/       
    2930} 
    3031 
  • library/trunk/modules/service-gotek2/SQLContext.hpp

    r513 r514  
    3939                        m_Time = starttime; 
    4040                        m_Command = command; 
     41                        m_String = ""; 
     42                } 
     43 
     44                SQLContext(uint8_t command, time_t starttime, string *str) 
     45                { 
     46                        m_Time = starttime; 
     47                        m_Command = command; 
     48                        m_String = *str; 
    4149                } 
    4250 
     
    5058                        return m_Time; 
    5159                } 
     60                string          getString() 
     61                { 
     62                        return m_String; 
     63                } 
    5264 
    5365        private: 
    5466                time_t          m_Time; 
    5567                uint8_t         m_Command; 
     68                string          m_String; 
    5669        }; 
    5770} 
  • library/trunk/modules/service-gotek2/service-gotek2.cpp

    r513 r514  
    193193        m_SessionKey = (((unsigned long long) time(0)) << 48) | (((unsigned long long) (rand() & 0xFF)) << 32); 
    194194        m_SessionKey |= (unsigned long long) rand(); 
    195 //     gp->writeRaw(string(m_SessionKey,8)); 
     195       gp->writeRaw((void *)&m_SessionKey,8); 
    196196 
    197197// server version 
     
    201201        gp->writeString(string("no description yet")); 
    202202 
    203 //      m_Socket->doWrite((char *)gp->buffer(), 20); 
    204  
     203        m_Socket->doWrite((char *)gp->buffer().c_str(),gp->size()+5); 
     204 
     205        delete gp; 
    205206 
    206207} 
     
    259260                } 
    260261        } 
     262        logSpam("return %i\n",cl); 
    261263        return cl; 
    262264} 
     
    275277        GotekPacket *gp = GotekPacket::createReadPacket(m_Buffer); 
    276278 
    277         gp->readUInt8(); 
    278  
    279         if (m_Buffer.size() < gp->readUInt32() + 5 ) 
     279        uint8_t command = gp->readUInt8(); 
     280        if ( command != (uint8_t)CCMD_LOGIN ) 
     281        { 
     282                logInfo("Invalid CCMD_LOGIN %x\n",command); 
     283                return CL_DROP; 
     284        } 
     285 
     286        uint32_t gotekpacketsize = gp->readUInt32(); 
     287        if (m_Buffer.size() <  gotekpacketsize + 5 ) 
    280288        { 
    281289                *needmoredata = true; 
     
    283291        } 
    284292 
     293     
    285294// parse the data 
    286295        string hash; 
    287         unsigned char command; 
     296         
    288297        try 
    289298        { 
     
    293302                hash = gp->readRaw(64); 
    294303                command = gp->readUInt8(); 
    295  
    296304        } 
    297305        catch ( GotekException e ) 
     
    314322// create the query context so we know which query returns, so we can answer appropriate 
    315323 
    316         SQLContext *sqlctx = new SQLContext(command,time(NULL)); 
     324        SQLContext *sqlctx = new SQLContext(command,time(NULL),&hash); 
    317325 
    318326// query  
     
    324332         m_QueryQueue.push_back(sqlquery); 
    325333 
    326  
    327  
     334         m_Buffer.erase(0,gotekpacketsize+5); 
    328335         return CL_ASSIGN; 
    329336} 
     
    360367 
    361368        uint8_t command = gp->readUInt8(); 
    362  
    363         if (m_Buffer.size() < gp->readUInt32() + 5 ) 
     369        uint32_t gotekpacketsize = gp->readUInt32(); 
     370 
     371        if (m_Buffer.size() <  + gotekpacketsize + 5  ) 
    364372        { 
    365373                *needmoredata = true; 
     374                delete gp; 
    366375                 return CL_ASSIGN; 
    367376        } 
     
    397406        } 
    398407 
     408        m_Buffer.erase(0,gotekpacketsize + 5); 
    399409 
    400410        return cl; 
     
    403413ConsumeLevel ServiceGotek2Dialogue::processCTRL_CHECK_PRESENCE(GotekPacket *gp) 
    404414{ 
     415        logPF(); 
     416        uint8_t hash_type = gp->readUInt8(); 
     417        if (hash_type != HTYPE_MD5 && hash_type != HTYPE_SHA512) 
     418        { 
     419                m_Socket->doWrite(mapEnum(RPL_UNSUPPORTED),1); 
     420                return CL_ASSIGN; 
     421        } 
     422 
     423         
     424// create the query context so we know which query returns, so we can answer appropriate 
     425 
     426        SQLContext *sqlctx = new SQLContext(CCMD_CHECK_PRESENCE,time(NULL)); 
     427 
     428        string hash; 
     429        switch(hash_type) 
     430        { 
     431        case HTYPE_SHA512: 
     432                { 
     433                        string hash = gp->readRaw(64); 
     434                        hash = SQL_ESCAPE_BINARY(&hash); 
     435                        string query = "SELECT \"sha512_hash\" FROM \"users-dp\".\"malware\" WHERE sha512_hash = '" + hash +"';"; 
     436                        SQLQuery *sqlquery = g_Library->getSQLMgr()->addQuery(&query,this,(void *)sqlctx); 
     437                        m_QueryQueue.push_back(sqlquery); 
     438                } 
     439                break; 
     440 
     441        case HTYPE_MD5: 
     442                { 
     443                        string hash = gp->readRaw(16); 
     444                        hash = SQL_ESCAPE_BINARY(&hash); 
     445                        string query = "SELECT \"sha512_hash\" FROM \"users-dp\".\"malware\" WHERE sha512_hash = '" + hash +"';"; 
     446                        SQLQuery *sqlquery = g_Library->getSQLMgr()->addQuery(&query,this,(void *)sqlctx); 
     447                        m_QueryQueue.push_back(sqlquery); 
     448                } 
     449                break; 
     450 
     451        } 
     452 
     453        return CL_ASSIGN; 
     454} 
     455 
     456ConsumeLevel ServiceGotek2Dialogue::processCTRL_STORE_MAGNET(GotekPacket *gp) 
     457{ 
     458        logPF(); 
     459        string hash = gp->readRaw(64); 
     460        uint8_t writemode = gp->readUInt8(); 
     461        string name = gp->readString(); 
     462        uint16_t valuesize = gp->readUInt16(); 
     463        string value = gp->readRaw(valuesize); 
     464 
     465        name = SQL_ESCAPE_STRING(&name); 
     466        hash = SQL_ESCAPE_BINARY(&hash); 
     467        value = SQL_ESCAPE_STRING(&value); 
     468 
     469        writemode = 0; 
     470 
     471        SQLContext *sqlctx = new SQLContext(CCMD_STORE_MAGNET,time(NULL)); 
     472 
     473        string query = "INSERT INTO \"users-dp\".\"magnets\" (\"sha512_hash\",\"name\",\"value\") VALUES ('" + hash + "','" + name + "','" + value + "')"; 
     474 
     475        SQLQuery *sqlquery = g_Library->getSQLMgr()->addQuery(&query,this,(void *)sqlctx); 
     476        m_QueryQueue.push_back(sqlquery); 
     477 
     478 
     479        return CL_ASSIGN; 
     480} 
     481 
     482ConsumeLevel ServiceGotek2Dialogue::processCTRL_REQUEST_NOTIFICATION(GotekPacket *gp) 
     483{ 
    405484        logPF();  
    406485        return CL_DROP; 
    407486} 
    408487 
    409 ConsumeLevel ServiceGotek2Dialogue::processCTRL_STORE_MAGNET(GotekPacket *gp) 
     488ConsumeLevel ServiceGotek2Dialogue::processCTRL_REQUEST_SILENCE(GotekPacket *gp) 
    410489{ 
    411490        logPF();  
     
    413492} 
    414493 
    415 ConsumeLevel ServiceGotek2Dialogue::processCTRL_REQUEST_NOTIFICATION(GotekPacket *gp) 
     494ConsumeLevel ServiceGotek2Dialogue::processCTRL_REPORT_INSTANCE(GotekPacket *gp) 
    416495{ 
    417496        logPF();  
    418         return CL_DROP; 
    419 
    420  
    421 ConsumeLevel ServiceGotek2Dialogue::processCTRL_REQUEST_SILENCE(GotekPacket *gp) 
    422 
    423         logPF();  
    424         return CL_DROP; 
    425 
    426  
    427 ConsumeLevel ServiceGotek2Dialogue::processCTRL_REPORT_INSTANCE(GotekPacket *gp) 
    428 
    429         logPF();  
    430         return CL_DROP; 
     497        string hash = gp->readRaw(64); 
     498        hash = SQL_ESCAPE_BINARY(&hash); 
     499 
     500        uint16_t num_magnets = gp->readUInt16(); 
     501 
     502        uint16_t i; 
     503 
     504        string insert_names; 
     505        string insert_values; 
     506 
     507        for (i=0;i<num_magnets;i++) 
     508        { 
     509 
     510                string name = gp->readString(); 
     511                name = SQL_ESCAPE_STRING(&name); 
     512 
     513                insert_names += "\"" + name + "\""; 
     514 
     515                if (i+1 < num_magnets ) 
     516                { 
     517                        insert_names += ","; 
     518                } 
     519 
     520 
     521                uint16_t valuesize = gp->readUInt16(); 
     522                string value = gp->readRaw(valuesize); 
     523        value = SQL_ESCAPE_STRING(&value); 
     524 
     525                insert_values += "'" + value + "'"; 
     526 
     527                if (i+1 < num_magnets ) 
     528                { 
     529                        insert_values += ","; 
     530                } 
     531        } 
     532 
     533 
     534        string query = "INSERT INTO \"users-dp\".\"instances\" (" + insert_names + ") VALUES (" + insert_values + ")"; 
     535 
     536 
     537        SQLContext *sqlctx = new SQLContext(CCMD_REPORT_INSTANCE,time(NULL)); 
     538 
     539        SQLQuery *sqlquery = g_Library->getSQLMgr()->addQuery(&query,this,sqlctx); 
     540        m_QueryQueue.push_back(sqlquery); 
     541 
     542        return CL_ASSIGN; 
    431543} 
    432544 
     
    516628        if ( m_QueryQueue.size() == 0 ) 
    517629        { 
    518                 logCrit("unexpected Query callback for query %s\n",sqlresult->getQuery().c_str()); 
     630                logCrit("unexpected Query callback for query %s context %x\n",sqlresult->getQuery().c_str(), sqlresult->getObject()); 
    519631                m_Socket->setStatus(SS_CLOSED); 
    520632                return false; 
     
    538650        } 
    539651 
     652        m_QueryQueue.pop_front(); 
    540653        return ret; 
    541654} 
     
    558671                g_Library->getUtilities()->sha512((unsigned char *)bkey.c_str(),bkey.size(),hash); 
    559672                 
    560                 if ( memcmp(m_Buffer.data(),hash,64) == 0 ) 
     673                if ( memcmp(sqlctx->getString().c_str(),hash,64) == 0 ) 
    561674                { 
    562                         logInfo("Login success: %s\n",m_Username.c_str()); 
    563                         if (sqlctx->getCommand() == CTYPE_CTRL
     675                         
     676                        switch ( sqlctx->getCommand()
    564677                        { 
     678                        case CTYPE_CTRL: 
     679                                logInfo("Login success (ctrl) :%s\n",m_Username.c_str()); 
    565680                                m_ClientType = GCT_CONTROL; 
    566                         }else 
    567                         if (sqlctx->getCommand() == CTYPE_DATA ) 
    568                         { 
     681                               break; 
     682                        case CTYPE_DATA: 
     683                               logInfo("Login success (data) :%s\n",m_Username.c_str()); 
    569684                                m_ClientType = GCT_DATA; 
     685                                break; 
     686                        default: 
     687                                logCrit("Login error, invalid connection type requested %0x\n",sqlctx->getCommand()); 
    570688                        } 
    571  
    572689                        m_Socket->doWrite(mapEnum(RPL_AUTHORIZED),1); 
    573690 
     
    597714{ 
    598715        logPF(); 
    599  
    600         return true; 
    601 
     716        bool retval=false; 
     717        SQLContext *sqlctx = (SQLContext *)sqlresult->getObject(); 
     718        switch (sqlctx->getCommand()) 
     719        { 
     720        case CCMD_CHECK_PRESENCE: 
     721                retval = sqlSuccessCTRL_CHECK_PRESENCE(sqlresult); 
     722                break; 
     723 
     724        case CCMD_STORE_MAGNET: 
     725                retval = sqlSuccessCTRL_STORE_MAGNET(sqlresult); 
     726                break; 
     727 
     728        case CCMD_REPORT_INSTANCE: 
     729                retval = sqlSuccessCTRL_REPORT_INSTANCE(sqlresult); 
     730                break; 
     731        } 
     732 
     733        delete sqlctx; 
     734        return true; 
     735
     736 
     737 
     738bool ServiceGotek2Dialogue::sqlSuccessCTRL_CHECK_PRESENCE(SQLResult *sqlresult) 
     739
     740        logPF(); 
     741        vector< map<string,string> > result = *sqlresult->getResult(); 
     742 
     743        if (result.size() >= 1) 
     744        { 
     745                m_Socket->doWrite(mapEnum(RPL_PRESENT),1); 
     746        }else 
     747        { 
     748                m_Socket->doWrite(mapEnum(RPL_NPRESENT),1); 
     749        } 
     750        return true; 
     751
     752 
     753bool ServiceGotek2Dialogue::sqlSuccessCTRL_STORE_MAGNET(SQLResult *sqlresult) 
     754
     755        logPF(); 
     756        m_Socket->doWrite(mapEnum(RPL_ACK),1); 
     757        return true; 
     758
     759 
     760bool ServiceGotek2Dialogue::sqlSuccessCTRL_REPORT_INSTANCE(SQLResult *sqlresult) 
     761
     762        logPF(); 
     763        m_Socket->doWrite(mapEnum(RPL_ACK),1); 
     764        return true; 
     765
     766 
     767 
     768 
     769 
     770 
     771 
    602772 
    603773bool ServiceGotek2Dialogue::sqlSuccessDATA(SQLResult *sqlresult) 
     
    641811        } 
    642812 
     813        m_QueryQueue.pop_front(); 
    643814        return ret; 
    644815} 
     
    658829        logPF(); 
    659830 
     831        bool retval=false; 
     832 
     833        SQLContext *sqlctx = (SQLContext *)sqlresult->getObject(); 
     834        switch ( sqlctx->getCommand() ) 
     835        { 
     836        case CCMD_STORE_MAGNET: 
     837                retval = sqlFailureCTRL_STORE_MAGNET(sqlresult); 
     838                break; 
     839 
     840        case CCMD_REPORT_INSTANCE: 
     841                retval = sqlFailureCTRL_REPORT_INSTANCE(sqlresult); 
     842                break; 
     843        } 
     844 
     845        delete sqlctx; 
     846 
     847        return retval; 
     848} 
     849 
     850bool ServiceGotek2Dialogue::sqlFailureCTRL_STORE_MAGNET(SQLResult *sqlresult) 
     851{ 
     852        logPF(); 
     853        m_Socket->doWrite(mapEnum(RPL_NACK),1); 
     854        return true; 
     855} 
     856 
     857bool ServiceGotek2Dialogue::sqlFailureCTRL_REPORT_INSTANCE(SQLResult *sqlresult) 
     858{ 
     859        logPF(); 
     860        m_Socket->doWrite(mapEnum(RPL_NACK),1); 
    660861        return true; 
    661862} 
  • library/trunk/modules/service-gotek2/service-gotek2.hpp

    r513 r514  
    152152                bool sqlSuccess(SQLResult *result); 
    153153                bool sqlSuccessLOGIN(SQLResult *result); 
     154 
    154155                bool sqlSuccessCTRL(SQLResult *result); 
     156                bool sqlSuccessCTRL_CHECK_PRESENCE(SQLResult *result); 
     157                bool sqlSuccessCTRL_STORE_MAGNET(SQLResult *result); 
     158                bool sqlSuccessCTRL_REPORT_INSTANCE(SQLResult *result); 
     159 
    155160                bool sqlSuccessDATA(SQLResult *result); 
    156161 
    157162                bool sqlFailure(SQLResult *result); 
    158163                bool sqlFailureLOGIN(SQLResult *result); 
     164 
    159165                bool sqlFailureCTRL(SQLResult *result); 
     166                bool sqlFailureCTRL_STORE_MAGNET(SQLResult *result); 
     167                bool sqlFailureCTRL_REPORT_INSTANCE(SQLResult *result); 
     168 
     169 
    160170                bool sqlFailureDATA(SQLResult *result); 
    161171 
  • library/trunk/modules/sqlhandler-postgres/sqlhandler-postgres.cpp

    r492 r514  
    154154        } 
    155155        return true; 
     156} 
     157 
     158string SQLHandlerPostgres::escapeString(string *str) 
     159{ 
     160        int size = str->size() * 2 + 1 ; 
     161        char *escaped = (char *)malloc(size); 
     162        size = PQescapeString(escaped,str->c_str(),str->size()); 
     163        string result(escaped,size); 
     164        free(escaped); 
     165        return result; 
    156166} 
    157167 
  • library/trunk/modules/sqlhandler-postgres/sqlhandler-postgres.hpp

    r492 r514  
    5757                ~SQLHandlerPostgres(); 
    5858                bool runQuery(SQLQuery *query); 
     59                string escapeString(string *str); 
    5960                string escapeBinary(string *str); 
    6061                string unescapeBinary(string *str);