Changeset 2154


Ignore:
Timestamp:
Jun 18, 2007, 7:39:52 PM (15 years ago)
Author:
charles
Message:
  • fix error checking large files reported by Gimp_
  • portability changes to pathname/filename building
  • small gratuitous changes
Location:
trunk
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • trunk/README

    r620 r2154  
    66back-end.
    77
    8 Transmission is open source (MIT license) and runs on Mac OS X (Cocoa
    9 interface), Linux/NetBSD/FreeBSD/OpenBSD (GTK+ interface) and BeOS
    10 (native interface).
     8Transmission runs on Mac OS X (Cocoa interface),
     9Linux/NetBSD/FreeBSD/OpenBSD (GTK+ interface)
     10and BeOS (native interface).
    1111
    1212For more information (including build instructions), please consult the
  • trunk/gtk/tr_prefs.c

    r2149 r2154  
    6060{
    6161    PROP_PARENT = 1,
    62     PROP_CORE,
     62    PROP_CORE
    6363};
    6464
  • trunk/libtransmission/fastresume.c

    r2149 r2154  
    7171
    7272static void
    73 fastResumeFileName( char * path, size_t size, const tr_torrent_t * tor, int tag )
    74 {
    75     if( tag )
    76     {
    77         snprintf( path, size, "%s/resume.%s-%s", tr_getCacheDirectory(),
    78                   tor->info.hashString, tor->handle->tag );
     73fastResumeFileName( char * buf, size_t buflen, const tr_torrent_t * tor, int tag )
     74{
     75    const char * cacheDir = tr_getCacheDirectory ();
     76    const char * hash = tor->info.hashString;
     77
     78    if( !tag )
     79    {
     80        tr_buildPath( buf, buflen, cacheDir, hash, NULL );
    7981    }
    8082    else
    8183    {
    82         snprintf( path, size, "%s/resume.%s", tr_getCacheDirectory(),
    83                   tor->info.hashString );
     84        char base[1024];
     85        snprintf( base, sizeof(base), "%s-%s", hash, tor->handle->tag );
     86        tr_buildPath( buf, buflen, cacheDir, base, NULL );
    8487    }
    8588}
     
    9598        char fname[MAX_PATH_LENGTH];
    9699        struct stat sb;
    97         snprintf( fname, sizeof(fname), "%s/%s",
    98                   tor->destination, tor->info.files[i].name );
     100        tr_buildPath( fname, sizeof(fname),
     101                      tor->destination, tor->info.files[i].name, NULL );
    99102        if ( !stat( fname, &sb ) && S_ISREG( sb.st_mode ) ) {
    100103#ifdef SYS_DARWIN
  • trunk/libtransmission/fdlimit.c

    r2004 r2154  
    426426    }
    427427
    428     snprintf( path, sizeof(path), "%s/%s", folder, name );
     428    snprintf( path, sizeof(path), "%s" TR_PATH_DELIMITER_STR "%s",
     429              folder,
     430              name );
    429431
    430432    /* Create subfolders, if any */
  • trunk/libtransmission/http.c

    r2040 r2154  
    136136    if( 0 <= ret && NULL != method )
    137137    {
    138         *method = tr_dupstr( words[0], words[1] - words[0] );
     138        *method = tr_strndup( words[0], words[1] - words[0] );
    139139        if( NULL == *method )
    140140        {
     
    145145    if( 0 <= ret && NULL != uri )
    146146    {
    147         *uri = tr_dupstr( words[2], words[3] - words[2] );
     147        *uri = tr_strndup( words[2], words[3] - words[2] );
    148148        if( NULL == *uri )
    149149        {
     
    372372    if( NULL != host )
    373373    {
    374         *host = tr_dupstr( url, hostend - url );
     374        *host = tr_strndup( url, hostend - url );
    375375    }
    376376    if( NULL != port )
     
    382382        if( 0 < len - ( pathstart - url ) )
    383383        {
    384             *path = tr_dupstr( pathstart, len - ( pathstart - url ) );
     384            *path = tr_strndup( pathstart, len - ( pathstart - url ) );
    385385        }
    386386        else
     
    844844            http->lengthtype = HTTP_LENGTH_FIXED;
    845845            http->chunkoff = body - http->header.buf;
    846             duped = tr_dupstr( hdr[0].data, hdr[0].len );
     846            duped = tr_strndup( hdr[0].data, hdr[0].len );
    847847            http->chunklen = strtol( duped, NULL, 10 );
    848848            free( duped );
  • trunk/libtransmission/inout.c

    r2149 r2154  
    3131                   int                   ioMode,
    3232                   int                   fileIndex,
    33                    size_t                fileOffset,
     33                   uint64_t              fileOffset,
    3434                   void                * buf,
    3535                   size_t                buflen )
     
    4949    else if ((fd = tr_fdFileOpen ( tor->destination, file->name, TRUE )) < 0)
    5050        ret = fd;
    51     else if( lseek( fd, fileOffset, SEEK_SET ) == ((off_t)-1) )
     51    else if( lseek( fd, (off_t)fileOffset, SEEK_SET ) == ((off_t)-1) )
    5252        ret = TR_ERROR_IO_OTHER;
    5353    else if( func( fd, buf, buflen ) != buflen )
     
    6464static void
    6565findFileLocation ( const tr_torrent_t * tor,
    66                    int pieceIndex, size_t pieceOffset,
    67                    int * fileIndex, size_t * fileOffset )
     66                   int                  pieceIndex,
     67                   int                  pieceOffset,
     68                   int                * fileIndex,
     69                   uint64_t           * fileOffset )
    6870{
    6971    const tr_info_t * info = &tor->info;
     
    7375
    7476    assert ( 0<=pieceIndex && pieceIndex < info->pieceCount );
    75     assert ( pieceOffset < (size_t)tr_pieceSize(pieceIndex) );
     77    assert ( 0<=tor->info.pieceSize );
     78    assert ( pieceOffset < tr_pieceSize(pieceIndex) );
    7679    assert ( piecePos < info->totalSize );
    7780
     
    8992ensureMinimumFileSize ( const tr_torrent_t  * tor,
    9093                        int                   fileIndex,
    91                         size_t                minSize ) /* in bytes */
     94                        uint64_t              minSize ) /* in bytes */
    9295{
    9396    int fd;
     
    121124                   int                  ioMode,
    122125                   int                  pieceIndex,
    123                    size_t               pieceOffset,
     126                   int                  pieceOffset,
    124127                   uint8_t            * buf,
    125128                   size_t               buflen )
     
    127130    int ret = 0;
    128131    int fileIndex;
    129     size_t fileOffset;
     132    uint64_t fileOffset;
    130133    const tr_info_t * info = &tor->info;
    131134
     
    142145    {
    143146        const tr_file_t * file = &info->files[fileIndex];
    144         const size_t bytesThisPass = MIN( buflen, file->length - fileOffset );
     147        const uint64_t bytesThisPass = MIN( buflen, file->length - fileOffset );
    145148
    146149        if( ioMode == TR_IO_WRITE )
  • trunk/libtransmission/makemeta.c

    r2149 r2154  
    4646    sb.st_size = 0;
    4747
    48     snprintf( buf, sizeof(buf), "%s"TR_PATH_DELIMITER_STR"%s", dir, base );
     48    tr_buildPath( buf, sizeof(buf), dir, base, NULL );
    4949    i = stat( buf, &sb );
    5050    if( i ) {
  • trunk/libtransmission/metainfo.c

    r2149 r2154  
    349349    for( ii = 0; jj > ii; ii++ )
    350350    {
    351         strcatUTF8( buf, size, "/", 0 );
     351        strcatUTF8( buf, size, TR_PATH_DELIMITER_STR, 0 );
    352352        strcatUTF8( buf, size, list[ii], 1 );
    353353    }
     
    524524}
    525525
    526 void savedname( char * name, size_t len, const char * hash, const char * tag )
    527 {
    528     if( NULL == tag )
    529     {
    530         snprintf( name, len, "%s/%s", tr_getTorrentsDirectory(), hash );
     526void
     527savedname( char * name, size_t len, const char * hash, const char * tag )
     528{
     529    const char * torDir = tr_getTorrentsDirectory ();
     530
     531    if( tag == NULL )
     532    {
     533        tr_buildPath( name, len, torDir, hash, NULL );
    531534    }
    532535    else
    533536    {
    534         snprintf( name, len, "%s/%s-%s",
    535                   tr_getTorrentsDirectory(), hash, tag );
     537        char base[1024];
     538        snprintf( base, sizeof(base), "%s-%s", hash, tag );
     539        tr_buildPath( name, len, torDir, base, NULL );
    536540    }
    537541}
  • trunk/libtransmission/platform.c

    r2034 r2154  
    8282tr_migrateResume( const char *oldDirectory, const char *newDirectory )
    8383{
    84     DIR * dirh;
    85     struct dirent * dirp;
    86     char oldFile[MAX_PATH_LENGTH];
    87     char newFile[MAX_PATH_LENGTH];
    88 
    89     if( ( dirh = opendir( oldDirectory ) ) )
    90     {
     84    DIR * dirh = opendir( oldDirectory );
     85
     86    if( dirh != NULL )
     87    {
     88        struct dirent * dirp;
     89
    9190        while( ( dirp = readdir( dirh ) ) )
    9291        {
    93             if( strncmp( "resume.", dirp->d_name, 7 ) )
    94             {
    95                 continue;
    96             }
    97             snprintf( oldFile, MAX_PATH_LENGTH, "%s/%s",
    98                       oldDirectory, dirp->d_name );
    99             snprintf( newFile, MAX_PATH_LENGTH, "%s/%s",
    100                       newDirectory, dirp->d_name );
    101             rename( oldFile, newFile );
     92            if( !strncmp( "resume.", dirp->d_name, 7 ) )
     93            {
     94                char o[MAX_PATH_LENGTH];
     95                char n[MAX_PATH_LENGTH];
     96                tr_buildPath( o, sizeof(o), oldDirectory, dirp->d_name, NULL );
     97                tr_buildPath( n, sizeof(n), newDirectory, dirp->d_name, NULL );
     98                rename( o, n );
     99            }
    102100        }
    103101
     
    106104}
    107105
    108 char * tr_getPrefsDirectory()
    109 {
    110     static char prefsDirectory[MAX_PATH_LENGTH];
     106const char *
     107tr_getPrefsDirectory( void )
     108{
     109    static char   buf[MAX_PATH_LENGTH];
     110    static int    init = 0;
     111    static size_t buflen = sizeof(buf);
     112    const char* h;
     113
     114    if( init )
     115        return buf;
     116
     117    h = tr_getHomeDirectory();
     118#ifdef SYS_BEOS
     119    find_directory( B_USER_SETTINGS_DIRECTORY,
     120                    dev_for_path("/boot"), true, buf, buflen );
     121    strcat( buf, "/Transmission" );
     122#elif defined( SYS_DARWIN )
     123    tr_buildPath ( buf, buflen, h,
     124                  "Library", "Application Support", "Transmission", NULL );
     125#elif defined(__AMIGAOS4__)
     126    snprintf( buf, buflen, "PROGDIR:.transmission" );
     127#else
     128    tr_buildPath ( buf, buflen, h, ".transmission", NULL );
     129#endif
     130
     131    tr_mkdir( buf );
     132    init = 1;
     133
     134#ifdef SYS_DARWIN
     135    char old[MAX_PATH_LENGTH];
     136    tr_buildPath ( old, sizeof(old), h, ".transmission", NULL );
     137    tr_migrateResume( old, buf );
     138    rmdir( oldDirectory );
     139#endif
     140
     141    return buf;
     142}
     143
     144const char *
     145tr_getCacheDirectory( void )
     146{
     147    static char buf[MAX_PATH_LENGTH];
    111148    static int  init = 0;
     149    static const size_t buflen = sizeof(buf);
     150    const char * p;
    112151
    113152    if( init )
    114     {
    115         return prefsDirectory;
    116     }
    117 
    118 #ifdef SYS_BEOS
    119         find_directory( B_USER_SETTINGS_DIRECTORY, dev_for_path("/boot"),
    120                         true, prefsDirectory, MAX_PATH_LENGTH );
    121         strcat( prefsDirectory, "/Transmission" );
     153        return buf;
     154
     155    p = tr_getPrefsDirectory();
     156#ifdef SYS_BEOS
     157    tr_buildPath( buf, buflen, p, "Cache", NULL );
    122158#elif defined( SYS_DARWIN )
    123     snprintf( prefsDirectory, MAX_PATH_LENGTH,
    124               "%s/Library/Application Support/Transmission",
    125               tr_getHomeDirectory() );
    126 #elif defined(__AMIGAOS4__)
    127     snprintf( prefsDirectory, MAX_PATH_LENGTH, "PROGDIR:.transmission" );
    128 #else
    129     snprintf( prefsDirectory, MAX_PATH_LENGTH, "%s/.transmission",
    130               tr_getHomeDirectory() );
    131 #endif
    132 
    133     tr_mkdir( prefsDirectory );
     159    tr_buildPath( buf, buflen, tr_getHomeDirectory(),
     160                  "Library", "Caches", "Transmission", NULL );
     161#else
     162    tr_buildPath( buf, buflen, p, "cache", NULL );
     163#endif
     164
     165    tr_mkdir( buf );
    134166    init = 1;
    135167
    136 #ifdef SYS_DARWIN
    137     char oldDirectory[MAX_PATH_LENGTH];
    138     snprintf( oldDirectory, MAX_PATH_LENGTH, "%s/.transmission",
    139               tr_getHomeDirectory() );
    140     tr_migrateResume( oldDirectory, prefsDirectory );
    141     rmdir( oldDirectory );
    142 #endif
    143 
    144     return prefsDirectory;
    145 }
    146 
    147 char * tr_getCacheDirectory()
    148 {
    149     static char cacheDirectory[MAX_PATH_LENGTH];
     168    if( strcmp( p, buf ) )
     169        tr_migrateResume( p, buf );
     170
     171    return buf;
     172}
     173
     174const char *
     175tr_getTorrentsDirectory( void )
     176{
     177    static char buf[MAX_PATH_LENGTH];
    150178    static int  init = 0;
     179    static const size_t buflen = sizeof(buf);
     180    const char * p;
    151181
    152182    if( init )
    153     {
    154         return cacheDirectory;
    155     }
    156 
    157 #ifdef SYS_BEOS
    158     /* XXX hey Bryan, is this fine with you? */
    159     snprintf( cacheDirectory, MAX_PATH_LENGTH, "%s/Cache",
    160               tr_getPrefsDirectory() );
     183        return buf;
     184
     185    p = tr_getPrefsDirectory ();
     186
     187#ifdef SYS_BEOS
     188    tr_buildPath( buf, buflen, p, "Torrents", NULL );
    161189#elif defined( SYS_DARWIN )
    162     snprintf( cacheDirectory, MAX_PATH_LENGTH, "%s/Library/Caches/Transmission",
    163               tr_getHomeDirectory() );
    164 #else
    165     snprintf( cacheDirectory, MAX_PATH_LENGTH, "%s/cache",
    166               tr_getPrefsDirectory() );
    167 #endif
    168 
    169     tr_mkdir( cacheDirectory );
     190    tr_buildPath( buf, buflen, p, "Torrents", NULL );
     191#else
     192    tr_buildPath( buf, buflen, p, "torrents", NULL );
     193#endif
     194
     195    tr_mkdir( buf );
    170196    init = 1;
    171 
    172     if( strcmp( tr_getPrefsDirectory(), cacheDirectory ) )
    173     {
    174         tr_migrateResume( tr_getPrefsDirectory(), cacheDirectory );
    175     }
    176 
    177     return cacheDirectory;
    178 }
    179 
    180 char * tr_getTorrentsDirectory()
    181 {
    182     static char torrentsDirectory[MAX_PATH_LENGTH];
    183     static int  init = 0;
    184 
    185     if( init )
    186     {
    187         return torrentsDirectory;
    188     }
    189 
    190 #ifdef SYS_BEOS
    191     /* XXX hey Bryan, is this fine with you? */
    192     snprintf( torrentsDirectory, MAX_PATH_LENGTH, "%s/Torrents",
    193               tr_getPrefsDirectory() );
    194 #elif defined( SYS_DARWIN )
    195     snprintf( torrentsDirectory, MAX_PATH_LENGTH, "%s/Torrents",
    196               tr_getPrefsDirectory() );
    197 #else
    198     snprintf( torrentsDirectory, MAX_PATH_LENGTH, "%s/torrents",
    199               tr_getPrefsDirectory() );
    200 #endif
    201 
    202     tr_mkdir( torrentsDirectory );
    203     init = 1;
    204 
    205     return torrentsDirectory;
     197    return buf;
    206198}
    207199
  • trunk/libtransmission/platform.h

    r2034 r2154  
    4848const char * tr_getHomeDirectory( void );
    4949
    50 char * tr_getCacheDirectory();
    51 char * tr_getTorrentsDirectory();
     50const char * tr_getCacheDirectory( void );
     51const char * tr_getTorrentsDirectory( void );
    5252
    5353/**
  • trunk/libtransmission/transmission.h

    r2152 r2154  
    5353#endif
    5454
     55#if defined(__MINGW__)
     56#define TR_PATH_DELIMITER '\\'
     57#define TR_PATH_DELIMITER_STR "\\"
     58#else
    5559#define TR_PATH_DELIMITER '/'
    5660#define TR_PATH_DELIMITER_STR "/"
     61#endif
    5762
    5863#define TR_DEFAULT_PORT   9090
     
    134139 * preferences. The string belongs to libtransmission, do not free it.
    135140 **********************************************************************/
    136 char * tr_getPrefsDirectory();
     141const char * tr_getPrefsDirectory( void );
    137142
    138143/***********************************************************************
  • trunk/libtransmission/upnp.c

    r2040 r2154  
    589589        return;
    590590    }
    591     ii->id = tr_dupstr( id, idLen );
     591    ii->id = tr_strndup( id, idLen );
    592592    ii->state = UPNPDEV_STATE_ROOT;
    593593    actionSetup( &ii->getcmd, "GetSpecificPortMappingEntry", 8 );
     
    10901090        basedup = strrchr( root, '/' );
    10911091        assert( NULL != basedup );
    1092         basedup = tr_dupstr( root, basedup - root + 1 );
     1092        basedup = tr_strndup( root, basedup - root + 1 );
    10931093    }
    10941094    else
  • trunk/libtransmission/utils.c

    r2149 r2154  
    312312}
    313313
    314 char *
    315 tr_dupstr( const char * base, int len )
    316 {
    317     char * ret;
    318 
    319     ret = malloc( len + 1 );
    320     if( NULL != ret )
    321     {
    322         memcpy( ret, base, len );
    323         ret[len] = '\0';
    324     }
    325 
    326     return ret;
     314void
     315tr_buildPath ( char *buf, size_t buflen, const char *first_element, ... )
     316{
     317    va_list vl;
     318    char* walk = buf;
     319    const char * element = first_element;
     320    va_start( vl, first_element );
     321    for( ;; ) {
     322        const size_t n = strlen( element );
     323        memcpy( walk, element, n );
     324        walk += n;
     325        element = (const char*) va_arg( vl, const char* );
     326        if( element == NULL )
     327            break;
     328        *walk++ = TR_PATH_DELIMITER;
     329    }
     330    *walk = '\0';
     331    assert( walk-buf <= (int)buflen );
    327332}
    328333
     
    377382****/
    378383
    379 char* tr_strdup( const char * in )
     384char*
     385tr_strdup( const char * in )
     386{
     387    return tr_strndup( in, in ? strlen(in) : 0 );
     388}
     389
     390char*
     391tr_strndup( const char * in, int len )
    380392{
    381393    char * out = NULL;
    382394    if( in != NULL )
    383395    {
    384         const size_t len = strlen( in );
    385         out = malloc( len + 1 );
     396        out = tr_calloc( len+1, 1 );
    386397        memcpy( out, in, len );
    387         out[len] = '\0';
    388398    }
    389399    return out;
     400}
     401
     402void*
     403tr_calloc( size_t nmemb, size_t size )
     404{
     405    return nmemb && size ? calloc( nmemb, size ) : NULL;
    390406}
    391407
  • trunk/libtransmission/utils.h

    r2149 r2154  
    6767               const char * data, int len );
    6868
    69 /***********************************************************************
    70  * tr_dupstr
    71  ***********************************************************************
    72  * Creates a nul-terminated string
    73  **********************************************************************/
    74 char * tr_dupstr( const char * base, int len );
     69/* creates a filename from a series of elements using the
     70   correct separator for filenames. */
     71void tr_buildPath ( char* buf, size_t buflen,
     72                    const char * first_element, ... );
     73
    7574
    7675int    tr_ioErrorFromErrno( void );
     
    178177***/
    179178
    180 char* tr_strdup( const char * pch );
    181 
     179char* tr_strdup( const char * str );
     180char* tr_strndup( const char * str, int len );
    182181void* tr_malloc( size_t );
    183 
     182void* tr_calloc( size_t nmemb, size_t size );
    184183void  tr_free( void* );
    185184
  • trunk/libtransmission/xml.c

    r1805 r2154  
    230230    if( NULL == str )
    231231    {
    232         return tr_dupstr( begin, end - begin );
     232        return tr_strndup( begin, end - begin );
    233233    }
    234234
Note: See TracChangeset for help on using the changeset viewer.