Changeset 2206


Ignore:
Timestamp:
Jun 27, 2007, 5:14:38 AM (15 years ago)
Author:
charles
Message:

add tr_torrentCanAdd() as per BentMyWookie?'s request... clear tracker error string when restarting... fix r2202 "completed" announce bug.

Location:
trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/cli/transmissioncli.c

    r2202 r2206  
    155155
    156156    /* Open and parse torrent file */
    157     if( !( tor = tr_torrentInit( h, torrentPath, ".", NULL, 0, &error ) ) )
     157    if( !( tor = tr_torrentInit( h, torrentPath, ".", 0, &error ) ) )
    158158    {
    159159        printf( "Failed opening torrent file `%s'\n", torrentPath );

  • trunk/daemon/torrents.c

    r2204 r2206  
    503503    {
    504504        tor->tor = tr_torrentInit( gl_handle, path, dir,
    505                                    tor->hash,
    506505                                   TR_FLAG_SAVE, &errcode );
    507506    }
    … …  
    513512    {
    514513        tor->tor = tr_torrentInitData( gl_handle, data, size, dir,
    515                                        tor->hash, TR_FLAG_SAVE, &errcode );
     514                                       TR_FLAG_SAVE, &errcode );
    516515    }
    517516

  • trunk/gtk/tr_torrent.c

    r2202 r2206  
    313313      flags |= TR_FLAG_PAUSED;
    314314
    315   handle = tr_torrentInit( back, torrent, dir, NULL, flags, &errcode );
     315  handle = tr_torrentInit( back, torrent, dir, flags, &errcode );
    316316
    317317  if(NULL == handle) {
    … …  
    355355
    356356    errcode = -1;
    357     handle  = tr_torrentInitData( back, data, size, dir, NULL, flags, &errcode );
     357    handle  = tr_torrentInitData( back, data, size, dir, flags, &errcode );
    358358
    359359    if( NULL == handle )
    … …  
    434434    handle = tr_torrentInitSaved(back, hash, dir, flags, &errcode);
    435435  else
    436     handle = tr_torrentInit(back, torrent, dir, NULL, flags, &errcode);
     436    handle = tr_torrentInit(back, torrent, dir, flags, &errcode);
    437437
    438438  if(NULL == handle) {

  • trunk/libtransmission/makemeta.c

    r2184 r2206  
    6464    else if( S_ISREG( sb.st_mode ) )
    6565    {
    66         struct FileList * node = tr_malloc( sizeof( struct FileList ) );
     66        struct FileList * node = tr_new( struct FileList, 1 );
    6767        node->size = sb.st_size;
    6868        node->filename = tr_strdup( buf );
    … …  
    118118    struct FileList * files;
    119119    struct FileList * walk;
    120     tr_metainfo_builder_t * ret = tr_calloc( 1, sizeof(tr_metainfo_builder_t) );
     120    tr_metainfo_builder_t * ret = tr_new0( tr_metainfo_builder_t, 1 );
    121121    ret->top = tr_strdup( topFile );
    122122    ret->handle = handle;
    … …  
    143143        ++ret->fileCount;
    144144
    145     ret->files = tr_calloc(ret->fileCount, sizeof(tr_metainfo_builder_file_t));
     145    ret->files = tr_new0( tr_metainfo_builder_file_t, ret->fileCount );
    146146
    147147    for( i=0, walk=files; walk!=NULL; ++i )
    … …  
    194194{
    195195    int fileIndex = 0;
    196     uint8_t *ret = (uint8_t*) tr_malloc ( SHA_DIGEST_LENGTH * b->pieceCount );
     196    uint8_t *ret = tr_new( uint8_t, SHA_DIGEST_LENGTH * b->pieceCount );
    197197    uint8_t *walk = ret;
    198     uint8_t *buf = tr_malloc( b->pieceSize );
     198    uint8_t *buf = tr_new( uint8_t, b->pieceSize );
    199199    uint64_t totalRemain;
    200200    uint64_t off = 0;
    … …  
    423423    if( lock == NULL )
    424424    {
    425         lock = tr_calloc( 1, sizeof( tr_lock_t ) );
     425        lock = tr_new0( tr_lock_t, 1 );
    426426        tr_lockInit( lock );
    427427    }

  • trunk/libtransmission/torrent.c

    r2202 r2206  
    9898
    9999static int
    100 tr_torrentDuplicateDownload( tr_torrent_t * tor )
    101 {
    102     tr_torrent_t * current;
    103    
    104     /* Check if a torrent with the same name and destination is already active */
    105     for( current = tor->handle->torrentList; current; current = current->next )
    106     {
    107         if( current != tor
    108             && !strcmp( tor->destination, current->destination )
    109             && !strcmp( tor->info.name, current->info.name ) )
    110         {
    111             return TRUE;
    112         }
    113     }
    114     return FALSE;
    115 }
    116 
    117 static int
    118100getBytePiece( const tr_info_t * info, uint64_t byteOffset )
    119101{
    … …  
    160142}
    161143
    162 void
     144static void
    163145tr_torrentInitFilePieces( tr_torrent_t * tor )
    164146{
    … …  
    180162static void torrentThreadLoop( void * );
    181163
    182 static tr_torrent_t *
     164static void
    183165torrentRealInit( tr_handle_t   * h,
    184166                 tr_torrent_t  * tor,
    185167                 const char    * destination,
    186                  uint8_t       * hash,
    187                  int             flags,
    188                  int           * error )
    189 {
     168                 int             flags )
     169{
     170    int i;
    190171    char name[512];
    191     tr_torrent_t  * tor_tmp;
    192     tr_info_t     * inf;
    193     int             i;
    194172   
    195     inf         = &tor->info;
    196     inf->flags |= flags;
     173    tor->info.flags = flags;
    197174
    198175    tr_sharedLock( h->shared );
    199176
    200177    tor->destination = tr_strdup( destination );
    201 
    202     /* Make sure this torrent is not already open */
    203     for( tor_tmp = h->torrentList; tor_tmp; tor_tmp = tor_tmp->next )
    204     {
    205         if( !memcmp( tor->info.hash, tor_tmp->info.hash,
    206                      SHA_DIGEST_LENGTH ) )
    207         {
    208             if( NULL != hash )
    209             {
    210                 memcpy( hash, tor->info.hash, SHA_DIGEST_LENGTH );
    211             }
    212             *error = TR_EDUPLICATE;
    213             tr_metainfoFree( &tor->info );
    214             free( tor );
    215             tr_sharedUnlock( h->shared );
    216             return NULL;
    217         }
    218     }
    219178
    220179    tr_torrentInitFilePieces( tor );
    … …  
    226185    tor->hasChangedState = -1;
    227186   
    228     /* Don't start if a torrent with the same name
    229        and destination is already active */
    230     if( tr_torrentDuplicateDownload( tor ) )
    231     {
    232         *error = TR_ERROR_IO_DUP_DOWNLOAD;
    233         tr_metainfoFree( &tor->info );
    234         free( tor );
    235         tr_sharedUnlock( h->shared );
    236         return NULL;
    237     }
    238 
    239187    /* Escaped info hash for HTTP queries */
    240188    for( i = 0; i < SHA_DIGEST_LENGTH; i++ )
    … …  
    242190        snprintf( &tor->escapedHashString[3*i],
    243191                  sizeof( tor->escapedHashString ) - 3 * i,
    244                   "%%%02x", inf->hash[i] );
     192                  "%%%02x", tor->info.hash[i] );
    245193    }
    246194
    … …  
    248196
    249197    /* Block size: usually 16 ko, or less if we have to */
    250     tor->blockSize  = MIN( inf->pieceSize, 1 << 14 );
    251     tor->blockCount = ( inf->totalSize + tor->blockSize - 1 ) /
     198    tor->blockSize  = MIN( tor->info.pieceSize, 1 << 14 );
     199    tor->blockCount = ( tor->info.totalSize + tor->blockSize - 1 ) /
    252200                        tor->blockSize;
    253201    tor->completion = tr_cpInit( tor );
    … …  
    284232    snprintf( name, sizeof( name ), "torrent %p (%s)", tor, tor->info.name );
    285233    tr_threadCreate( &tor->thread, torrentThreadLoop, tor, name );
    286 
    287     return tor;
    288 }
    289 
     234}
     235
     236static int
     237pathIsInUse ( const tr_handle_t   * h,
     238              const char          * destination,
     239              const char          * name )
     240{
     241    const tr_torrent_t * tor;
     242   
     243    for( tor=h->torrentList; tor; tor=tor->next )
     244        if( !strcmp( destination, tor->destination )
     245         && !strcmp( name, tor->info.name ) )
     246            return TRUE;
     247
     248    return FALSE;
     249}
     250
     251static int
     252hashExists( const tr_handle_t   * h,
     253            const uint8_t       * hash )
     254{
     255    const tr_torrent_t * tor;
     256
     257    for( tor=h->torrentList; tor; tor=tor->next )
     258        if( !memcmp( hash, tor->info.hash, SHA_DIGEST_LENGTH ) )
     259            return TRUE;
     260
     261    return FALSE;
     262}
     263
     264static int
     265infoCanAdd( const tr_handle_t   * h,
     266            const char          * destination,
     267            const tr_info_t     * info )
     268{
     269    if( hashExists( h, info->hash ) )
     270        return TR_EDUPLICATE;
     271
     272    if( pathIsInUse( h, destination, info->name ) )
     273        return TR_ERROR_IO_DUP_DOWNLOAD;
     274
     275    return TR_OK;
     276}
     277
     278int
     279tr_torrentCanAdd( const tr_handle_t  * h,
     280                  const char         * destination,
     281                  const char         * path )
     282{
     283    tr_info_t info;
     284
     285    if( tr_metainfoParseFile( &info, h->tag, path, FALSE ) )
     286        return TR_EINVALID;
     287
     288    return infoCanAdd( h, destination, &info );
     289}
     290 
    290291tr_torrent_t *
    291292tr_torrentInit( tr_handle_t   * h,
    292293                const char    * path,
    293294                const char    * destination,
    294                 uint8_t       * hash,
    295295                int             flags,
    296296                int           * error )
    297297{
    298     tr_torrent_t * tor  = tr_calloc( 1, sizeof *tor );
    299     if( NULL == tor )
    300     {
     298    int val;
     299    tr_torrent_t * tor = NULL;
     300
     301    if(( val = tr_torrentCanAdd( h, destination, path ) ))
     302        *error = val;
     303    else if(!(( tor = tr_new0( tr_torrent_t, 1 ))))
    301304        *error = TR_EOTHER;
    302         return NULL;
    303     }
    304 
    305     /* Parse torrent file */
    306     if( tr_metainfoParseFile( &tor->info, h->tag, path,
    307                               TR_FLAG_SAVE & flags ) )
    308     {
    309         *error = TR_EINVALID;
    310         free( tor );
    311         return NULL;
    312     }
    313 
    314     return torrentRealInit( h, tor, destination, hash, flags, error );
    315 }
    316 
    317 tr_torrent_t *
    318 tr_torrentInitData( tr_handle_t  * h,
    319                     uint8_t      * data,
    320                     size_t         size,
    321                     const char   * destination,
    322                     uint8_t      * hash,
    323                     int            flags,
    324                     int          * error )
    325 {
    326     tr_torrent_t * tor  = tr_calloc( 1, sizeof *tor );
    327     if( NULL == tor )
    328     {
    329         *error = TR_EOTHER;
    330         return NULL;
    331     }
    332 
    333     /* Parse torrent file */
    334     if( tr_metainfoParseData( &tor->info, h->tag, data, size,
    335                               TR_FLAG_SAVE & flags ) )
    336     {
    337         *error = TR_EINVALID;
    338         free( tor );
    339         return NULL;
    340     }
    341 
    342     return torrentRealInit( h, tor, destination, hash, flags, error );
     305    else {
     306        tr_metainfoParseFile( &tor->info, h->tag, path, TR_FLAG_SAVE & flags );
     307        torrentRealInit( h, tor, destination, flags );
     308    }
     309
     310    return tor;
     311}
     312
     313static int
     314tr_torrentCanAddHash( tr_handle_t * h,
     315                      const char  * destination,
     316                      const char  * hashStr )
     317{
     318    tr_info_t info;
     319
     320    if( tr_metainfoParseHash( &info, h->tag, hashStr ) )
     321        return TR_EINVALID;
     322
     323    return infoCanAdd( h, destination, &info );
    343324}
    344325
    … …  
    350331                     int          * error )
    351332{
    352     tr_torrent_t * tor  = calloc( 1, sizeof *tor );
    353     if( NULL == tor )
    354     {
     333    int val;
     334    tr_torrent_t * tor = NULL;
     335
     336    if(( val = tr_torrentCanAddHash( h, destination, hashStr ) ))
     337        *error = val;
     338    else if(!(( tor = tr_new0( tr_torrent_t, 1 ))))
    355339        *error = TR_EOTHER;
    356         return NULL;
    357     }
    358 
    359     /* Parse torrent file */
    360     if( tr_metainfoParseHash( &tor->info, h->tag, hashStr ) )
    361     {
    362         *error = TR_EINVALID;
    363         free( tor );
    364         return NULL;
    365     }
    366 
    367     return torrentRealInit( h, tor, destination, NULL, (TR_FLAG_SAVE|flags), error );
     340    else {
     341        tr_metainfoParseHash( &tor->info, h->tag, hashStr );
     342        torrentRealInit( h, tor, destination, (TR_FLAG_SAVE|flags) );
     343    }
     344
     345    return tor;
     346}
     347
     348static int
     349tr_torrentCanAddData( tr_handle_t  * h,
     350                      const char   * destination,
     351                      uint8_t      * data,
     352                      size_t         size )
     353{
     354    tr_info_t info;
     355
     356    if( tr_metainfoParseData( &info, h->tag, data, size, FALSE ) )
     357        return TR_EINVALID;
     358
     359    return infoCanAdd( h, destination, &info );
     360}
     361
     362tr_torrent_t *
     363tr_torrentInitData( tr_handle_t  * h,
     364                    uint8_t      * data,
     365                    size_t         size,
     366                    const char   * destination,
     367                    int            flags,
     368                    int          * error )
     369{
     370    int val;
     371    tr_torrent_t * tor = NULL;
     372
     373    if(( val = tr_torrentCanAddData( h, destination, data, size ) ))
     374        *error = val;
     375    else if(!(( tor = tr_new0( tr_torrent_t, 1 ))))
     376        *error = TR_EOTHER;
     377    else {
     378        tr_metainfoParseData( &tor->info, h->tag, data, size, TR_FLAG_SAVE & flags );
     379        torrentRealInit( h, tor, destination, flags );
     380    }
     381
     382    return tor;
    368383}
    369384
    … …  
    452467    uint8_t * peerCompact;
    453468
    454     if( !( tor->status & TR_STATUS_ACTIVE ) )
     469    if( tor->status != TR_RUN_RUNNING )
    455470        return;
    456471   
    … …  
    486501    tc = tor->tracker;
    487502    s->cannotConnect = tr_trackerCannotConnect( tc );
    488     s->tracker = ( tc ? tr_trackerGet( tc ) : &tor->info.trackerList[0].list[0] );
     503    s->tracker = tc
     504        ? tr_trackerGet( tc )
     505        : &tor->info.trackerList[0].list[0];
    489506
    490507    /* peers... */
    … …  
    568585
    569586    *peerCount = tor->peerCount;
    570     
    571     peers = (tr_peer_stat_t *) calloc( tor->peerCount, sizeof( tr_peer_stat_t ) );
     587   
     588    peers = tr_new0( tr_peer_stat_t, tor->peerCount );
    572589    if (peers != NULL)
    573590    {
    … …  
    700717
    701718float*
    702 tr_torrentCompletion( tr_torrent_t * tor )
     719tr_torrentCompletion( const tr_torrent_t * tor )
    703720{
    704721    int i;
    … …  
    706723    tr_torrentReaderLock( tor );
    707724
    708     f = calloc ( tor->info.fileCount, sizeof( float ) );
     725    f = tr_new0( float, tor->info.fileCount );
    709726    for( i=0; i<tor->info.fileCount; ++i )
    710727       f[i] = tr_torrentFileCompletion ( tor, i );
    … …  
    891908    /* create the check-files mutex */
    892909    if( !checkFilesLockInited ) {
    893         tr_lockInit( &checkFilesLock );
    894         checkFilesLockInited = TRUE;
     910         checkFilesLockInited = TRUE;
     911         tr_lockInit( &checkFilesLock );
    895912    }
    896913
    … …  
    971988            /* starting to run... */
    972989            if( tor->io == NULL ) {
     990                *tor->errorString = '\0';
    973991                tr_torrentResetTransferStats( tor );
    974992                tor->io = tr_ioInitFast( tor );
    … …  
    9861004            if( cpStatus != tor->cpStatus ) {
    9871005                tor->hasChangedState = tor->cpStatus = cpStatus;
    988                 if( (cpStatus == TR_CP_COMPLETE) && tor->tracker!=NULL )
    989                     tr_trackerCompleted( tor->tracker );
     1006                if( (cpStatus == TR_CP_COMPLETE)        /* if we're complete */
     1007                    && tor->tracker!=NULL           /* and we have a tracker */
     1008                    && tor->downloadedCur )          /* and it just happened */
     1009                    tr_trackerCompleted( tor->tracker ); /* tell the tracker */
    9901010                tr_ioSync( tor->io );
    9911011            }
    … …  
    11031123
    11041124    tr_torrentReaderLock( tor );
    1105     p = tr_malloc( tor->info.fileCount * sizeof(tr_priority_t) );
     1125    p = tr_new0( tr_priority_t, tor->info.fileCount );
    11061126    for( i=0; i<tor->info.fileCount; ++i )
    11071127        p[i] = tor->info.files[i].priority;

  • trunk/libtransmission/transmission.h

    r2202 r2206  
    267267                               const char * path,
    268268                               const char * destination,
    269                                uint8_t * hash, int flags, int * error );
     269                               int flags, int * error );
     270
     271/**
     272 * Checks to see if the specified torrent file could be
     273 * successfully added to Transmission.
     274 * returns TR_OK, TR_EDUPLICATE, TR_ERROR_IO_DUP_DOWNLOAD, or TR_EINVALID.
     275 */
     276int tr_torrentCanAdd( const tr_handle_t  * handle,
     277                      const char         * destination,
     278                      const char         * path );
    270279
    271280/***********************************************************************
    … …  
    278287                                   uint8_t * data, size_t size,
    279288                                   const char * destination,
    280                                    uint8_t * hash, int flags, int * error );
     289                                   int flags, int * error );
    281290
    282291/***********************************************************************
    … …  
    401410 * array when done.
    402411 **********************************************************************/
    403 float * tr_torrentCompletion( tr_torrent_t * );
     412float * tr_torrentCompletion( const tr_torrent_t * );
    404413
    405414float tr_torrentFileCompletion( const tr_torrent_t *, int fileIndex );
    … …  
    506515                                        there's nothing we want right now */
    507516    TR_STATUS_SEED         = (1<<4), /* Seeding */
    508     TR_STATUS_STOPPING     = (1<<5), /* Sending 'stopped' to the tracker */
    509     TR_STATUS_STOPPED      = (1<<6)  /* Sent 'stopped' but thread still
    510                                         running (for internal use only) */
     517    TR_STATUS_STOPPING     = (1<<5), /* Stopping -- closing connections, etc. */
     518    TR_STATUS_STOPPED      = (1<<6)  /* Torrent is stopped */
    511519}
    512520torrent_status_t;

  • trunk/libtransmission/utils.c

    r2154 r2206  
    412412}
    413413
     414void*
     415tr_malloc0( size_t size )
     416{
     417    void * ret = tr_malloc( size );
     418    memset( ret, 0, size );
     419    return ret;
     420}
     421
    414422void tr_free( void * p )
    415423{

  • trunk/libtransmission/utils.h

    r2154 r2206  
    177177***/
    178178
     179#define tr_new(struct_type, n_structs)           \
     180    ((struct_type *) tr_malloc (((size_t) sizeof (struct_type)) * ((size_t) (n_structs))))
     181#define tr_new0(struct_type, n_structs)          \
     182    ((struct_type *) tr_malloc0 (((size_t) sizeof (struct_type)) * ((size_t) (n_structs))))
     183
     184void* tr_malloc  ( size_t );
     185void* tr_malloc0 ( size_t );
     186void* tr_calloc  ( size_t nmemb, size_t size );
     187void  tr_free    ( void* );
     188
    179189char* tr_strdup( const char * str );
    180190char* tr_strndup( const char * str, int len );
    181 void* tr_malloc( size_t );
    182 void* tr_calloc( size_t nmemb, size_t size );
    183 void  tr_free( void* );
    184191
    185192/***
Note: See TracChangeset for help on using the changeset viewer.