Changeset 5506


Ignore:
Timestamp:
Apr 4, 2008, 5:19:44 PM (14 years ago)
Author:
charles
Message:

ipc/daemon cleanup

Location:
trunk
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/daemon/client.c

    r5498 r5506  
    724724    }
    725725
    726     res = ipc_parse( con->ipc, buf, len, con );
     726    res = ipc_handleMessages( con->ipc, buf, len, con );
    727727    if( 0 > res )
    728728    {
     
    841841            case IPC_MSG_GETINFOALL:
    842842            case IPC_MSG_GETSTATALL:
    843                 buf = ipc_mkgetinfo( con->ipc, &buflen, req->id, req->tag,
    844                                      req->types, NULL );
     843                buf = ipc_createInfoRequest( con->ipc, &buflen, req->id, req->tag,
     844                                             req->types, NULL );
    845845                break;
    846846            default:
     
    907907         void * arg UNUSED )
    908908{
    909     benc_val_t   * dict;
    910909    int            ii;
    911910    struct cl_info inf;
     
    915914    assert( IPC_MSG_INFO == msgid );
    916915
    917     if( TYPE_LIST != list->type )
    918     {
     916    if( !tr_bencIsList( list ) )
    919917        return;
    920     }
    921918
    922919    memset( &key, 0, sizeof key );
     
    931928    for( ii = 0; list->val.l.count > ii; ii++ )
    932929    {
    933         dict = &list->val.l.vals[ii];
    934         if( TYPE_DICT != dict->type )
    935         {
     930        tr_benc * dict = &list->val.l.vals[ii];
     931
     932        if( !tr_bencIsDict( dict ) )
    936933            continue;
    937         }
    938934
    939935        id       = getinfoint( msgid, dict, IPC_INF_ID,   -1   );
     
    959955         void * arg UNUSED )
    960956{
    961     benc_val_t   * dict;
    962957    int            ii;
    963958    int64_t        id;
     
    967962    assert( IPC_MSG_STAT == msgid );
    968963
    969     if( TYPE_LIST != list->type )
    970     {
     964    if( !tr_bencIsList( list ) )
    971965        return;
    972     }
    973966
    974967    memset( &key, 0, sizeof key );
     
    983976    for( ii = 0; list->val.l.count > ii; ii++ )
    984977    {
    985         dict  = &list->val.l.vals[ii];
    986         if( TYPE_DICT != dict->type )
    987         {
     978        tr_benc * dict = &list->val.l.vals[ii];
     979
     980        if( !tr_bencIsDict( dict ) )
    988981            continue;
    989         }
    990982
    991983        id           = getinfoint( msgid, dict, IPC_ST_ID,        -1   );
     
    10531045cbdone( struct resp * resp )
    10541046{
    1055     if( NULL != resp->infocb )
     1047    if( resp->infocb )
    10561048    {
    10571049        resp->infocb( NULL );
    10581050    }
    1059     else if( NULL != resp->statcb )
     1051    else if( resp->statcb )
    10601052    {
    10611053        resp->statcb( NULL );
     
    10661058getinfoint( enum ipc_msg msgid, benc_val_t * dict, int type, int64_t defval  )
    10671059{
    1068     benc_val_t * val;
    1069 
    1070     val = tr_bencDictFind( dict, ipc_infoname( msgid, type ) );
    1071 
    1072     if( NULL != val && TYPE_INT == val->type )
    1073     {
    1074         return val->val.i;
    1075     }
    1076 
    1077     return defval;
     1060    const char * key = ipc_infoname( msgid, type );
     1061    benc_val_t * val = tr_bencDictFind( dict, key );
     1062    return tr_bencIsInt( val ) ? val->val.i : defval;
    10781063}
    10791064
     
    10811066getinfostr( enum ipc_msg msgid, benc_val_t * dict, int type, char * defval  )
    10821067{
    1083     benc_val_t * val;
    1084 
    1085     val = tr_bencDictFind( dict, ipc_infoname( msgid, type ) );
    1086 
    1087     if( NULL != val && TYPE_STR == val->type )
    1088     {
    1089         return val->val.s.s ;
    1090     }
    1091 
    1092     return defval;
    1093 }
     1068    const char * key = ipc_infoname( msgid, type );
     1069    benc_val_t * val = tr_bencDictFind( dict, key );
     1070    return tr_bencIsString( val ) ? val->val.s.s : defval;
     1071}
  • trunk/daemon/server.c

    r5498 r5506  
    359359    }
    360360
    361     res = ipc_parse( client->ipc, buf, len, client );
     361    res = ipc_handleMessages( client->ipc, buf, len, client );
    362362
    363363    if( gl_exiting )
     
    458458{
    459459    struct client * client = arg;
    460     benc_val_t      pk, * added, * file;
     460    benc_val_t      pk, * added;
    461461    int             ii, tor;
    462462    size_t          buflen;
    463463    uint8_t       * buf;
    464464
    465     if( NULL == val || TYPE_LIST != val->type )
     465    if( !tr_bencIsList( val ) )
    466466    {
    467467        msgresp( client, tag, IPC_MSG_BAD );
     
    479479    for( ii = 0; ii < val->val.l.count; ii++ )
    480480    {
    481         file = &val->val.l.vals[ii];
    482         if( TYPE_STR != file->type )
    483         {
     481        tr_benc * file = &val->val.l.vals[ii];
     482        if( !tr_bencIsString( file ) )
    484483            continue;
    485         }
     484
    486485        /* XXX need to somehow inform client of skipped or failed files */
    487486        tor = torrent_add_file( file->val.s.s, NULL, -1 );
     
    515514    const char    * dir;
    516515
    517     if( NULL == dict || TYPE_DICT != dict->type )
     516    if( !tr_bencIsDict( dict ) )
    518517    {
    519518        msgresp( client, tag, IPC_MSG_BAD );
     
    522521
    523522    val   = tr_bencDictFind( dict, "directory" );
    524     dir   = ( NULL == val || TYPE_STR != val->type ? NULL : val->val.s.s );
     523    dir   = tr_bencIsString( val ) ? val->val.s.s : NULL;
    525524    val   = tr_bencDictFind( dict, "autostart" );
    526     start = ( NULL == val || TYPE_INT != val->type ? -1 :
    527               ( val->val.i ? 1 : 0 ) );
     525    start = tr_bencIsInt( val ) ? (val->val.i!=0) : -1;
    528526    val   = tr_bencDictFind( dict, "data" );
    529     if( NULL != val && TYPE_STR == val->type )
     527    if( tr_bencIsString( val ) )
    530528    {
    531529        /* XXX detect duplicates and return a message indicating so */
     
    536534    {
    537535        val = tr_bencDictFind( dict, "file" );
    538         if( NULL == val || TYPE_STR != val->type )
     536        if( !tr_bencIsString( val ) )
    539537        {
    540538            msgresp( client, tag, IPC_MSG_BAD );
     
    587585    int             num;
    588586
    589     if( NULL == val || TYPE_INT != val->type )
     587    if( !tr_bencIsInt( val ) )
    590588    {
    591589        msgresp( client, tag, IPC_MSG_BAD );
     
    627625    struct client * client = arg;
    628626
    629     if( NULL == val || TYPE_STR != val->type )
     627    if( !tr_bencIsString( val ) )
    630628    {
    631629        msgresp( client, tag, IPC_MSG_BAD );
     
    705703    if( all )
    706704    {
    707         if( NULL == val || TYPE_LIST != val->type )
     705        if( !tr_bencIsList( val ) )
    708706        {
    709707            msgresp( client, tag, IPC_MSG_BAD );
     
    727725    else
    728726    {
    729         if( NULL == val || TYPE_DICT != val->type )
     727        if( !tr_bencIsDict( val ) )
    730728        {
    731729            msgresp( client, tag, IPC_MSG_BAD );
     
    735733        typelist = tr_bencDictFind( val, "type" );
    736734        idlist   = tr_bencDictFind( val, "id" );
    737         if( NULL == typelist || TYPE_LIST != typelist->type ||
    738             NULL == idlist   || TYPE_LIST != idlist->type )
     735        if( !tr_bencIsList(typelist) || !tr_bencIsList(idlist) )
    739736        {
    740737            msgresp( client, tag, IPC_MSG_BAD );
     
    837834    else
    838835    {
    839         if( NULL == val || TYPE_LIST != val->type )
     836        if( !tr_bencIsList( val ) )
    840837        {
    841838            msgresp( client, tag, IPC_MSG_BAD );
     
    866863    int64_t         found;
    867864
    868     if( NULL == val || TYPE_LIST != val->type )
     865    if( !tr_bencIsList( val ) )
    869866    {
    870867        msgresp( client, tag, IPC_MSG_BAD );
     
    884881        const tr_info * inf;
    885882        hash = &val->val.l.vals[ii];
    886         if( NULL == hash || TYPE_STR != hash->type ||
    887             SHA_DIGEST_LENGTH * 2 != hash->val.s.i )
     883        if( !tr_bencIsString(hash) || SHA_DIGEST_LENGTH * 2 != hash->val.s.i )
    888884        {
    889885            tr_bencFree( &pk );
     
    985981    size_t           buflen;
    986982    int              ii;
    987     benc_val_t       pk, *pkval, * name;
     983    benc_val_t       pk, *pkval;
    988984    enum ipc_msg     found;
    989985
    990     if( NULL == val || TYPE_LIST != val->type )
     986    if( !tr_bencIsList( val ) )
    991987    {
    992988        msgresp( client, tag, IPC_MSG_BAD );
     
    10121008    for( ii = 0; val->val.l.count > ii; ii++ )
    10131009    {
    1014         name = &val->val.l.vals[ii];
    1015         if( NULL == name || TYPE_STR != name->type )
     1010        tr_benc * name = &val->val.l.vals[ii];
     1011        if( !tr_bencIsString( name ) )
    10161012        {
    10171013            tr_bencFree( &pk );
  • trunk/daemon/torrents.c

    r5151 r5506  
    656656    uint8_t   *  buf;
    657657    size_t       len;
    658     benc_val_t   top, * num, * str, * list, * dict;
     658    benc_val_t   top, * num, * str, * list;
    659659    int          ii;
    660660    struct tor * tor;
     
    676676
    677677    num = tr_bencDictFind( &top, "autostart" );
    678     if( NULL != num && TYPE_INT == num->type )
    679     {
     678    if( tr_bencIsInt( num ) )
    680679        gl_autostart = ( num->val.i ? 1 : 0 );
    681     }
    682680
    683681    num = tr_bencDictFind( &top, "port" );
    684     if( NULL != num && TYPE_INT == num->type &&
    685         0 < num->val.i && 0xffff > num->val.i )
     682    if( tr_bencIsInt( num ) && 0 < num->val.i && 0xffff > num->val.i )
    686683    {
    687684        gl_port = num->val.i;
     
    690687
    691688    num = tr_bencDictFind( &top, "default-pex" );
    692     if( NULL != num && TYPE_INT == num->type )
    693     {
     689    if( tr_bencIsInt( num ) )
    694690        gl_pex = ( num->val.i ? 1 : 0 );
    695     }
    696691
    697692    num = tr_bencDictFind( &top, "port-mapping" );
    698     if( NULL != num && TYPE_INT == num->type )
    699     {
     693    if( tr_bencIsInt( num ) )
    700694        gl_mapping = ( num->val.i ? 1 : 0 );
    701     }
    702695    tr_natTraversalEnable( gl_handle, gl_mapping );
    703696
    704697    num = tr_bencDictFind( &top, "upload-limit" );
    705     if( NULL != num && TYPE_INT == num->type )
    706     {
     698    if( tr_bencIsInt( num ) )
    707699        gl_uplimit = num->val.i;
    708     }
    709700    tr_setGlobalSpeedLimit( gl_handle, TR_UP, gl_uplimit );
    710701    tr_setUseGlobalSpeedLimit( gl_handle, TR_UP, gl_uplimit > 0 );
    711702
    712703    num = tr_bencDictFind( &top, "download-limit" );
    713     if( NULL != num && TYPE_INT == num->type )
    714     {
     704    if( tr_bencIsInt( num ) )
    715705        gl_downlimit = num->val.i;
    716     }
    717706    tr_setGlobalSpeedLimit( gl_handle, TR_DOWN, gl_downlimit );
    718707    tr_setUseGlobalSpeedLimit( gl_handle, TR_DOWN, gl_downlimit > 0 );
    719708
    720709    str = tr_bencDictFind( &top, "default-directory" );
    721     if( NULL != str && TYPE_STR == str->type )
    722     {
     710    if( tr_bencIsString( str ) )
    723711        strlcpy( gl_dir, str->val.s.s, sizeof gl_dir );
    724     }
    725712
    726713    str = tr_bencDictFind( &top, "encryption-mode" );
    727     if( NULL != str && TYPE_STR == str->type )
     714    if( tr_bencIsString( str ) )
    728715    {
    729716        if(!strcasecmp(str->val.s.s, "preferred"))
     
    736723
    737724    list = tr_bencDictFind( &top, "torrents" );
    738     if( NULL == list || TYPE_LIST != list->type )
    739     {
     725    if( !tr_bencIsList( list ) )
    740726        return 0;
    741     }
    742727
    743728    for( ii = 0; ii < list->val.l.count; ii++ )
    744729    {
    745         dict = &list->val.l.vals[ii];
    746         if( TYPE_DICT != dict->type )
    747         {
     730        tr_benc * dict = &list->val.l.vals[ii];
     731        if( !tr_bencIsDict( dict ) )
    748732            continue;
    749         }
    750733
    751734        str = tr_bencDictFind( dict, "directory" );
    752         dir = ( NULL != str && TYPE_STR == str->type ? str->val.s.s : NULL );
     735        dir = tr_bencIsString( str ) ? str->val.s.s : NULL;
    753736
    754737        str = tr_bencDictFind( dict, "hash" );
    755         if( NULL == str || TYPE_STR != str->type ||
    756             2 * SHA_DIGEST_LENGTH != str->val.s.i )
    757         {
     738        if( !tr_bencIsString( str ) || 2 * SHA_DIGEST_LENGTH != str->val.s.i )
    758739            continue;
    759         }
    760740
    761741        tor = opentor( NULL, str->val.s.s, NULL, 0, dir );
    762         if( NULL == tor )
    763         {
     742        if( !tor )
    764743            continue;
    765         }
    766744
    767745        num = tr_bencDictFind( dict, "pex" );
    768         if( NULL != num && TYPE_INT == num->type )
    769         {
     746        if( tr_bencIsInt( num ) )
    770747            fprintf( stderr, "warning: obsolete command 'pex'\n" );
    771         }
    772748
    773749        num = tr_bencDictFind( dict, "paused" );
    774         if( NULL != num && TYPE_INT == num->type && !num->val.i )
    775         {
     750        if( tr_bencIsInt( num ) && !num->val.i )
    776751            tr_torrentStart( tor->tor );
    777         }
    778752    }
    779753
  • trunk/gtk/ipc.c

    r5498 r5506  
    223223    }
    224224
    225     res = ipc_parse( con->ipc, data, len, con );
     225    res = ipc_handleMessages( con->ipc, data, len, con );
    226226
    227227    if( 0 > res )
     
    382382    }
    383383
    384     res = ipc_parse( con->ipc, data, len, con );
     384    res = ipc_handleMessages( con->ipc, data, len, con );
    385385
    386386    if( 0 > res )
     
    495495    GSList               * list = NULL;
    496496
    497     if( NULL == val || TYPE_LIST != val->type )
     497    if( !tr_bencIsList( val ) )
    498498    {
    499499        simpleresp( con, tag, IPC_MSG_BAD );
     
    531531    tr_ctor              * ctor;
    532532
    533     if( !val || ( val->type != TYPE_DICT ) )
     533    if( !tr_bencIsDict( val ) )
    534534    {
    535535        simpleresp( con, tag, IPC_MSG_BAD );
     
    542542    start = tr_bencDictFind( val, "autostart" );
    543543
    544     if( ( NULL != file  && TYPE_STR != file->type ) ||
    545         ( NULL != data  && TYPE_STR != data->type ) ||
    546         ( NULL != dir   && TYPE_STR != dir->type   ) ||
    547         ( NULL != start && TYPE_INT != start->type ) )
     544    if( ( file  && !tr_bencIsString( file ) ) ||
     545        ( data  && !tr_bencIsString( data ) ) ||
     546        ( dir   && !tr_bencIsString( dir ) ) ||
     547        ( start && !tr_bencIsInt( start ) ) )
    548548    {
    549549        simpleresp( con, tag, IPC_MSG_BAD );
     
    646646    size_t                 size;
    647647
    648     if( NULL == val || TYPE_DICT != val->type )
     648    if( !tr_bencIsDict( val ) )
    649649    {
    650650        simpleresp( con, tag, IPC_MSG_BAD );
     
    655655    ids    = tr_bencDictFind( val, "id" );
    656656    types  = tr_bencDictFind( val, "types" );
    657     if( NULL == ids   || TYPE_LIST != ids->type ||
    658         NULL == types || TYPE_LIST != types->type )
     657    if( !tr_bencIsList(ids) || !tr_bencIsList(types) )
    659658    {
    660659        simpleresp( con, tag, IPC_MSG_BAD );
     
    712711    size_t                 size;
    713712
    714     if( NULL == val || TYPE_LIST != val->type )
     713    if( !tr_bencIsList( val ) )
    715714    {
    716715        simpleresp( con, tag, IPC_MSG_BAD );
     
    799798    size_t                 size;
    800799
    801     if( NULL == val || TYPE_LIST != val->type )
     800    if( !tr_bencIsList( val ) )
    802801    {
    803802        simpleresp( con, tag, IPC_MSG_BAD );
     
    852851    int                    ii;
    853852
    854     if( NULL == val || TYPE_LIST != val->type )
     853    if( !tr_bencIsList( val ) )
    855854    {
    856855        simpleresp( con, tag, IPC_MSG_BAD );
     
    10011000    struct constate_serv * srv = &con->u.serv;
    10021001
    1003     if( NULL == val || TYPE_INT != val->type || INT_MAX < val->val.i )
     1002    if( !tr_bencIsInt( val ) || INT_MAX < val->val.i )
    10041003    {
    10051004        simpleresp( con, tag, IPC_MSG_BAD );
     
    10551054    struct constate_serv * srv = &con->u.serv;
    10561055
    1057     if( NULL == val || TYPE_STR != val->type )
     1056    if( !tr_bencIsString( val ) )
    10581057    {
    10591058        simpleresp( con, tag, IPC_MSG_BAD );
     
    10761075{
    10771076    struct constate      * con = arg;
    1078     tr_benc                packet, * pkval, * name;
     1077    tr_benc                packet, * pkval;
    10791078    int                    ii;
    10801079    enum ipc_msg           found;
     
    10821081    size_t                 size;
    10831082
    1084     if( NULL == val || TYPE_LIST != val->type )
     1083    if( !tr_bencIsList( val ) )
    10851084    {
    10861085        simpleresp( con, tag, IPC_MSG_BAD );
     
    11031102    for( ii = 0; val->val.l.count > ii; ii++ )
    11041103    {
    1105         name = &val->val.l.vals[ii];
    1106         if( NULL == name || TYPE_STR != name->type )
    1107         {
     1104        tr_benc * name = &val->val.l.vals[ii];
     1105
     1106        if( !tr_bencIsString( name ) )
    11081107            continue;
    1109         }
     1108
    11101109        found = ipc_msgid( con->ipc, name->val.s.s );
    11111110        if( IPC__MSG_COUNT == found || !ipc_ishandled( con->ipc, found ) )
    1112         {
    11131111            continue;
    1114         }
     1112
    11151113        tr_bencInitStr( tr_bencListAdd( pkval ),
    11161114                        name->val.s.s, name->val.s.i, 1 );
     
    11191117    buf = ipc_serialize( &packet, &size );
    11201118    tr_bencFree( &packet );
    1121     if( NULL == buf )
    1122     {
     1119
     1120    if( !buf )
    11231121        simpleresp( con, tag, IPC_MSG_FAIL );
    1124     }
    11251122    else
    1126     {
    11271123        io_send_keepdata( con->source, buf, size );
    1128     }
    11291124}
    11301125
  • trunk/libtransmission/bencode.c

    r5498 r5506  
    4242**/
    4343
    44 static int
    45 isType( const tr_benc * val, int type )
     44int
     45tr_bencIsType( const tr_benc * val, int type )
    4646{
    4747    return ( ( val != NULL ) && ( val->type == type ) );
    4848}
    49 
    50 #define isInt(v)    ( isType( ( v ), TYPE_INT ) )
    51 #define isString(v) ( isType( ( v ), TYPE_STR ) )
    52 #define isList(v)   ( isType( ( v ), TYPE_LIST ) )
    53 #define isDict(v)   ( isType( ( v ), TYPE_DICT ) )
    5449
    5550static int
    5651isContainer( const tr_benc * val )
    5752{
    58     return isList(val) || isDict(val);
     53    return tr_bencIsList(val) || tr_bencIsDict(val);
    5954}
    6055static int
    6156isSomething( const tr_benc * val )
    6257{
    63     return isContainer(val) || isInt(val) || isString(val);
     58    return isContainer(val) || tr_bencIsInt(val) || tr_bencIsString(val);
    6459}
    6560
     
    273268
    274269            node = tr_ptrArrayBack( parentStack );
    275             if( isDict( node ) && ( node->val.l.count % 2 ) )
     270            if( tr_bencIsDict( node ) && ( node->val.l.count % 2 ) )
    276271                return TR_ERROR; /* odd # of children in dict */
    277272
     
    339334    int len, ii;
    340335
    341     if( !isDict( val ) )
     336    if( !tr_bencIsDict( val ) )
    342337        return NULL;
    343338
     
    386381{
    387382    tr_benc * ret = NULL;
    388     if( isList( val ) && ( i >= 0 ) && ( i < val->val.l.count ) )
     383    if( tr_bencIsList( val ) && ( i >= 0 ) && ( i < val->val.l.count ) )
    389384        ret = val->val.l.vals + i;
    390385    return ret;
     
    394389tr_bencGetInt ( const tr_benc * val )
    395390{
    396     assert( isInt( val ) );
     391    assert( tr_bencIsInt( val ) );
    397392    return val->val.i;
    398393}
     
    401396tr_bencStealStr( tr_benc * val )
    402397{
    403     assert( isString( val ) );
     398    assert( tr_bencIsString( val ) );
    404399    val->val.s.nofree = 1;
    405400    return val->val.s.s;
     
    451446tr_bencListReserve( tr_benc * val, int count )
    452447{
    453     assert( isList( val ) );
     448    assert( tr_bencIsList( val ) );
    454449    return makeroom( val, count );
    455450}
     
    465460tr_bencDictReserve( tr_benc * val, int count )
    466461{
    467     assert( isDict( val ) );
     462    assert( tr_bencIsDict( val ) );
    468463    return makeroom( val, count * 2 );
    469464}
     
    474469    tr_benc * item;
    475470
    476     assert( isList( list ) );
     471    assert( tr_bencIsList( list ) );
    477472    assert( list->val.l.count < list->val.l.alloc );
    478473
     
    489484    tr_benc * keyval, * itemval;
    490485
    491     assert( isDict( dict ) );
     486    assert( tr_bencIsDict( dict ) );
    492487    assert( dict->val.l.count + 2 <= dict->val.l.alloc );
    493488
     
    536531    struct KeyIndex * indices;
    537532
    538     assert( isDict( val ) );
     533    assert( tr_bencIsDict( val ) );
    539534
    540535    nKeys = val->val.l.count / 2;
     
    567562    struct SaveNode * node;
    568563
    569     assert( isList( val ) );
     564    assert( tr_bencIsList( val ) );
    570565
    571566    n = val->val.l.count;
     
    597592    struct SaveNode * node;
    598593
    599     if( isList( val ) )
     594    if( tr_bencIsList( val ) )
    600595        node = nodeNewList( val );
    601     else if( isDict( val ) )
     596    else if( tr_bencIsDict( val ) )
    602597        node = nodeNewDict( val );
    603598    else
  • trunk/libtransmission/bencode.h

    r5498 r5506  
    104104int64_t tr_bencGetInt( const tr_benc * val );
    105105
     106int tr_bencIsType( const tr_benc *, int type );
     107#define tr_bencIsInt(b) (tr_bencIsType(b,TYPE_INT))
     108#define tr_bencIsDict(b) (tr_bencIsType(b,TYPE_DICT))
     109#define tr_bencIsList(b) (tr_bencIsType(b,TYPE_LIST))
     110#define tr_bencIsString(b) (tr_bencIsType(b,TYPE_STR))
    106111
    107112/**
  • trunk/libtransmission/ipcparse.c

    r5498 r5506  
    6464#define DICTPAYLOAD( info )     ( 2 > (info)->vers )
    6565
     66struct ipc_funcs
     67{
     68    trd_msgfunc msgs[IPC__MSG_COUNT];
     69    trd_msgfunc def;
     70};
     71
    6672struct ipc_info
    6773{
     
    8187    const int           minvers;
    8288    const enum ipc_msg  id;
    83 };
    84 
    85 struct inf
    86 {
    87     const char    * name;
    88     const int       type;
    89 };
    90 
    91 struct msgfunc
    92 {
    93     int             id;
    94     trd_msgfunc     func;
    95 };
    96 
    97 struct ipc_funcs
    98 {
    99     trd_msgfunc msgs[IPC__MSG_COUNT];
    100     trd_msgfunc def;
    10189};
    10290
     
    147135};
    148136
     137struct inf
     138{
     139    const char    * name;
     140    const int       type;
     141};
     142
    149143/* these names must be sorted for strcmp() */
    150144static const struct inf gl_inf[] =
     
    196190
    197191void
    198 ipc_addmsg( struct ipc_funcs * funcs, enum ipc_msg msg_id, trd_msgfunc func )
     192ipc_addmsg( struct ipc_funcs  * funcs,
     193            enum ipc_msg        msg_id,
     194            trd_msgfunc         func )
    199195{
    200196    assert( MSGVALID( msg_id ) );
     
    226222
    227223void
    228 ipc_freecon( struct ipc_info * info )
    229 {
    230     tr_free( info );
     224ipc_freecon( struct ipc_info * session )
     225{
     226    tr_free( session );
    231227}
    232228
    233229int
    234 ipc_ishandled( const struct ipc_info * info, enum ipc_msg id )
    235 {
    236     assert( MSGVALID( id ) );
    237 
    238     return info->funcs->msgs[id] != NULL;
     230ipc_ishandled( const struct ipc_info * session, enum ipc_msg msg_id )
     231{
     232    assert( MSGVALID( msg_id ) );
     233
     234    return session->funcs->msgs[msg_id] != NULL;
    239235}
    240236
    241237int
    242 ipc_havetags( const struct ipc_info * info )
    243 {
    244     return !DICTPAYLOAD( info );
     238ipc_havetags( const struct ipc_info * session )
     239{
     240    return !DICTPAYLOAD( session );
    245241}
    246242
     
    252248
    253249static int
    254 sessionSupportsMessage( const struct ipc_info * info, enum ipc_msg id )
     250sessionSupportsMessage( const struct ipc_info * session, enum ipc_msg id )
    255251{
    256252    assert( MSGVALID( id ) );
    257     assert( ipc_hasvers( info ) );
    258 
    259     return gl_msgs[id].minvers <= info->vers;
     253    assert( ipc_hasvers( session ) );
     254
     255    return gl_msgs[id].minvers <= session->vers;
    260256}
    261257
     
    314310 */
    315311uint8_t *
    316 ipc_serialize( const tr_benc * pk, size_t * setmeSize )
    317 {
    318     int bencSize = 0;
    319     char * benc = tr_bencSave( pk, &bencSize );
     312ipc_serialize( const tr_benc * benc, size_t * setmeSize )
     313{
    320314    uint8_t * ret = NULL;
    321 
    322     if( bencSize > IPC_MAX_MSG_LEN )
     315    int len = 0;
     316    char * str = tr_bencSave( benc, &len );
     317
     318    if( len > IPC_MAX_MSG_LEN )
    323319        errno = EFBIG;
    324320    else {
    325         const size_t size = IPC_MIN_MSG_LEN + bencSize;
     321        const size_t size = IPC_MIN_MSG_LEN + len;
    326322        ret = tr_new( uint8_t, size );
    327         snprintf( (char*)ret, size, "%0*X", IPC_MIN_MSG_LEN, bencSize );
    328         memcpy( ret + IPC_MIN_MSG_LEN, benc, bencSize );
     323        snprintf( (char*)ret, size, "%0*X", IPC_MIN_MSG_LEN, len );
     324        memcpy( ret + IPC_MIN_MSG_LEN, str, len );
    329325        *setmeSize = size;
    330326    }
    331327
    332     tr_free( benc );
     328    tr_free( str );
    333329    return ret;
    334330}
     
    399395 * Note that this message is just the dictionary payload.
    400396 * It doesn't contain metainfo as the other ipc_mk*() functions do.
     397 * That's because the metainfo is dependent on the protocol version,
     398 * and this is a handshake message to negotiate protocol versions.
     399 *
     400 * @see handlevers()
    401401 */
    402402uint8_t *
     
    448448 */
    449449uint8_t *
    450 ipc_mkgetinfo( const struct ipc_info * session,
    451                size_t                * setmeSize,
    452                enum ipc_msg            msg_id,
    453                int64_t                 tag,
    454                int                     types,
    455                const int             * ids )
     450ipc_createInfoRequest( const struct ipc_info * session,
     451                       size_t                * setmeSize,
     452                       enum ipc_msg            msg_id,
     453                       int64_t                 tag,
     454                       int                     types,
     455                       const int             * ids )
    456456{
    457457    tr_benc   pk;
     
    534534    tr_bencInitInt( tr_bencDictAdd( val, "port" ),     tk->port );
    535535    tr_bencInitStr( tr_bencDictAdd( val, "announce" ), tk->announce, -1, 1 );
    536     if( NULL != tk->scrape )
     536    if( tk->scrape )
    537537        tr_bencInitStr( tr_bencDictAdd( val, "scrape" ), tk->scrape, -1, 1 );
    538538}
     
    553553             int               types )
    554554{
    555     tr_benc * dict, * item, * file, * tier;
     555    tr_benc * dict;
    556556    int          ii, jj, kk;
    557557    tr_file_index_t ff;
     
    580580    for( ii = 0; IPC_INF__MAX > 1 << ii; ii++ )
    581581    {
     582        tr_benc * item;
     583
    582584        if( !( types & ( 1 << ii ) ) )
    583585            continue;
     
    599601                for( ff = 0; inf->fileCount > ff; ff++ )
    600602                {
    601                     file = tr_bencListAdd( item );
     603                    tr_benc * file = tr_bencListAdd( item );
    602604                    tr_bencInitDict( file, 2 );
    603605                    tr_bencInitStr( tr_bencDictAdd( file, "name" ),
     
    629631                for( jj = 0; inf->trackerTiers > jj; jj++ )
    630632                {
    631                     tier = tr_bencListAdd( item );
     633                    tr_benc * tier = tr_bencListAdd( item );
    632634                    tr_bencInitList( tier, inf->trackerList[jj].count );
    633635                    for( kk = 0; inf->trackerList[jj].count > kk; kk++ )
     
    846848}
    847849
     850/**
     851 * This reads a handshake message from the client to decide
     852 * which IPC protocol version to use.
     853 * Returns 0 on success; otherwise, returns -1 and sets errno.
     854 *
     855 * @see ipc_handleMessages()
     856 * @see ipc_mkvers()
     857 */
    848858static int
    849859handlevers( struct ipc_info * info, tr_benc * dict )
    850860{
    851     tr_benc * vers, * num;
     861    tr_benc * vers;
    852862    int64_t      min, max;
    853863
    854     if( TYPE_DICT != dict->type )
     864    if( !tr_bencIsDict( dict ) )
    855865    {
    856866        errno = EINVAL;
     
    871881            max = vers->val.i;
    872882            break;
    873         case TYPE_DICT:
    874             num = tr_bencDictFind( vers, "min" );
    875             min = ( NULL == num || TYPE_INT != num->type ? -1 : num->val.i );
     883        case TYPE_DICT: {
     884            tr_benc * num = tr_bencDictFind( vers, "min" );
     885            min = tr_bencIsInt( num ) ? num->val.i : -1;
    876886            num = tr_bencDictFind( vers, "max" );
    877             max = ( NULL == num || TYPE_INT != num->type ? -1 : num->val.i );
    878             break;
     887            max = tr_bencIsInt( num ) ? num->val.i : -1;
     888            break;
     889        }
    879890        default:
    880891            min = -1;
     
    931942}
    932943
     944/**
     945 * Invokes the trd_msgfunc for the message passed in.
     946 * Returns 0 on success; otherwise, returns -1 and sets errno.
     947 */
    933948static int
    934 gotmsg( const struct ipc_info * info, tr_benc * name, tr_benc * val,
    935         tr_benc * tagval, void * arg )
     949callmsgfunc( const struct ipc_info  * info,
     950             tr_benc                * name,
     951             tr_benc                * val,
     952             tr_benc                * tagval,
     953             void                   * user_data )
    936954{
    937955    const struct msg * msg;
    938956    int64_t            tag;
    939957
    940     if( TYPE_STR != name->type )
    941     {
     958    /* extract tag from tagval */
     959    if( !tagval )
     960        tag = -1;
     961    else if( tr_bencIsInt( tagval ) )
     962        tag = tagval->val.i;
     963    else {
    942964        errno = EINVAL;
    943965        return -1;
    944966    }
    945967
    946     if( NULL == tagval )
    947     {
    948         tag = -1;
    949     }
    950     else
    951     {
    952         if( TYPE_INT != tagval->type )
     968    /* find the msg corresponding to `name' */
     969    if( !tr_bencIsString( name ) ) {
     970        errno = EINVAL;
     971        return -1;
     972    }
     973    msg = msglookup( name->val.s.s );
     974
     975    if( msg && msg->minvers <= info->vers )
     976    {
     977        if( info->funcs->msgs[msg->id] != NULL )
     978        {
     979            (*info->funcs->msgs[msg->id])( msg->id, val, tag, user_data );
     980        }
     981        else if( info->funcs->def )
     982        {
     983            info->funcs->def( msg->id, val, tag, user_data );
     984        }
     985    }
     986    else if( NULL != info->funcs->def )
     987        info->funcs->def( IPC__MSG_UNKNOWN, NULL, tag, user_data );
     988
     989    return 0;
     990}
     991
     992static int
     993handlemsgs( const struct ipc_info  * session,
     994            tr_benc                * message,
     995            void                   * user_data )
     996{
     997    tr_benc * name, * val, * tag;
     998
     999    assert( ipc_hasvers( session ) );
     1000
     1001    if( DICTPAYLOAD( session ) )
     1002    {
     1003        int ii;
     1004
     1005        if( TYPE_DICT != message->type || message->val.l.count % 2 )
    9531006        {
    9541007            errno = EINVAL;
    9551008            return -1;
    9561009        }
    957         tag = tagval->val.i;
    958     }
    959 
    960     msg = msglookup( name->val.s.s );
    961     if( msg && msg->minvers <= info->vers )
    962     {
    963         if( info->funcs->msgs[msg->id] != NULL )
     1010
     1011        for( ii = 0; ii < message->val.l.count; ii += 2 )
    9641012        {
    965             (*info->funcs->msgs[msg->id])( msg->id, val, tag, arg );
     1013            assert( ii + 1 < message->val.l.count );
     1014            name = &message->val.l.vals[ii];
     1015            val  = &message->val.l.vals[ii+1];
     1016            if( 0 > callmsgfunc( session, name, val, NULL, user_data ) )
     1017                return -1;
    9661018        }
    967         else if( info->funcs->def )
    968         {
    969             info->funcs->def( msg->id, val, tag, arg );
    970         }
    971     }
    972     else if( NULL != info->funcs->def )
    973         info->funcs->def( IPC__MSG_UNKNOWN, NULL, tag, arg );
    974 
    975     return 0;
    976 }
    977 
    978 static int
    979 handlemsgs( const struct ipc_info * info, tr_benc * pay, void * arg )
    980 {
    981     tr_benc * name, * val, * tag;
    982     int          ii;
    983 
    984     assert( ipc_hasvers( info ) );
    985 
    986     if( DICTPAYLOAD( info ) )
    987     {
    988         if( TYPE_DICT != pay->type || pay->val.l.count % 2 )
     1019    }
     1020    else
     1021    {
     1022        if( TYPE_LIST != message->type || 2 > message->val.l.count )
    9891023        {
    9901024            errno = EINVAL;
     
    9921026        }
    9931027
    994         for( ii = 0; ii < pay->val.l.count; ii += 2 )
    995         {
    996             assert( ii + 1 < pay->val.l.count );
    997             name = &pay->val.l.vals[ii];
    998             val  = &pay->val.l.vals[ii+1];
    999             if( 0 > gotmsg( info, name, val, NULL, arg ) )
    1000             {
    1001                 return -1;
    1002             }
    1003         }
    1004     }
    1005     else
    1006     {
    1007         if( TYPE_LIST != pay->type || 2 > pay->val.l.count )
    1008         {
    1009             errno = EINVAL;
     1028        name = &message->val.l.vals[0];
     1029        val  = &message->val.l.vals[1];
     1030        tag  = ( 2 == message->val.l.count ? NULL : &message->val.l.vals[2] );
     1031        if( 0 > callmsgfunc( session, name, val, tag, user_data ) )
    10101032            return -1;
    1011         }
    1012 
    1013         name = &pay->val.l.vals[0];
    1014         val  = &pay->val.l.vals[1];
    1015         tag  = ( 2 == pay->val.l.count ? NULL : &pay->val.l.vals[2] );
    1016         if( 0 > gotmsg( info, name, val, tag, arg ) )
    1017         {
    1018             return -1;
    1019         }
    10201033    }
    10211034
     
    10241037
    10251038ssize_t
    1026 ipc_parse( struct ipc_info * info, const uint8_t * buf, ssize_t total, void * arg )
     1039ipc_handleMessages( struct ipc_info  * info,
     1040                    const uint8_t    * msgs,
     1041                    ssize_t            msgslen,
     1042                    void             * user_data )
    10271043{
    10281044    char        hex[IPC_MIN_MSG_LEN+1], * end;
     
    10301046    tr_benc  benc;
    10311047
    1032     for( off = 0; off + IPC_MIN_MSG_LEN < total; off += IPC_MIN_MSG_LEN + len )
    1033     {
    1034         memcpy( hex, buf + off, IPC_MIN_MSG_LEN );
     1048    for( off = 0; off + IPC_MIN_MSG_LEN < msgslen; off += IPC_MIN_MSG_LEN + len )
     1049    {
     1050        memcpy( hex, msgs + off, IPC_MIN_MSG_LEN );
    10351051        hex[IPC_MIN_MSG_LEN] = '\0';
    10361052        end = NULL;
     
    10421058            return -1;
    10431059        }
    1044         if( off + IPC_MIN_MSG_LEN + len > total )
     1060        if( off + IPC_MIN_MSG_LEN + len > msgslen )
    10451061        {
    10461062            break;
    10471063        }
    10481064        errno = 0;
    1049         if( tr_bencLoad( buf + off + IPC_MIN_MSG_LEN, len, &benc, NULL ) )
     1065        if( tr_bencLoad( msgs + off + IPC_MIN_MSG_LEN, len, &benc, NULL ) )
    10501066        {
    10511067            if( 0 == errno )
     
    10551071            return -1;
    10561072        }
    1057         if( 0 > ( ipc_hasvers( info ) ? handlemsgs( info, &benc, arg ) :
     1073        if( 0 > ( ipc_hasvers( info ) ? handlemsgs( info, &benc, user_data ) :
    10581074                                        handlevers( info, &benc ) ) )
    10591075        {
     
    10741090}
    10751091
     1092/**
     1093 * Convert a benc list of string keys from gl_inf or gl_stat
     1094 * into a bitwise-or'ed int representation.
     1095 * msg_id must be either IPC_MSG_INFO or IPC_MSG_STAT.
     1096 * @see ipc_infoname()
     1097 */
    10761098int
    10771099ipc_infotypes( enum ipc_msg id, const tr_benc * list )
     
    10991121    ret = IPC_INF_ID;
    11001122
    1101     if( NULL == list || TYPE_LIST != list->type )
    1102     {
     1123    if( !tr_bencIsList( list ) )
    11031124        return ret;
    1104     }
    11051125
    11061126    for( i=0; i<list->val.l.count; ++i )
     
    11091129        const struct inf * inf;
    11101130
    1111         if( TYPE_STR != name->type )
     1131        if( !tr_bencIsString( name ) )
    11121132            continue;
    11131133
     
    11221142}
    11231143
     1144/**
     1145 * This function is the reverse of ipc_infotypes:
     1146 * it returns the string key that corresponds to the type passed in.
     1147 * Type is one of the IPC_INF_* or IPC_ST_* enums from ipcparse.h.
     1148 * msg_id must be either IPC_MSG_INFO or IPC_MSG_STAT.
     1149 * @see ipc_infotypes()
     1150 */
    11241151const char *
    11251152ipc_infoname( enum ipc_msg id, int type )
  • trunk/libtransmission/ipcparse.h

    r5498 r5506  
    161161                             int64_t tag, const char * val );
    162162uint8_t *    ipc_mkvers    ( size_t *, const char * );
    163 uint8_t *    ipc_mkgetinfo ( const struct ipc_info *, size_t *, enum ipc_msg,
    164                             int64_t, int, const int * );
     163
     164uint8_t *    ipc_createInfoRequest( const struct ipc_info * session,
     165                                    size_t                * setme_len,
     166                                    enum ipc_msg            msg_id,
     167                                    int64_t                 tag,
     168                                    int                     types,
     169                                    const int             * ids );
     170
    165171int          ipc_addinfo   ( struct tr_benc *, int,
    166172                             const struct tr_info *, int );
     
    170176/* sets errno to EINVAL on parse error or
    171177   EPERM for unsupported protocol version */
    172 ssize_t      ipc_parse    ( struct ipc_info *, const uint8_t *,
    173                             ssize_t, void * );
     178ssize_t      ipc_handleMessages( struct ipc_info * session,
     179                                 const uint8_t   * serializedMessages ,
     180                                 ssize_t           serializedLength,
     181                                 void            * user_data );
    174182
    175183/* misc info functions, these will always succeed */
  • trunk/libtransmission/metainfo.c

    r5455 r5506  
    175175    memset( buf, '\0', sizeof( buf ) );
    176176    val = tr_bencDictFindFirst( meta, "comment.utf-8", "comment", NULL );
    177     if( val && val->type == TYPE_STR )
     177    if( tr_bencIsString( val ) )
    178178        strlcat_utf8( buf, val->val.s.s, sizeof( buf ), 0 );
    179179    tr_free( inf->comment );
     
    183183    memset( buf, '\0', sizeof( buf ) );
    184184    val = tr_bencDictFindFirst( meta, "created by.utf-8", "created by", NULL );
    185     if( val && val->type == TYPE_STR )
     185    if( tr_bencIsString( val ) )
    186186        strlcat_utf8( buf, val->val.s.s, sizeof( buf ), 0 );
    187187    tr_free( inf->creator );
     
    191191    inf->dateCreated = 0;
    192192    val = tr_bencDictFind( meta, "creation date" );
    193     if( NULL != val && TYPE_INT == val->type )
    194     {
     193    if( tr_bencIsInt( val ) )
    195194        inf->dateCreated = val->val.i;
    196     }
    197195   
    198196    /* Private torrent */
    199197    val  = tr_bencDictFind( beInfo, "private" );
    200198    val2 = tr_bencDictFind( meta,  "private" );
    201     if( ( NULL != val  && ( TYPE_INT != val->type  || 0 != val->val.i ) ) ||
    202         ( NULL != val2 && ( TYPE_INT != val2->type || 0 != val2->val.i ) ) )
     199    if( ( tr_bencIsInt(val) && val->val.i ) ||
     200        ( tr_bencIsInt(val2) && val2->val.i ) )
    203201    {
    204202        inf->isPrivate = 1;
     
    207205    /* Piece length */
    208206    val = tr_bencDictFind( beInfo, "piece length" );
    209     if( NULL == val || TYPE_INT != val->type )
     207    if( !tr_bencIsInt( val ) )
    210208    {
    211209        if( val )
     
    219217    /* Hashes */
    220218    val = tr_bencDictFind( beInfo, "pieces" );
    221     if( NULL == val || TYPE_STR != val->type )
     219    if( !tr_bencIsString( val ) )
    222220    {
    223221        if( val )
     
    308306getfile( char ** setme, const char * prefix, tr_benc * name )
    309307{
    310     tr_benc     * dir;
    311308    const char ** list;
    312309    int           ii, jj;
    313310    char          buf[4096];
    314311
    315     if( TYPE_LIST != name->type )
    316     {
    317         return TR_EINVALID;
    318     }
     312    if( !tr_bencIsList( name ) )
     313        return TR_EINVALID;
    319314
    320315    list = calloc( name->val.l.count, sizeof( list[0] ) );
    321     if( NULL == list )
    322     {
    323         return TR_EINVALID;
    324     }
     316    if( !list )
     317        return TR_EINVALID;
    325318
    326319    for( ii = jj = 0; name->val.l.count > ii; ii++ )
    327320    {
    328         dir = &name->val.l.vals[ii];
    329         if( TYPE_STR != dir->type )
    330         {
     321        tr_benc * dir = &name->val.l.vals[ii];
     322
     323        if( !tr_bencIsString( dir ) )
    331324            continue;
    332         }
     325
    333326        if( 0 == strcmp( "..", dir->val.s.s ) )
    334327        {
     
    368361static int getannounce( tr_info * inf, tr_benc * meta )
    369362{
    370     tr_benc           * val, * subval, * urlval;
     363    tr_benc           * val, * urlval;
    371364    char              * address, * announce;
    372     int                 ii, jj, port, random, subcount;
     365    int                 ii, jj, port, random;
    373366    tr_tracker_info   * sublist;
    374367    void * swapping;
     
    376369    /* Announce-list */
    377370    val = tr_bencDictFind( meta, "announce-list" );
    378     if( NULL != val && TYPE_LIST == val->type && 0 < val->val.l.count )
     371    if( tr_bencIsList(val) && 0 < val->val.l.count )
    379372    {
    380373        inf->trackerTiers = 0;
     
    385378        for( ii = 0; ii < val->val.l.count; ii++ )
    386379        {
    387             subval = &val->val.l.vals[ii];
    388             if( TYPE_LIST != subval->type || 0 >= subval->val.l.count )
    389             {
     380            int subcount = 0;
     381            tr_benc * subval = &val->val.l.vals[ii];
     382
     383            if( !tr_bencIsList(subval) || 0 >= subval->val.l.count )
    390384                continue;
    391             }
    392             subcount = 0;
     385
    393386            sublist = calloc( subval->val.l.count, sizeof( sublist[0] ) );
    394387
     
    464457    /* Regular announce value */
    465458    val = tr_bencDictFind( meta, "announce" );
    466     if( NULL == val || TYPE_STR != val->type )
     459    if( !tr_bencIsString( val ) )
    467460    {
    468461        tr_err( _( "Missing metadata entry \"%s\"" ), "announce" );
     
    612605    int ii;
    613606
    614     if( NULL == name || TYPE_STR != name->type )
     607    if( !tr_bencIsString( name ) )
    615608    {
    616609        if( name )
     
    630623    inf->totalSize = 0;
    631624
    632     if( files && TYPE_LIST == files->type )
     625    if( tr_bencIsList( files ) )
    633626    {
    634627        /* Multi-file mode */
     
    653646            }
    654647            length = tr_bencDictFind( item, "length" );
    655             if( NULL == length || TYPE_INT != length->type )
     648            if( !tr_bencIsInt( length ) )
    656649            {
    657650                if( length )
     
    665658        }
    666659    }
    667     else if( NULL != length && TYPE_INT == length->type )
     660    else if( tr_bencIsInt( length ) )
    668661    {
    669662        char buf[4096];
  • trunk/macosx/IPCController.m

    r5499 r5506  
    356356        return;
    357357
    358     res = ipc_parse( _ipc, [_buf mutableBytes], [_buf length], self );
     358    res = ipc_handleMessages( _ipc, [_buf mutableBytes], [_buf length], self );
    359359
    360360    if( 0 > res )
Note: See TracChangeset for help on using the changeset viewer.