Changeset 6842


Ignore:
Timestamp:
Oct 3, 2008, 4:49:06 AM (12 years ago)
Author:
charles
Message:

(libT) finish killing tr_errno.

Location:
trunk/libtransmission
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/bencode-test.c

    r6795 r6842  
    11#include <ctype.h>
     2#include <errno.h>
    23#include <stdio.h>
    34#include <string.h>
     
    4445    val = 888;
    4546    err = tr_bencParseInt( buf, buf + 3, &end, &val );
    46     check( err == TR_ERROR );
     47    check( err == EILSEQ );
    4748    check( val == 888 );
    4849    check( end == NULL );
     
    5051    /* empty buffer */
    5152    err = tr_bencParseInt( buf, buf + 0, &end, &val );
    52     check( err == TR_ERROR );
     53    check( err == EILSEQ );
    5354    check( val == 888 );
    5455    check( end == NULL );
     
    5758    tr_snprintf( (char*)buf, sizeof( buf ), "i6z4e" );
    5859    err = tr_bencParseInt( buf, buf + 5, &end, &val );
    59     check( err == TR_ERROR );
     60    check( err == EILSEQ );
    6061    check( val == 888 );
    6162    check( end == NULL );
     
    6465    tr_snprintf( (char*)buf, sizeof( buf ), "i-3e" );
    6566    err = tr_bencParseInt( buf, buf + 4, &end, &val );
    66     check( err == TR_OK );
     67    check( err == 0 );
    6768    check( val == -3 );
    6869    check( end == buf + 4 );
     
    7172    tr_snprintf( (char*)buf, sizeof( buf ), "i0e" );
    7273    err = tr_bencParseInt( buf, buf + 4, &end, &val );
    73     check( err == TR_OK );
     74    check( err == 0 );
    7475    check( val == 0 );
    7576    check( end == buf + 3 );
     
    8081    tr_snprintf( (char*)buf, sizeof( buf ), "i04e" );
    8182    err = tr_bencParseInt( buf, buf + 4, &end, &val );
    82     check( err == TR_ERROR );
     83    check( err == EILSEQ );
    8384    check( val == 0 );
    8485    check( end == NULL );
     
    99100    tr_snprintf( (char*)buf, sizeof( buf ), "4:boat" );
    100101    err = tr_bencParseStr( buf, buf + 6, &end, &str, &len );
    101     check( err == TR_OK );
     102    check( err == 0 );
    102103    check( !strncmp( (char*)str, "boat", len ) );
    103104    check( len == 4 );
     
    109110    /* string goes past end of buffer */
    110111    err = tr_bencParseStr( buf, buf + 5, &end, &str, &len );
    111     check( err == TR_ERROR );
     112    check( err == EILSEQ );
    112113    check( str == NULL );
    113114    check( end == NULL );
     
    117118    tr_snprintf( (char*)buf, sizeof( buf ), "0:" );
    118119    err = tr_bencParseStr( buf, buf + 2, &end, &str, &len );
    119     check( err == TR_OK );
     120    check( err == 0 );
    120121    check( !*str );
    121122    check( !len );
     
    128129    tr_snprintf( (char*)buf, sizeof( buf ), "3:boat" );
    129130    err = tr_bencParseStr( buf, buf + 6, &end, &str, &len );
    130     check( err == TR_OK );
     131    check( err == 0 );
    131132    check( !strncmp( (char*)str, "boa", len ) );
    132133    check( len == 3 );
  • trunk/libtransmission/bencode.c

    r6795 r6842  
    8181                 int64_t *        setme_val )
    8282{
    83     int          err = TR_OK;
     83    int          err = 0;
    8484    char *       endptr;
    8585    const void * begin;
     
    8888
    8989    if( buf >= bufend )
    90         return TR_ERROR;
     90        return EILSEQ;
    9191    if( *buf != 'i' )
    92         return TR_ERROR;
     92        return EILSEQ;
    9393
    9494    begin = buf + 1;
    9595    end = memchr( begin, 'e', ( bufend - buf ) - 1 );
    9696    if( end == NULL )
    97         return TR_ERROR;
     97        return EILSEQ;
    9898
    9999    errno = 0;
    100100    val = strtoll( begin, &endptr, 10 );
    101101    if( errno || ( endptr != end ) ) /* incomplete parse */
    102         err = TR_ERROR;
     102        err = EILSEQ;
    103103    else if( val && *(const char*)begin == '0' ) /* no leading zeroes! */
    104         err = TR_ERROR;
     104        err = EILSEQ;
    105105    else
    106106    {
     
    130130
    131131    if( buf >= bufend )
    132         return TR_ERROR;
     132        return EILSEQ;
    133133
    134134    if( !isdigit( *buf  ) )
    135         return TR_ERROR;
     135        return EILSEQ;
    136136
    137137    end = memchr( buf, ':', bufend - buf );
    138138    if( end == NULL )
    139         return TR_ERROR;
     139        return EILSEQ;
    140140
    141141    errno = 0;
    142142    len = strtoul( (const char*)buf, &endptr, 10 );
    143143    if( errno || endptr != end )
    144         return TR_ERROR;
     144        return EILSEQ;
    145145
    146146    if( (const uint8_t*)end + 1 + len > bufend )
    147         return TR_ERROR;
     147        return EILSEQ;
    148148
    149149    *setme_end = end + 1 + len;
    150150    *setme_str = end + 1;
    151151    *setme_strlen = len;
    152     return TR_OK;
     152    return 0;
    153153}
    154154
     
    240240            node = getNode( top, parentStack, TYPE_INT );
    241241            if( !node )
    242                 return TR_ERROR;
     242                return EILSEQ;
    243243
    244244            tr_bencInitInt( node, val );
     
    252252            tr_benc * node = getNode( top, parentStack, TYPE_LIST );
    253253            if( !node )
    254                 return TR_ERROR;
     254                return EILSEQ;
    255255            tr_bencInit( node, TYPE_LIST );
    256256            tr_ptrArrayAppend( parentStack, node );
     
    261261            tr_benc * node = getNode( top, parentStack, TYPE_DICT );
    262262            if( !node )
    263                 return TR_ERROR;
     263                return EILSEQ;
    264264            tr_bencInit( node, TYPE_DICT );
    265265            tr_ptrArrayAppend( parentStack, node );
     
    271271            ++buf;
    272272            if( tr_ptrArrayEmpty( parentStack ) )
    273                 return TR_ERROR;
     273                return EILSEQ;
    274274
    275275            node = tr_ptrArrayBack( parentStack );
     
    278278                /* odd # of children in dict */
    279279                tr_bencFree( &node->val.l.vals[--node->val.l.count] );
    280                 return TR_ERROR;
     280                return EILSEQ;
    281281            }
    282282
     
    298298            node = getNode( top, parentStack, TYPE_STR );
    299299            if( !node )
    300                 return TR_ERROR;
     300                return EILSEQ;
    301301
    302302            tr_bencInitStr( node, str, str_len );
     
    14151415          size_t       len )
    14161416{
    1417     int    err = TR_OK;
     1417    int    err = 0;
    14181418    FILE * out = NULL;
    14191419
    14201420    out = fopen( filename, "wb+" );
     1421
    14211422    if( !out )
    14221423    {
     1424        err = errno;
    14231425        tr_err( _( "Couldn't open \"%1$s\": %2$s" ),
    1424                filename, tr_strerror( errno ) );
    1425         err = TR_EINVALID;
     1426                filename, tr_strerror( errno ) );
    14261427    }
    14271428    else if( fwrite( content, sizeof( char ), len, out ) != (size_t)len )
    14281429    {
     1430        err = errno;
    14291431        tr_err( _( "Couldn't save file \"%1$s\": %2$s" ),
    14301432               filename, tr_strerror( errno ) );
    1431         err = TR_EINVALID;
    14321433    }
    14331434
     
    14711472                 tr_benc *    b )
    14721473{
    1473     int       ret;
     1474    int       err;
    14741475    size_t    contentLen;
    1475     uint8_t * content = tr_loadFile( filename, &contentLen );
    1476 
    1477     ret = content ? tr_bencLoad( content, contentLen, b, NULL )
    1478           : TR_ERROR_IO_OTHER;
     1476    uint8_t * content;
     1477
     1478    content = tr_loadFile( filename, &contentLen );
     1479    if( !content )
     1480        err = errno;
     1481    else
     1482        err = tr_bencLoad( content, contentLen, b, NULL );
     1483
    14791484    tr_free( content );
    1480     return ret;
     1485    return err;
    14811486}
    14821487
     
    14851490                     tr_benc *    b )
    14861491{
    1487     int       ret;
    1488     size_t    contentLen;
    1489     uint8_t * content = tr_loadFile( filename, &contentLen );
    1490 
    1491     ret = content ? tr_jsonParse( content, contentLen, b, NULL )
    1492           : TR_ERROR_IO_OTHER;
     1492    int        err;
     1493    size_t     contentLen;
     1494    uint8_t  * content;
     1495
     1496    content = tr_loadFile( filename, &contentLen );
     1497    if( !content )
     1498        err = errno;
     1499    else
     1500        err = tr_jsonParse( content, contentLen, b, NULL );
     1501
    14931502    tr_free( content );
    1494     return ret;
    1495 }
    1496 
     1503    return err;
     1504}
     1505
  • trunk/libtransmission/fdlimit.c

    r6795 r6842  
    101101***/
    102102
    103 static tr_errno
     103/**
     104 * returns 0 on success, or an errno value on failure.
     105 * errno values include ENOENT if the parent folder doesn't exist,
     106 * plus the errno values set by tr_mkdirp() and open().
     107 */
     108static int
    104109TrOpenFile( int          i,
    105110            const char * folder,
     
    114119    /* confirm the parent folder exists */
    115120    if( stat( folder, &sb ) || !S_ISDIR( sb.st_mode ) )
    116         return TR_ERROR_IO_PARENT;
     121        return ENOENT;
    117122
    118123    /* create subfolders, if any */
     
    124129        tr_free( tmp );
    125130        if( err )
    126             return tr_ioErrorFromErrno( err );
     131            return err;
    127132    }
    128133
     
    141146        tr_err( _( "Couldn't open \"%1$s\": %2$s" ), filename,
    142147               tr_strerror( err ) );
    143         return tr_ioErrorFromErrno( err );
    144     }
    145 
    146     return TR_OK;
     148        return err;
     149    }
     150
     151    return 0;
    147152}
    148153
     
    173178}
    174179
     180/* returns an fd on success, or a -1 on failure and sets errno */
    175181int
    176182tr_fdFileCheckout( const char * folder,
     
    275281    if( !fileIsOpen( o ) )
    276282    {
    277         const tr_errno err = TrOpenFile( winner, folder, torrentFile, write );
    278         if( err )
    279         {
     283        const int err = TrOpenFile( winner, folder, torrentFile, write );
     284        if( err ) {
    280285            tr_lockUnlock( gFd->lock );
    281             return err;
     286            errno = err;
     287            return -1;
    282288        }
    283289
  • trunk/libtransmission/fdlimit.h

    r6795 r6842  
    4343 * and then check it back in via tr_fdFileReturn() when done.
    4444 *
    45  * - if `folder' doesn't exist, TR_ERROR_IO_PARENT is returned.
     45 * - if `folder' doesn't exist, errno is set to ENOENT.
    4646 * - if doWrite is true, subfolders in torrentFile are created if necessary.
    4747 * - if doWrite is true, the target file is created if necessary.
    4848 *
    4949 * on success, a file descriptor >= 0 is returned.
    50  * on failure, a negative number corresponding to tr_errno is returned.
     50 * on failure, a -1 is returned and errno is set.
    5151 *
    5252 * @see tr_fdFileReturn
    5353 * @see tr_fdFileClose
    54  * @see tr_errno
    5554 */
    5655int  tr_fdFileCheckout( const char * folder,
  • trunk/libtransmission/inout.c

    r6841 r6842  
    4141enum { TR_IO_READ, TR_IO_WRITE };
    4242
    43 static tr_errno
     43/* returns 0 on success, or an errno on failure */
     44static int
    4445readOrWriteBytes( const tr_torrent * tor,
    4546                  int                ioMode,
     
    6970
    7071    if( !file->length )
    71         return TR_OK;
     72        return 0;
    7273
    7374    if( ( ioMode == TR_IO_READ ) && !fileExists ) /* does file exist? */
    74         err = tr_ioErrorFromErrno( errno );
     75        err = errno;
    7576    else if( ( fd = tr_fdFileCheckout ( tor->downloadDir,
    7677                                        file->name,
    7778                                        ioMode == TR_IO_WRITE ) ) < 0 )
    78         err = fd;
     79        err = errno;
    7980    else if( lseek( fd, (off_t)fileOffset, SEEK_SET ) == ( (off_t)-1 ) )
    80         err = tr_ioErrorFromErrno( errno );
     81        err = errno;
    8182    else if( func( fd, buf, buflen ) != buflen )
    82         err = tr_ioErrorFromErrno( errno );
     83        err = errno;
    8384    else
    84         err = TR_OK;
    85 
    86     if( ( err == TR_OK ) && ( !fileExists ) && ( ioMode == TR_IO_WRITE ) )
     85        err = 0;
     86
     87    if( ( !err ) && ( !fileExists ) && ( ioMode == TR_IO_WRITE ) )
    8788        tr_statsFileCreated( tor->session );
    8889
     
    129130
    130131#ifdef WIN32
    131 static tr_errno
     132/* return 0 on success, or an errno on failure */
     133static int
    132134ensureMinimumFileSize( const tr_torrent * tor,
    133135                       tr_file_index_t    fileIndex,
     
    135137{
    136138    int             fd;
    137     tr_errno        err;
     139    int             err;
    138140    struct stat     sb;
    139141    const tr_file * file = &tor->info.files[fileIndex];
     
    144146    fd = tr_fdFileCheckout( tor->downloadDir, file->name, TRUE );
    145147    if( fd < 0 ) /* bad fd */
    146         err = fd;
     148        err = errno;
    147149    else if( fstat ( fd, &sb ) ) /* how big is the file? */
    148         err = tr_ioErrorFromErrno( errno );
     150        err = errno;
    149151    else if( sb.st_size >= (off_t)minBytes ) /* already big enough */
    150         err = TR_OK;
     152        err = 0;
    151153    else if( !ftruncate( fd, minBytes ) )  /* grow it */
    152         err = TR_OK;
     154        err = 0;
    153155    else /* couldn't grow it */
    154         err = tr_ioErrorFromErrno( errno );
     156        err = errno;
    155157
    156158    if( fd >= 0 )
     
    162164#endif
    163165
    164 static tr_errno
     166/* returns 0 on success, or an errno on failure */
     167static int
    165168readOrWritePiece( const tr_torrent * tor,
    166169                  int                ioMode,
     
    170173                  size_t             buflen )
    171174{
    172     tr_errno        err = 0;
     175    int             err = 0;
    173176    tr_file_index_t fileIndex;
    174177    uint64_t        fileOffset;
     
    176179
    177180    if( pieceIndex >= tor->info.pieceCount )
    178         return TR_ERROR_ASSERT;
     181        return EINVAL;
    179182    if( pieceOffset + buflen > tr_torPieceCountBytes( tor, pieceIndex ) )
    180         return TR_ERROR_ASSERT;
     183        return EINVAL;
    181184
    182185    tr_ioFindFileLocation( tor, pieceIndex, pieceOffset,
     
    206209}
    207210
    208 tr_errno
     211int
    209212tr_ioRead( const tr_torrent * tor,
    210213           tr_piece_index_t   pieceIndex,
     
    216219}
    217220
    218 tr_errno
     221int
    219222tr_ioWrite( const tr_torrent * tor,
    220223            tr_piece_index_t   pieceIndex,
  • trunk/libtransmission/inout.h

    r6838 r6842  
    3030/**
    3131 * Reads the block specified by the piece index, offset, and length.
    32  * @return 0 on success, TR_ERROR_ASSERT if the arguments are incorrect,
    33  * or TR_ERROR_IO_* otherwise.
     32 * @return 0 on success, or an errno value on failure.
    3433 */
    35 tr_errno tr_ioRead( const struct tr_torrent * tor,
    36                     tr_piece_index_t          pieceIndex,
    37                     uint32_t                  offset,
    38                     uint32_t                  len,
    39                     uint8_t *                 setme );
     34int tr_ioRead( const struct tr_torrent * tor,
     35               tr_piece_index_t          pieceIndex,
     36               uint32_t                  offset,
     37               uint32_t                  len,
     38               uint8_t *                 setme );
    4039
    4140/**
    4241 * Writes the block specified by the piece index, offset, and length.
    43  * @return 0 on success, TR_ERROR_ASSERT if the arguments are incorrect,
    44  * or TR_ERROR_IO_* otherwise.
     42 * @return 0 on success, or an errno value on failure.
    4543 */
    46 tr_errno tr_ioWrite( const struct tr_torrent * tor,
    47                      tr_piece_index_t          pieceIndex,
    48                      uint32_t                  offset,
    49                      uint32_t                  len,
    50                      const uint8_t *           writeme );
     44int tr_ioWrite( const struct tr_torrent * tor,
     45                tr_piece_index_t          pieceIndex,
     46                uint32_t                  offset,
     47                uint32_t                  len,
     48                const uint8_t *           writeme );
    5149
    5250/**
  • trunk/libtransmission/json.c

    r6795 r6842  
    1313#include <assert.h>
    1414#include <ctype.h>
     15#include <errno.h>
    1516#include <string.h>
    1617#include <stdio.h> /* printf */
     
    154155
    155156    if( buf != bufend )
    156         err = TR_ERROR;
     157        err = EILSEQ;
    157158
    158159    if( setme_end )
  • trunk/libtransmission/metainfo.c

    r6795 r6842  
    155155        /* fprintf( stderr, "[%s]\n", *setme ); */
    156156        evbuffer_free( buf );
    157         err = TR_OK;
     157        err = 0;
    158158    }
    159159
     
    455455        return TR_EINVALID;
    456456    }
    457     return TR_OK;
     457    return 0;
    458458}
    459459
  • trunk/libtransmission/peer-common.h

    r6795 r6842  
    5454    uint32_t         length; /* for GOT_BLOCK + GOT_DATA */
    5555    float            progress; /* for TR_PEER_PEER_PROGRESS */
    56     tr_errno         err; /* for TR_PEER_GOT_ERROR */
     56    int              err; /* errno for TR_PEER_GOT_ERROR */
    5757}
    5858tr_peer_event;
  • trunk/libtransmission/peer-mgr.c

    r6838 r6842  
    990990
    991991        case TR_PEER_ERROR:
    992             if( TR_ERROR_IS_IO( e->err ) )
     992            if( e->err == EINVAL )
     993            {
     994                addStrike( t, peer );
     995                peer->doPurge = 1;
     996            }
     997            else if( ( e->err == EPROTO )
     998                  || ( e->err == ERANGE )
     999                  || ( e->err == EMSGSIZE )
     1000                  || ( e->err == ENOTCONN ) )
     1001            {
     1002                /* some protocol error from the peer */
     1003                peer->doPurge = 1;
     1004            }
     1005            else /* a local error, such as an IO error */
    9931006            {
    9941007                t->tor->error = e->err;
    995                 tr_strlcpy( t->tor->errorString, tr_errorString(
    996                                e->err ), sizeof( t->tor->errorString ) );
     1008                tr_strlcpy( t->tor->errorString,
     1009                            tr_strerror( t->tor->error ),
     1010                            sizeof( t->tor->errorString ) );
    9971011                tr_torrentStop( t->tor );
    9981012            }
    999             else if( e->err == TR_ERROR_ASSERT )
    1000             {
    1001                 addStrike( t, peer );
    1002             }
    1003             peer->doPurge = 1;
    10041013            break;
    10051014
  • trunk/libtransmission/peer-msgs.c

    r6839 r6842  
    483483static void
    484484fireError( tr_peermsgs * msgs,
    485            tr_errno      err )
     485           int           err )
    486486{
    487487    tr_peer_event e = blankEvent;
     
    14251425        dbgmsg( msgs, "bad packet - BT message #%d with a length of %d",
    14261426                (int)id, (int)msglen );
    1427         fireError( msgs, TR_ERROR );
     1427        fireError( msgs, EPROTO );
    14281428        return READ_ERR;
    14291429    }
     
    14581458            dbgmsg( msgs, "got Have: %u", ui32 );
    14591459            if( tr_bitfieldAdd( msgs->info->have, ui32 ) )
    1460                 fireError( msgs, TR_ERROR_PEER_MESSAGE );
     1460                fireError( msgs, ERANGE );
    14611461            updatePeerProgress( msgs );
    14621462            tr_rcTransferred( msgs->torrent->swarmSpeed,
     
    16041604}
    16051605
    1606 static tr_errno
     1606/* returns 0 on success, or an errno on failure */
     1607static int
    16071608clientGotBlock( tr_peermsgs *               msgs,
    16081609                const uint8_t *             data,
     
    16201621        dbgmsg( msgs, "wrong block size -- expected %u, got %d",
    16211622                tr_torBlockCountBytes( msgs->torrent, block ), req->length );
    1622         return TR_ERROR;
     1623        return EMSGSIZE;
    16231624    }
    16241625
     
    16571658
    16581659    msgs->info->peerSentPieceDataAt = time( NULL );
    1659     if( ( err = tr_ioWrite( tor, req->index, req->offset, req->length, data ) ) )
     1660    if(( err = tr_ioWrite( tor, req->index, req->offset, req->length, data )))
    16601661        return err;
    16611662
     
    18561857        dbgmsg( vmsgs, "libevent got an error! what=%hd, errno=%d (%s)",
    18571858               what, errno, tr_strerror( errno ) );
    1858     fireError( vmsgs, TR_ERROR );
     1859    fireError( vmsgs, ENOTCONN );
    18591860}
    18601861
  • trunk/libtransmission/session.h

    r6795 r6842  
    133133int          tr_globalIsLocked( const tr_session * );
    134134
    135 
    136 #define TR_ERROR_IS_IO( e ) ( TR_ERROR_IO_PARENT <= ( e ) && ( e ) <=\
    137                               TR_ERROR_IO_OTHER )
    138 #define TR_ERROR_IS_TC( e ) ( TR_ERROR_TC_ERROR <= ( e ) && ( e ) <=\
    139                               TR_ERROR_TC_WARNING )
    140 
    141 
    142135#endif
  • trunk/libtransmission/torrent-ctor.c

    r6795 r6842  
    1111 */
    1212
     13#include <errno.h>
    1314#include <libgen.h> /* basename */
    1415#include "transmission.h"
     
    139140    const char * filename;
    140141
    141     if( ( filename = tr_sessionFindTorrentFile( ctor->handle, hashString ) ) )
     142    filename = tr_sessionFindTorrentFile( ctor->handle, hashString );
     143    if( !filename )
     144        err = EINVAL;
     145    else
    142146        err = tr_ctorSetMetainfoFromFile( ctor, filename );
    143     else
    144         err = TR_ERROR;
    145147
    146148    return err;
  • trunk/libtransmission/torrent.c

    r6832 r6842  
    233233        case TR_TRACKER_WARNING:
    234234            tr_torerr( tor, _( "Tracker warning: \"%s\"" ), event->text );
    235             tor->error = TR_ERROR_TC_WARNING;
     235            tor->error = -1;
    236236            tr_strlcpy( tor->errorString, event->text,
    237237                       sizeof( tor->errorString ) );
     
    240240        case TR_TRACKER_ERROR:
    241241            tr_torerr( tor, _( "Tracker error: \"%s\"" ), event->text );
    242             tor->error = TR_ERROR_TC_ERROR;
     242            tor->error = -2;
    243243            tr_strlcpy( tor->errorString, event->text,
    244244                       sizeof( tor->errorString ) );
     
    523523    assert( !tor->uploadedCur );
    524524
    525     tor->error   = TR_OK;
     525    tor->error   = 0;
    526526
    527527    tor->checkedPieces = tr_bitfieldNew( tor->info.pieceCount );
  • trunk/libtransmission/transmission.h

    r6825 r6842  
    788788/**
    789789 * Parses the specified metainfo.
    790  * Returns TR_OK if it parsed and can be added to Transmission.
     790 * Returns 0 if it parsed successfully and can be added to Transmission.
    791791 * Returns TR_EINVALID if it couldn't be parsed.
    792792 * Returns TR_EDUPLICATE if it parsed but can't be added.
     
    11771177#define TR_STATUS_IS_ACTIVE( s ) ( ( s ) != TR_STATUS_STOPPED )
    11781178
    1179 /**
    1180  * Transmission error codes
    1181  * errors are always negative, and 0 refers to no error.
    1182  */
    1183 typedef enum tr_errno
    1184 {
    1185     TR_OK = 0,
    1186 
    1187     /* general errors */
    1188     TR_ERROR = -100,
    1189     TR_ERROR_ASSERT,
    1190 
    1191     /* io errors */
    1192     TR_ERROR_IO_PARENT = -200,
    1193     TR_ERROR_IO_PERMISSIONS,
    1194     TR_ERROR_IO_SPACE,
    1195     TR_ERROR_IO_FILE_TOO_BIG,
    1196     TR_ERROR_IO_OPEN_FILES,
    1197     TR_ERROR_IO_DUP_DOWNLOAD,
    1198     TR_ERROR_IO_CHECKSUM,
    1199     TR_ERROR_IO_OTHER,
    1200 
    1201     /* tracker errors */
    1202     TR_ERROR_TC_ERROR = -300,
    1203     TR_ERROR_TC_WARNING,
    1204 
    1205     /* peer errors */
    1206     TR_ERROR_PEER_MESSAGE = -400
    1207 }
    1208 tr_errno;
    1209 
    12101179typedef enum
    12111180{
     
    12131182    TR_LOCKFILE_EOPEN,
    12141183    TR_LOCKFILE_ELOCK
    1215 } tr_lockfile_state_t;
     1184}
     1185tr_lockfile_state_t;
    12161186
    12171187tr_torrent_status tr_torrentGetStatus( tr_torrent * );
     
    12511221    char *  scrapeURL;
    12521222
    1253     /** The error status for this torrent.  0 means everything's fine. */
    1254     tr_errno    error;
     1223    /** The errno status for this torrent.  0 means everything's fine. */
     1224    int     error;
    12551225
    12561226    /** Typically an error string returned from the tracker. */
  • trunk/libtransmission/utils.c

    r6795 r6842  
    409409    if( stat( path, &sb ) )
    410410    {
     411        const int err = errno;
    411412        tr_dbg( err_fmt, path, tr_strerror( errno ) );
     413        errno = err;
    412414        return NULL;
    413415    }
     
    416418    {
    417419        tr_err( err_fmt, path, _( "Not a regular file" ) );
     420        errno = EISDIR;
    418421        return NULL;
    419422    }
     
    423426    if( !file )
    424427    {
     428        const int err = errno;
    425429        tr_err( err_fmt, path, tr_strerror( errno ) );
     430        errno = err;
    426431        return NULL;
    427432    }
    428433    buf = malloc( sb.st_size );
    429     if( NULL == buf )
    430     {
     434    if( !buf )
     435    {
     436        const int err = errno;
    431437        tr_err( err_fmt, path, _( "Memory allocation failed" ) );
    432438        fclose( file );
     439        errno = err;
    433440        return NULL;
    434441    }
    435442    if( fread( buf, sb.st_size, 1, file ) != 1 )
    436443    {
     444        const int err = errno;
    437445        tr_err( err_fmt, path, tr_strerror( errno ) );
    438446        fclose( file );
    439447        free( buf );
     448        errno = err;
    440449        return NULL;
    441450    }
     451
    442452    fclose( file );
    443 
    444453    *size = sb.st_size;
    445 
    446454    return buf;
    447455}
     
    554562    va_end( vl );
    555563    evbuffer_free( evbuf );
    556 }
    557 
    558 int
    559 tr_ioErrorFromErrno( int err )
    560 {
    561     switch( err )
    562     {
    563         case 0:
    564             return TR_OK;
    565 
    566         case EACCES:
    567         case EROFS:
    568             return TR_ERROR_IO_PERMISSIONS;
    569 
    570         case ENOSPC:
    571             return TR_ERROR_IO_SPACE;
    572 
    573         case EMFILE:
    574             return TR_ERROR_IO_OPEN_FILES;
    575 
    576         case EFBIG:
    577             return TR_ERROR_IO_FILE_TOO_BIG;
    578 
    579         default:
    580             tr_err( "generic i/o errno from errno: %s", tr_strerror( errno ) );
    581             return TR_ERROR_IO_OTHER;
    582     }
    583 }
    584 
    585 const char *
    586 tr_errorString( int code )
    587 {
    588     switch( code )
    589     {
    590         case TR_OK:
    591             return _( "No error" );
    592 
    593         case TR_ERROR:
    594             return _( "Unspecified error" );
    595 
    596         case TR_ERROR_ASSERT:
    597             return _( "Assert error" );
    598 
    599         case TR_ERROR_IO_PARENT:
    600             return _( "Destination folder doesn't exist" );
    601 
    602         case TR_ERROR_IO_PERMISSIONS:
    603             return tr_strerror( EACCES );
    604 
    605         case TR_ERROR_IO_SPACE:
    606             return tr_strerror( ENOSPC );
    607 
    608         case TR_ERROR_IO_FILE_TOO_BIG:
    609             return tr_strerror( EFBIG );
    610 
    611         case TR_ERROR_IO_OPEN_FILES:
    612             return tr_strerror( EMFILE );
    613 
    614         case TR_ERROR_IO_DUP_DOWNLOAD:
    615             return _(
    616                        "A torrent with this name and destination folder already exists." );
    617 
    618         case TR_ERROR_IO_CHECKSUM:
    619             return _( "Checksum failed" );
    620 
    621         case TR_ERROR_IO_OTHER:
    622             return _( "Unspecified I/O error" );
    623 
    624         case TR_ERROR_TC_ERROR:
    625             return _( "Tracker error" );
    626 
    627         case TR_ERROR_TC_WARNING:
    628             return _( "Tracker warning" );
    629 
    630         case TR_ERROR_PEER_MESSAGE:
    631             return _( "Peer sent a bad message" );
    632 
    633         default:
    634             return _( "Unknown error" );
    635     }
    636564}
    637565
  • trunk/libtransmission/utils.h

    r6798 r6842  
    167167
    168168
     169/**
     170 * Loads a file and returns its contents.
     171 * On failure, NULL is returned and errno is set.
     172 */
    169173uint8_t*       tr_loadFile( const char * filename,
    170174                            size_t *     size ) TR_GNUC_MALLOC;
     
    181185struct timeval tr_timevalMsec( uint64_t milliseconds );
    182186
    183 
    184 int            tr_ioErrorFromErrno( int err );
    185 
    186 const char *   tr_errorString( int code );
    187187
    188188/* return the current date in milliseconds */
Note: See TracChangeset for help on using the changeset viewer.