Changeset 5151


Ignore:
Timestamp:
Feb 27, 2008, 8:06:53 PM (14 years ago)
Author:
charles
Message:

eliminate duplicate code between readfile() and tr_loadFile(). shrink down the daemon torrent code a bit.

Location:
trunk/daemon
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/daemon/misc.c

    r2514 r5151  
    3535#include <libtransmission/transmission.h>
    3636#include <libtransmission/trcompat.h>
     37#include <libtransmission/utils.h> /* tr_loadFile() */
    3738
    3839#include "errors.h"
     
    155156
    156157uint8_t *
    157 readfile( const char * name, size_t * len )
    158 {
    159     struct stat sb;
    160     int         fd;
    161     uint8_t   * buf;
    162     ssize_t     res;
    163 
    164     fd = open( name, O_RDONLY );
    165     if( 0 > fd )
    166     {
    167         if( ENOENT != errno )
    168         {
    169             errnomsg( "failed to open %s for reading", name );
    170         }
    171         return NULL;
    172     }
    173 
    174     if( 0 > fstat( fd, &sb ) )
    175     {
    176         errnomsg( "failed to stat %s", name );
    177         return NULL;
    178     }
    179 
    180     buf = malloc( sb.st_size );
    181     if( NULL == buf )
    182     {
    183         mallocmsg( sb.st_size );
    184         return NULL;
    185     }
    186 
    187     res = read( fd, buf, sb.st_size );
    188     if( 0 > res )
    189     {
    190         errnomsg( "failed to read from %s", name );
    191         free( buf );
    192         return NULL;
    193     }
    194     if( res < sb.st_size )
    195     {
    196         errmsg( "failed to read all data from %s", name );
    197         free( buf );
    198         return NULL;
    199     }
    200 
    201     close( fd );
    202     *len = res;
    203 
    204     return buf;
     158readfile( const char * filename, size_t * len )
     159{
     160    return tr_loadFile( filename, len );
    205161}
    206162
  • trunk/daemon/misc.h

    r3175 r5151  
    108108
    109109#define INTCMP_FUNC( name, type, id )                                         \
    110 int                                                                           \
     110static int                                                                    \
    111111name( struct type * _icf_first, struct type * _icf_second )                   \
    112112{                                                                             \
    113113    if( _icf_first->id < _icf_second->id )                                    \
    114     {                                                                         \
    115114        return -1;                                                            \
    116     }                                                                         \
    117     else if( _icf_first->id > _icf_second->id )                               \
    118     {                                                                         \
     115    if( _icf_first->id > _icf_second->id )                                    \
    119116        return 1;                                                             \
    120     }                                                                         \
    121     else                                                                      \
    122     {                                                                         \
    123         return 0;                                                             \
    124     }                                                                         \
     117    return 0;                                                                 \
    125118}
    126119
  • trunk/daemon/torrents.c

    r5143 r5151  
    7272static int          loadstate  ( void );
    7373static int          savestate  ( void );
    74 static int          toridcmp   ( struct tor *, struct tor * );
    75 static int          torhashcmp ( struct tor *, struct tor * );
    76 static struct tor * hashlookup ( const uint8_t * );
    77 static struct tor * iterate    ( struct tor * );
    7874
    7975static struct event_base * gl_base      = NULL;
     
    9793static tr_encryption_mode  gl_crypto    = TR_ENCRYPTION_PREFERRED;
    9894
     95static int
     96torhashcmp( struct tor * left, struct tor * right )
     97{
     98    return memcmp( left->hash, right->hash, sizeof left->hash );
     99}
     100
     101RB_GENERATE_STATIC( hashtree, tor, hashlinks, torhashcmp )
     102
     103INTCMP_FUNC( toridcmp, tor, id )
    99104RB_GENERATE_STATIC( tortree, tor, idlinks, toridcmp )
    100 RB_GENERATE_STATIC( hashtree, tor, hashlinks, torhashcmp )
    101 INTCMP_FUNC( toridcmp, tor, id )
    102105
    103106void
     
    242245}
    243246
     247static struct tor *
     248hashlookup( const uint8_t * hash )
     249{
     250    struct tor key, * found;
     251
     252    memset( &key, 0, sizeof key );
     253    memcpy( key.hash, hash, sizeof key.hash );
     254    found = RB_FIND( hashtree, &gl_hashes, &key );
     255
     256    return found;
     257}
     258
    244259int
    245260torrent_lookup( const uint8_t * hashstr )
     
    273288}
    274289
     290static struct tor *
     291iterate( struct tor * tor )
     292{
     293    struct tor * next = NULL;
     294
     295    if( gl_handle && !gl_exiting )
     296        next = tor ? RB_NEXT( tortree, &gl_tree, tor )
     297                   : RB_MIN( tortree, &gl_tree );
     298
     299    return next;
     300}
     301
    275302void *
    276 torrent_iter( void * iter, int * id )
    277 {
    278     struct tor * tor = iter;
    279 
    280     assert( NULL != gl_handle );
    281     assert( !gl_exiting );
    282 
    283     tor = iterate( tor );
    284 
    285     if( NULL != tor )
    286     {
    287         *id = tor->id;
    288     }
    289 
    290     return tor;
     303torrent_iter( void * cur, int * id )
     304{
     305    struct tor * next = iterate( cur );
     306    if( next )
     307        *id = next->id;
     308    return next;
    291309}
    292310
     
    849867    return 0;
    850868}
    851 
    852 int
    853 torhashcmp( struct tor * left, struct tor * right )
    854 {
    855     return memcmp( left->hash, right->hash, sizeof left->hash );
    856 }
    857 
    858 struct tor *
    859 hashlookup( const uint8_t * hash )
    860 {
    861     struct tor key, * found;
    862 
    863     memset( &key, 0, sizeof key );
    864     memcpy( key.hash, hash, sizeof key.hash );
    865     found = RB_FIND( hashtree, &gl_hashes, &key );
    866 
    867     return found;
    868 }
    869 
    870 struct tor *
    871 iterate( struct tor * tor )
    872 {
    873     assert( NULL != gl_handle );
    874     assert( !gl_exiting );
    875 
    876     if( NULL == tor )
    877     {
    878         tor = RB_MIN( tortree, &gl_tree );
    879     }
    880     else
    881     {
    882         tor = RB_NEXT( tortree, &gl_tree, tor );
    883     }
    884 
    885     return tor;
    886 }
Note: See TracChangeset for help on using the changeset viewer.