Changeset 5794


Ignore:
Timestamp:
May 9, 2008, 8:59:34 PM (14 years ago)
Author:
charles
Message:

bang on ipcparse.c for a bit.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/ipcparse.c

    r5673 r5794  
    3939#define TR_N_ELEMENTS( ary ) ( sizeof( ary ) / sizeof( (ary)[0] ) )
    4040
    41 #define SAFEFREE( ptr )      \
    42     do                       \
    43     {                        \
    44         int saved = errno;   \
    45         free( ptr );         \
    46         errno = saved;       \
    47     }                        \
     41#define SAFEFREE( ptr )            \
     42    do                             \
     43    {                              \
     44        const int saved = errno;   \
     45        free( ptr );               \
     46        errno = saved;             \
     47    }                              \
    4848    while( 0 )
    4949
    50 #define SAFEBENCFREE( val )  \
    51     do                       \
    52     {                        \
    53         int saved = errno;   \
    54         tr_bencFree( val );  \
    55         errno = saved;       \
    56     }                        \
     50#define SAFEBENCFREE( val )        \
     51    do                             \
     52    {                              \
     53        int saved = errno;         \
     54        tr_bencFree( val );        \
     55        errno = saved;             \
     56    }                              \
    5757    while( 0 )
    5858
     
    186186};
    187187
     188#define ASSERT_SORTED(A) \
     189  do { \
     190    int i, n; \
     191    for( i=0, n=TR_N_ELEMENTS(A)-1; i<n; ++i ) \
     192      assert( strcmp( A[i].name, A[i+1].name ) < 0 ); \
     193  } while( 0 );
     194
    188195struct ipc_funcs *
    189196ipc_initmsgs( void )
    190197{
     198    ASSERT_SORTED( gl_msgs );
     199    ASSERT_SORTED( gl_inf );
     200    ASSERT_SORTED( gl_stat );
     201
    191202    return tr_new0( struct ipc_funcs, 1 );
    192203}
     
    360371    if(( val = ipc_initval( session, msg_id, tag, &pk, TYPE_INT )))
    361372    {
    362         val->val.i = num;
     373        tr_bencInitInt( val, num );
    363374        ret = ipc_serialize( &pk, setmeSize );
    364375        SAFEBENCFREE( &pk );
     
    383394    if(( val = ipc_initval( session, msg_id, tag, &pk, TYPE_STR )))
    384395    {
    385         tr_bencInitStr( val, str, -1, 1 );
     396        tr_bencInitStrDup( val, str );
    386397        ret = ipc_serialize( &pk, setmeSize );
    387398        SAFEBENCFREE( &pk );
     
    458469    tr_benc   pk;
    459470    tr_benc * typelist;
    460     size_t       ii, typecount, used;
     471    size_t       i, typecount;
    461472    const struct inf * typearray;
    462473    uint8_t    * ret;
     
    479490        /* add the requested IDs */
    480491        tr_bencDictReserve( top, 2 );
    481         idlist   = tr_bencDictAdd( top, "id" );
    482492        typelist = tr_bencDictAdd( top, "type" );
    483493        tr_bencInit( typelist, TYPE_LIST );
    484         for( ii = 0; TORRENT_ID_VALID( ids[ii] ); ii++ ) { }
    485         tr_bencInitList( idlist, ii );
    486         for( ii = 0; TORRENT_ID_VALID( ids[ii] ); ii++ )
    487             tr_bencListAddInt( idlist, ids[ii] );
     494        for( i = 0; TORRENT_ID_VALID( ids[i] ); i++ ) { }
     495        idlist = tr_bencDictAddList( top, "id", i );
     496        for( i = 0; TORRENT_ID_VALID( ids[i] ); i++ )
     497            tr_bencListAddInt( idlist, ids[i] );
    488498    }
    489499
     
    506516    }       
    507517
    508     /* add the type names */
    509     for( ii = used = 0; typecount > ii; ii++ )
    510         if( types & ( 1 << ii ) )
    511             used++;
    512     tr_bencListReserve( typelist, used );
    513 
    514     for( ii = 0; typecount > ii; ii++ )
    515     {
    516         if( !( types & ( 1 << ii ) ) )
    517             continue;
    518         assert( typearray[ii].type == ( 1 << ii ) );
    519         tr_bencInitStr( tr_bencListAdd( typelist ),
    520                         typearray[ii].name, -1, 1 );
    521     }
     518    tr_bencListReserve( typelist, typecount );
     519    for( i=0; i<typecount; ++i )
     520        if( types & typearray[i].type )
     521            tr_bencListAddStr( typelist, typearray[i].name );
    522522
    523523    /* generate packet */
     
    552552             int               types )
    553553{
     554    const tr_info * inf = tr_torrentInfo( tor );
     555    const struct inf * it;
     556    const struct inf * end;
    554557    tr_benc * dict;
    555     int          ii, jj;
    556     tr_file_index_t ff;
    557     const tr_info * inf = tr_torrentInfo( tor );
    558558
    559559    /* always send torrent id */
    560560    types |= IPC_INF_ID;
    561561
    562     tr_bencListReserve( list, 1 );
    563 
    564     dict = tr_bencListAdd( list );
    565 
    566     /* count the number of info keys and allocate a dict for them */
    567     for( ii = jj = 0; IPC_INF__MAX > 1 << ii; ii++ )
    568     {
    569         if( !( types & ( 1 << ii ) ) )
    570             continue;
    571 
    572         assert( TR_N_ELEMENTS( gl_inf ) > ( unsigned )ii );
    573         assert( gl_inf[ii].type == ( 1 << ii ) );
    574         jj++;
    575     }
    576 
    577     tr_bencInitDict( dict, jj );
    578 
    579     /* populate the dict with info key->value pairs */
    580     for( ii = 0; IPC_INF__MAX > 1 << ii; ii++ )
    581     {
    582         tr_benc * item;
    583 
    584         if( !( types & ( 1 << ii ) ) )
    585             continue;
    586 
    587         item = tr_bencDictAdd( dict, gl_inf[ii].name );
    588         switch( 1 << ii )
     562    /* create a dict to hold the info */
     563    dict = tr_bencListAddDict( list, TR_N_ELEMENTS( gl_inf ) );
     564
     565    /* populate the dict */
     566    for( it=gl_inf, end=it+TR_N_ELEMENTS(gl_inf); it!=end; ++it )
     567    {
     568        if( types & it->type )
    589569        {
    590             case IPC_INF_COMMENT:
    591                 tr_bencInitStr( item, inf->comment ? inf->comment : "", -1, 1 );
    592                 break;
    593             case IPC_INF_CREATOR:
    594                 tr_bencInitStr( item, inf->creator ? inf->creator : "", -1, 1 );
    595                 break;
    596             case IPC_INF_DATE:
    597                 tr_bencInitInt( item, inf->dateCreated );
    598                 break;
    599             case IPC_INF_FILES:
    600                 tr_bencInitList( item, inf->fileCount );
    601                 for( ff = 0; inf->fileCount > ff; ff++ )
    602                 {
    603                     tr_benc * file = tr_bencListAdd( item );
    604                     tr_bencInitDict( file, 2 );
    605                     tr_bencInitStr( tr_bencDictAdd( file, "name" ),
    606                                     inf->files[ff].name, -1, 1 );
    607                     tr_bencInitInt( tr_bencDictAdd( file, "size" ),
    608                                     inf->files[ff].length );
     570            tr_benc * val = tr_bencDictAdd( dict, it->name );
     571
     572            switch( it->type )
     573            {
     574                case IPC_INF_COMMENT:
     575                    tr_bencInitStrDup( val, inf->comment ? inf->comment : "" );
     576                    break;
     577                case IPC_INF_CREATOR:
     578                    tr_bencInitStrDup( val, inf->creator ? inf->creator : "" );
     579                    break;
     580                case IPC_INF_DATE:
     581                    tr_bencInitInt( val, inf->dateCreated );
     582                    break;
     583                case IPC_INF_FILES: {
     584                    tr_file_index_t f;
     585                    tr_bencInitList( val, inf->fileCount );
     586                    for( f=0; f<inf->fileCount; ++f ) {
     587                        tr_benc * file = tr_bencListAddDict( val, 2 );
     588                        tr_bencDictAddStr( file, "name", inf->files[f].name );
     589                        tr_bencDictAddInt( file, "size", inf->files[f].length );
     590                    }
     591                    break;
    609592                }
    610                 break;
    611             case IPC_INF_HASH:
    612                 tr_bencInitStr( item, inf->hashString, -1, 1 );
    613                 break;
    614             case IPC_INF_ID:
    615                 tr_bencInitInt( item, torrent_id );
    616                 break;
    617             case IPC_INF_NAME:
    618                 tr_bencInitStr( item, inf->name, -1, 1 );
    619                 break;
    620             case IPC_INF_PATH:
    621                 tr_bencInitStr( item, inf->torrent, -1, 1 );
    622                 break;
    623             case IPC_INF_PRIVATE:
    624                 tr_bencInitInt( item, inf->isPrivate ? 1 : 0 );
    625                 break;
    626             case IPC_INF_SIZE:
    627                 tr_bencInitInt( item, inf->totalSize );
    628                 break;
    629             case IPC_INF_TRACKERS: {
    630                 int prevTier = -1;
    631                 tr_benc * tier = NULL;
    632                 tr_bencInitList( item, 0 );
    633                 for( jj=0; jj<inf->trackerCount; ++jj ) {
    634                     if( prevTier != inf->trackers[jj].tier ) {
    635                         prevTier = inf->trackers[jj].tier;
    636                         tier = tr_bencListAddList( item, 0 );
     593                case IPC_INF_HASH:
     594                    tr_bencInitStr( val, inf->hashString, -1, 1 );
     595                    break;
     596                case IPC_INF_ID:
     597                    tr_bencInitInt( val, torrent_id );
     598                    break;
     599                case IPC_INF_NAME:
     600                    tr_bencInitStrDup( val, inf->name );
     601                    break;
     602                case IPC_INF_PATH:
     603                    tr_bencInitStrDup( val, inf->torrent );
     604                    break;
     605                case IPC_INF_PRIVATE:
     606                    tr_bencInitInt( val, inf->isPrivate ? 1 : 0 );
     607                    break;
     608                case IPC_INF_SIZE:
     609                    tr_bencInitInt( val, inf->totalSize );
     610                    break;
     611                case IPC_INF_TRACKERS: {
     612                    int j;
     613                    int prevTier = -1;
     614                    tr_benc * tier = NULL;
     615                    tr_bencInitList( val, 0 );
     616                    for( j=0; j<inf->trackerCount; ++j ) {
     617                        if( prevTier != inf->trackers[j].tier ) {
     618                            prevTier = inf->trackers[j].tier;
     619                            tier = tr_bencListAddList( val, 0 );
     620                        }
     621                        filltracker( tr_bencListAdd( tier ), &inf->trackers[j] );
    637622                    }
    638                     filltracker( tr_bencListAdd( tier ), &inf->trackers[jj] );
     623                    break;
    639624                }
    640                 break;
     625                default:
     626                    assert( 0 );
     627                    break;
    641628            }
    642             default:
    643                 assert( 0 );
    644                 break;
    645629        }
    646630    }
     
    665649{
    666650    const tr_stat * st = tr_torrentStatCached( tor );
     651    const struct inf * it;
     652    const struct inf * end;
    667653    tr_benc  * dict;
    668     int ii, used;
    669 
    670     /* add the dictionary child */
    671     tr_bencListReserve( list, 1 );
    672     dict = tr_bencListAdd( list );
    673654
    674655    /* always send torrent id */
    675656    types |= IPC_ST_ID;
    676657
    677     /* count the number of stat keys and allocate a dict for them */
    678     for( ii = used = 0; IPC_ST__MAX > 1 << ii; ii++ )
    679         if( types & ( 1 << ii ) )
    680             used++;
    681     tr_bencInitDict( dict, used );
     658    /* add the dictionary child */
     659    dict = tr_bencListAddDict( list, TR_N_ELEMENTS( gl_stat ) );
    682660
    683661    /* populate the dict */
    684     for( ii = 0; IPC_ST__MAX > 1 << ii; ii++ )
    685     {
    686         tr_benc * item;
    687 
    688         if( !( types & ( 1 << ii ) ) )
    689             continue;
    690 
    691         assert( TR_N_ELEMENTS( gl_stat ) > ( unsigned )ii );
    692         assert( gl_stat[ii].type == ( 1 << ii ) );
    693         item = tr_bencDictAdd( dict, gl_stat[ii].name );
    694         switch( 1 << ii )
     662    for( it=gl_stat, end=it+TR_N_ELEMENTS(gl_stat); it!=end; ++it )
     663    {
     664        if( types & it->type )
    695665        {
    696             case IPC_ST_COMPLETED:
    697             case IPC_ST_DOWNVALID:
    698                 tr_bencInitInt( item, st->haveValid );
    699                 break;
    700             case IPC_ST_DOWNSPEED:
    701                 tr_bencInitInt( item, st->rateDownload * 1024 );
    702                 break;
    703             case IPC_ST_DOWNTOTAL:
    704                 tr_bencInitInt( item, st->downloadedEver );
    705                 break;
    706             case IPC_ST_ERROR: {
    707                 const tr_errno error = st->error;
    708                 if( TR_OK == error )
    709                 {
    710                     tr_bencInitStr( item, "", -1, 1 );
     666            tr_benc * val = tr_bencDictAdd( dict, it->name );
     667
     668            switch( it->type )
     669            {
     670                case IPC_ST_COMPLETED:
     671                case IPC_ST_DOWNVALID:
     672                    tr_bencInitInt( val, st->haveValid );
     673                    break;
     674                case IPC_ST_DOWNSPEED:
     675                    tr_bencInitInt( val, st->rateDownload * 1024 );
     676                    break;
     677                case IPC_ST_DOWNTOTAL:
     678                    tr_bencInitInt( val, st->downloadedEver );
     679                    break;
     680                case IPC_ST_ERROR: {
     681                    const char * s;
     682                    const tr_errno e = st->error;
     683                    if( !e ) s = "";
     684                    else if( e == TR_ERROR_ASSERT )          s = "assert";
     685                    else if( e == TR_ERROR_IO_PERMISSIONS )  s = "io-permissions";
     686                    else if( e == TR_ERROR_IO_SPACE )        s = "io-space";
     687                    else if( e == TR_ERROR_IO_FILE_TOO_BIG ) s = "io-file-too-big";
     688                    else if( e == TR_ERROR_IO_OPEN_FILES )   s = "io-open-files";
     689                    else if( TR_ERROR_IS_IO( e ) )           s = "io-other";
     690                    else if( e == TR_ERROR_TC_ERROR )        s = "tracker-error";
     691                    else if( e == TR_ERROR_TC_WARNING )      s = "tracker-warning";
     692                    else if( TR_ERROR_IS_TC( e ) )           s = "tracker-other";
     693                    else                                     s = "other";
     694                    tr_bencInitStrDup( val, s );
     695                    break;
    711696                }
    712                 else if( error == TR_ERROR_ASSERT )
    713                 {
    714                     tr_bencInitStr( item, "assert", -1, 1 );
     697                case IPC_ST_ERRMSG: {
     698                    const char * s;
     699                    if( !st->error ) s = "";
     700                    else if( !*st->errorString ) s = "other";
     701                    else s = st->errorString;
     702                    tr_bencInitStrDup( val, s );
     703                    break;
    715704                }
    716                 else if( error == TR_ERROR_IO_PERMISSIONS )
    717                 {
    718                     tr_bencInitStr( item, "io-permissions", -1, 1 );
     705                case IPC_ST_ETA:
     706                    tr_bencInitInt( val, st->eta );
     707                    break;
     708                case IPC_ST_ID:
     709                    tr_bencInitInt( val, torrent_id );
     710                    break;
     711                case IPC_ST_PEERDOWN:
     712                    tr_bencInitInt( val, st->peersSendingToUs );
     713                    break;
     714                case IPC_ST_PEERFROM: {
     715                    const int * c = st->peersFrom;
     716                    tr_bencInitDict( val, 4 );
     717                    tr_bencDictAddInt( val, "cache",    c[TR_PEER_FROM_CACHE] );
     718                    tr_bencDictAddInt( val, "incoming", c[TR_PEER_FROM_INCOMING] );
     719                    tr_bencDictAddInt( val, "pex",      c[TR_PEER_FROM_PEX] );
     720                    tr_bencDictAddInt( val, "tracker",  c[TR_PEER_FROM_TRACKER] );
     721                    break;
    719722                }
    720                 else if( error == TR_ERROR_IO_SPACE )
    721                 {
    722                     tr_bencInitStr( item, "io-space", -1, 1 );
     723                case IPC_ST_PEERMAX:
     724                    tr_bencInitInt( val, tor->maxConnectedPeers );
     725                    break;
     726                case IPC_ST_PEERTOTAL:
     727                    tr_bencInitInt( val, st->peersConnected );
     728                    break;
     729                case IPC_ST_PEERUP:
     730                    tr_bencInitInt( val, st->peersGettingFromUs );
     731                    break;
     732                case IPC_ST_RUNNING:
     733                    tr_bencInitInt( val, TR_STATUS_IS_ACTIVE(st->status) );
     734                    break;
     735                case IPC_ST_STATE: {
     736                    const char * s;
     737                    if( TR_STATUS_CHECK_WAIT & st->status )    s = "waiting to check";
     738                    else if( TR_STATUS_CHECK & st->status )    s = "checking";
     739                    else if( TR_STATUS_DOWNLOAD & st->status ) s = "downloading";
     740                    else if( TR_STATUS_SEED & st->status )     s = "seeding";
     741                    else if( TR_STATUS_STOPPED & st->status )  s = "paused";
     742                    else                                       s = "error";
     743                    tr_bencInitStr( val, s, -1, 1 );
     744                    break;
    723745                }
    724                 else if( error == TR_ERROR_IO_FILE_TOO_BIG )
    725                 {
    726                     tr_bencInitStr( item, "io-file-too-big", -1, 1 );
    727                 }
    728                 else if( error == TR_ERROR_IO_OPEN_FILES )
    729                 {
    730                     tr_bencInitStr( item, "io-open-files", -1, 1 );
    731                 }
    732                 else if( TR_ERROR_IS_IO( error ) )
    733                 {
    734                     tr_bencInitStr( item, "io-other", -1, 1 );
    735                 }
    736                 else if( error == TR_ERROR_TC_ERROR )
    737                 {
    738                     tr_bencInitStr( item, "tracker-error", -1, 1 );
    739                 }
    740                 else if( error == TR_ERROR_TC_WARNING )
    741                 {
    742                     tr_bencInitStr( item, "tracker-warning", -1, 1 );
    743                 }
    744                 else if( TR_ERROR_IS_TC( error ) )
    745                 {
    746                     tr_bencInitStr( item, "tracker-other", -1, 1 );
    747                 }
    748                 else
    749                 {
    750                     tr_bencInitStr( item, "other", -1, 1 );
    751                 }
    752                 break;
     746                case IPC_ST_SWARM:
     747                    tr_bencInitInt( val, st->swarmspeed * 1024 );
     748                    break;
     749                case IPC_ST_TRACKER:
     750                    filltracker( val, st->tracker );
     751                    break;
     752                case IPC_ST_TKDONE:
     753                    tr_bencInitInt( val, st->completedFromTracker );
     754                    break;
     755                case IPC_ST_TKLEECH:
     756                    tr_bencInitInt( val, st->leechers );
     757                    break;
     758                case IPC_ST_TKSEED:
     759                    tr_bencInitInt( val, st->seeders );
     760                    break;
     761                case IPC_ST_UPSPEED:
     762                    tr_bencInitInt( val, st->rateUpload * 1024 );
     763                    break;
     764                case IPC_ST_UPTOTAL:
     765                    tr_bencInitInt( val, st->uploadedEver );
     766                    break;
     767                default:
     768                    assert( 0 );
     769                    break;
    753770            }
    754             case IPC_ST_ERRMSG:
    755                 if( TR_OK == st->error )
    756                 {
    757                     tr_bencInitStr( item, "", -1, 1 );
    758                 }
    759                 else if( '\0' == st->errorString[0] )
    760                 {
    761                     tr_bencInitStr( item, "other", -1, 1 );
    762                 }
    763                 else if( tr_bencInitStrDup( item, st->errorString ) )
    764                 {
    765                     return -1;
    766                 }
    767                 break;
    768             case IPC_ST_ETA:
    769                 tr_bencInitInt( item, st->eta );
    770                 break;
    771             case IPC_ST_ID:
    772                 tr_bencInitInt( item, torrent_id );
    773                 break;
    774             case IPC_ST_PEERDOWN:
    775                 tr_bencInitInt( item, st->peersSendingToUs );
    776                 break;
    777             case IPC_ST_PEERFROM:
    778                 tr_bencInitDict( item, 4 );
    779                 tr_bencInitInt( tr_bencDictAdd( item, "incoming" ),
    780                                 st->peersFrom[TR_PEER_FROM_INCOMING] );
    781                 tr_bencInitInt( tr_bencDictAdd( item, "tracker" ),
    782                                 st->peersFrom[TR_PEER_FROM_TRACKER] );
    783                 tr_bencInitInt( tr_bencDictAdd( item, "cache" ),
    784                                 st->peersFrom[TR_PEER_FROM_CACHE] );
    785                 tr_bencInitInt( tr_bencDictAdd( item, "pex" ),
    786                                 st->peersFrom[TR_PEER_FROM_PEX] );
    787                 break;
    788             case IPC_ST_PEERMAX:
    789                 tr_bencInitInt( item, tor->maxConnectedPeers );
    790                 break;
    791             case IPC_ST_PEERTOTAL:
    792                 tr_bencInitInt( item, st->peersConnected );
    793                 break;
    794             case IPC_ST_PEERUP:
    795                 tr_bencInitInt( item, st->peersGettingFromUs );
    796                 break;
    797             case IPC_ST_RUNNING:
    798                 tr_bencInitInt( item, TR_STATUS_IS_ACTIVE(st->status) );
    799                 break;
    800             case IPC_ST_STATE:
    801                 if( TR_STATUS_CHECK_WAIT & st->status )
    802                 {
    803                     tr_bencInitStr( item, "waiting to checking", -1, 1 );
    804                 }
    805                 else if( TR_STATUS_CHECK & st->status )
    806                 {
    807                     tr_bencInitStr( item, "checking", -1, 1 );
    808                 }
    809                 else if( TR_STATUS_DOWNLOAD & st->status )
    810                 {
    811                     tr_bencInitStr( item, "downloading", -1, 1 );
    812                 }
    813                 else if( TR_STATUS_SEED & st->status )
    814                 {
    815                     tr_bencInitStr( item, "seeding", -1, 1 );
    816                 }
    817                 else if( TR_STATUS_STOPPED & st->status )
    818                 {
    819                     tr_bencInitStr( item, "paused", -1, 1 );
    820                 }
    821                 else
    822                 {
    823                     assert( 0 );
    824                 }
    825                 break;
    826             case IPC_ST_SWARM:
    827                 tr_bencInitInt( item, st->swarmspeed * 1024 );
    828                 break;
    829             case IPC_ST_TRACKER:
    830                 filltracker( item, st->tracker );
    831                 break;
    832             case IPC_ST_TKDONE:
    833                 tr_bencInitInt( item, st->completedFromTracker );
    834                 break;
    835             case IPC_ST_TKLEECH:
    836                 tr_bencInitInt( item, st->leechers );
    837                 break;
    838             case IPC_ST_TKSEED:
    839                 tr_bencInitInt( item, st->seeders );
    840                 break;
    841             case IPC_ST_UPSPEED:
    842                 tr_bencInitInt( item, st->rateUpload * 1024 );
    843                 break;
    844             case IPC_ST_UPTOTAL:
    845                 tr_bencInitInt( item, st->uploadedEver );
    846                 break;
    847             default:
    848                 assert( 0 );
    849                 break;
    850771        }
    851772    }
     
    884805    {
    885806        case TYPE_INT:
    886             min = vers->val.i;
    887             max = vers->val.i;
    888             break;
    889         case TYPE_DICT: {
    890             tr_benc * num = tr_bencDictFind( vers, "min" );
    891             min = tr_bencIsInt( num ) ? num->val.i : -1;
    892             num = tr_bencDictFind( vers, "max" );
    893             max = tr_bencIsInt( num ) ? num->val.i : -1;
    894             break;
    895         }
     807            min = max = vers->val.i;
     808            break;
     809        case TYPE_DICT:
     810            min = max = -1;
     811            tr_bencDictFindInt( vers, "min", &min );
     812            tr_bencDictFindInt( vers, "max", &max );
     813            break;
    896814        default:
    897             min = -1;
    898             max = -1;
     815            min = max = -1;
    899816            break;
    900817    }
     
    11581075ipc_infoname( enum ipc_msg id, int type )
    11591076{
    1160     const struct inf * array;
    1161     size_t len, ii;
     1077    const struct inf * it;
     1078    const struct inf * end;
    11621079
    11631080    switch( id )
    11641081    {
    11651082        case IPC_MSG_INFO:
    1166             array = gl_inf;
    1167             len   = TR_N_ELEMENTS( gl_inf );
     1083            it = gl_inf;
     1084            end = it + TR_N_ELEMENTS( gl_inf );
    11681085            break;
    11691086        case IPC_MSG_STAT:
    1170             array = gl_stat;
    1171             len   = TR_N_ELEMENTS( gl_stat );
     1087            it = gl_stat;
     1088            end = it + TR_N_ELEMENTS( gl_stat );
    11721089            break;
    11731090        default:
     
    11761093    }
    11771094
    1178     for( ii = 0; len > ii; ii++ )
    1179         if( array[ii].type == type )
    1180             return array[ii].name;
     1095    for( ; it!=end; ++it )
     1096        if( it->type == type )
     1097            return it->name;
    11811098
    11821099    assert( 0 );
Note: See TracChangeset for help on using the changeset viewer.