Ignore:
Timestamp:
Dec 5, 2012, 5:29:46 PM (9 years ago)
Author:
jordan
Message:

Follow more common whitespace style conventions in the C code (libtransmission, daemon, utils, cli, gtk).

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/torrent-magnet.c

    r13576 r13625  
    33 *
    44 * This file is licensed by the GPL version 2. Works owned by the
    5  * Transmission project are granted a special exemption to clause 2(b)
     5 * Transmission project are granted a special exemption to clause 2 (b)
    66 * so that the bulk of its code can remain under the MIT license.
    77 * This exemption does not extend to derived works not owned by
     
    1212
    1313#include <assert.h>
    14 #include <stdio.h> /* remove() */
    15 #include <string.h> /* memcpy(), memset(), memcmp() */
     14#include <stdio.h> /* remove () */
     15#include <string.h> /* memcpy (), memset (), memcmp () */
    1616
    1717#include <event2/buffer.h>
     
    1919#include "transmission.h"
    2020#include "bencode.h"
    21 #include "crypto.h" /* tr_sha1() */
     21#include "crypto.h" /* tr_sha1 () */
    2222#include "magnet.h"
    2323#include "metainfo.h"
     
    2828#include "web.h"
    2929
    30 #define dbgmsg( tor, ... ) \
    31     do { \
    32         if( tr_deepLoggingIsActive( ) ) \
    33             tr_deepLog( __FILE__, __LINE__, tr_torrentName( tor ), __VA_ARGS__ ); \
    34     } while( 0 )
     30#define dbgmsg(tor, ...) \
     31  do \
     32    { \
     33      if (tr_deepLoggingIsActive ()) \
     34        tr_deepLog (__FILE__, __LINE__, tr_torrentName (tor), __VA_ARGS__); \
     35    } \
     36  while (0)
    3537
    3638/***
     
    6264
    6365static void
    64 incompleteMetadataFree( struct tr_incomplete_metadata * m )
    65 {
    66     tr_free( m->metadata );
    67     tr_free( m->piecesNeeded );
    68     tr_free( m );
     66incompleteMetadataFree (struct tr_incomplete_metadata * m)
     67{
     68    tr_free (m->metadata);
     69    tr_free (m->piecesNeeded);
     70    tr_free (m);
    6971}
    7072
    7173void
    72 tr_torrentSetMetadataSizeHint( tr_torrent * tor, int size )
    73 {
    74     if( !tr_torrentHasMetadata( tor ) )
    75     {
    76         if( tor->incompleteMetadata == NULL )
     74tr_torrentSetMetadataSizeHint (tr_torrent * tor, int size)
     75{
     76    if (!tr_torrentHasMetadata (tor))
     77    {
     78        if (tor->incompleteMetadata == NULL)
    7779        {
    7880            int i;
    7981            struct tr_incomplete_metadata * m;
    80             const int n = ( size + ( METADATA_PIECE_SIZE - 1 ) ) / METADATA_PIECE_SIZE;
    81             dbgmsg( tor, "metadata is %d bytes in %d pieces", size, n );
    82 
    83             m = tr_new( struct tr_incomplete_metadata, 1 );
     82            const int n = (size + (METADATA_PIECE_SIZE - 1)) / METADATA_PIECE_SIZE;
     83            dbgmsg (tor, "metadata is %d bytes in %d pieces", size, n);
     84
     85            m = tr_new (struct tr_incomplete_metadata, 1);
    8486            m->pieceCount = n;
    85             m->metadata = tr_new( uint8_t, size );
     87            m->metadata = tr_new (uint8_t, size);
    8688            m->metadata_size = size;
    8789            m->piecesNeededCount = n;
    88             m->piecesNeeded = tr_new( struct metadata_node, n );
    89 
    90             for( i=0; i<n; ++i ) {
     90            m->piecesNeeded = tr_new (struct metadata_node, n);
     91
     92            for (i=0; i<n; ++i) {
    9193                m->piecesNeeded[i].piece = i;
    9294                m->piecesNeeded[i].requestedAt = 0;
     
    99101
    100102static int
    101 findInfoDictOffset( const tr_torrent * tor )
     103findInfoDictOffset (const tr_torrent * tor)
    102104{
    103105    size_t fileLen;
     
    106108
    107109    /* load the file, and find the info dict's offset inside the file */
    108     if(( fileContents = tr_loadFile( tor->info.torrent, &fileLen )))
     110    if ((fileContents = tr_loadFile (tor->info.torrent, &fileLen)))
    109111    {
    110112        tr_benc top;
    111113
    112         if( !tr_bencParse( fileContents, fileContents + fileLen, &top, NULL ) )
     114        if (!tr_bencParse (fileContents, fileContents + fileLen, &top, NULL))
    113115        {
    114116            tr_benc * infoDict;
    115117
    116             if( tr_bencDictFindDict( &top, "info", &infoDict ) )
     118            if (tr_bencDictFindDict (&top, "info", &infoDict))
    117119            {
    118120                int infoLen;
    119                 char * infoContents = tr_bencToStr( infoDict, TR_FMT_BENC, &infoLen );
    120                 const uint8_t * i = (const uint8_t*) tr_memmem( (char*)fileContents, fileLen, infoContents, infoLen );
     121                char * infoContents = tr_bencToStr (infoDict, TR_FMT_BENC, &infoLen);
     122                const uint8_t * i = (const uint8_t*) tr_memmem ((char*)fileContents, fileLen, infoContents, infoLen);
    121123                offset = i != NULL ? i - fileContents : 0;
    122                 tr_free( infoContents );
    123             }
    124 
    125             tr_bencFree( &top );
    126         }
    127 
    128         tr_free( fileContents );
     124                tr_free (infoContents);
     125            }
     126
     127            tr_bencFree (&top);
     128        }
     129
     130        tr_free (fileContents);
    129131    }
    130132
     
    133135
    134136static void
    135 ensureInfoDictOffsetIsCached( tr_torrent * tor )
    136 {
    137     assert( tr_torrentHasMetadata( tor ) );
    138 
    139     if( !tor->infoDictOffsetIsCached )
    140     {
    141         tor->infoDictOffset = findInfoDictOffset( tor );
     137ensureInfoDictOffsetIsCached (tr_torrent * tor)
     138{
     139    assert (tr_torrentHasMetadata (tor));
     140
     141    if (!tor->infoDictOffsetIsCached)
     142    {
     143        tor->infoDictOffset = findInfoDictOffset (tor);
    142144        tor->infoDictOffsetIsCached = true;
    143145    }
     
    145147
    146148void*
    147 tr_torrentGetMetadataPiece( tr_torrent * tor, int piece, int * len )
     149tr_torrentGetMetadataPiece (tr_torrent * tor, int piece, int * len)
    148150{
    149151    char * ret = NULL;
    150152
    151     assert( tr_isTorrent( tor ) );
    152     assert( piece >= 0 );
    153     assert( len != NULL );
    154 
    155     if( tr_torrentHasMetadata( tor ) )
     153    assert (tr_isTorrent (tor));
     154    assert (piece >= 0);
     155    assert (len != NULL);
     156
     157    if (tr_torrentHasMetadata (tor))
    156158    {
    157159        FILE * fp;
    158160
    159         ensureInfoDictOffsetIsCached( tor );
    160 
    161         assert( tor->infoDictLength > 0 );
    162         assert( tor->infoDictOffset >= 0 );
    163 
    164         fp = fopen( tor->info.torrent, "rb" );
    165         if( fp != NULL )
     161        ensureInfoDictOffsetIsCached (tor);
     162
     163        assert (tor->infoDictLength > 0);
     164        assert (tor->infoDictOffset >= 0);
     165
     166        fp = fopen (tor->info.torrent, "rb");
     167        if (fp != NULL)
    166168        {
    167169            const int o = piece  * METADATA_PIECE_SIZE;
    168170
    169             if( !fseek( fp, tor->infoDictOffset + o, SEEK_SET ) )
     171            if (!fseek (fp, tor->infoDictOffset + o, SEEK_SET))
    170172            {
    171173                const int l = o + METADATA_PIECE_SIZE <= tor->infoDictLength
     
    173175                            : tor->infoDictLength - o;
    174176
    175                 if( 0<l && l<=METADATA_PIECE_SIZE )
     177                if (0<l && l<=METADATA_PIECE_SIZE)
    176178                {
    177                     char * buf = tr_new( char, l );
    178                     const int n = fread( buf, 1, l, fp );
    179                     if( n == l )
     179                    char * buf = tr_new (char, l);
     180                    const int n = fread (buf, 1, l, fp);
     181                    if (n == l)
    180182                    {
    181183                        *len = l;
     
    184186                    }
    185187
    186                     tr_free( buf );
     188                    tr_free (buf);
    187189                }
    188190            }
    189191
    190             fclose( fp );
     192            fclose (fp);
    191193        }
    192194    }
     
    196198
    197199void
    198 tr_torrentSetMetadataPiece( tr_torrent  * tor, int piece, const void  * data, int len )
     200tr_torrentSetMetadataPiece (tr_torrent  * tor, int piece, const void  * data, int len)
    199201{
    200202    int i;
     
    202204    const int offset = piece * METADATA_PIECE_SIZE;
    203205
    204     assert( tr_isTorrent( tor ) );
    205 
    206     dbgmsg( tor, "got metadata piece %d", piece );
     206    assert (tr_isTorrent (tor));
     207
     208    dbgmsg (tor, "got metadata piece %d", piece);
    207209
    208210    /* are we set up to download metadata? */
    209211    m = tor->incompleteMetadata;
    210     if( m == NULL )
     212    if (m == NULL)
    211213        return;
    212214
    213215    /* does this data pass the smell test? */
    214     if( offset + len > m->metadata_size )
     216    if (offset + len > m->metadata_size)
    215217        return;
    216218
    217219    /* do we need this piece? */
    218     for( i=0; i<m->piecesNeededCount; ++i )
    219         if( m->piecesNeeded[i].piece == piece )
     220    for (i=0; i<m->piecesNeededCount; ++i)
     221        if (m->piecesNeeded[i].piece == piece)
    220222            break;
    221     if( i==m->piecesNeededCount )
     223    if (i==m->piecesNeededCount)
    222224        return;
    223225
    224     memcpy( m->metadata + offset, data, len );
    225 
    226     tr_removeElementFromArray( m->piecesNeeded, i,
    227                                sizeof( struct metadata_node ),
    228                                m->piecesNeededCount-- );
    229 
    230     dbgmsg( tor, "saving metainfo piece %d... %d remain", piece, m->piecesNeededCount );
     226    memcpy (m->metadata + offset, data, len);
     227
     228    tr_removeElementFromArray (m->piecesNeeded, i,
     229                               sizeof (struct metadata_node),
     230                               m->piecesNeededCount--);
     231
     232    dbgmsg (tor, "saving metainfo piece %d... %d remain", piece, m->piecesNeededCount);
    231233
    232234    /* are we done? */
    233     if( m->piecesNeededCount == 0 )
     235    if (m->piecesNeededCount == 0)
    234236    {
    235237        bool success = false;
     
    239241
    240242        /* we've got a complete set of metainfo... see if it passes the checksum test */
    241         dbgmsg( tor, "metainfo piece %d was the last one", piece );
    242         tr_sha1( sha1, m->metadata, m->metadata_size, NULL );
    243         if(( checksumPassed = !memcmp( sha1, tor->info.hash, SHA_DIGEST_LENGTH )))
     243        dbgmsg (tor, "metainfo piece %d was the last one", piece);
     244        tr_sha1 (sha1, m->metadata, m->metadata_size, NULL);
     245        if ((checksumPassed = !memcmp (sha1, tor->info.hash, SHA_DIGEST_LENGTH)))
    244246        {
    245247            /* checksum passed; now try to parse it as benc */
    246248            tr_benc infoDict;
    247             const int err = tr_bencLoad( m->metadata, m->metadata_size, &infoDict, NULL );
    248             dbgmsg( tor, "err is %d", err );
    249             if(( metainfoParsed = !err ))
     249            const int err = tr_bencLoad (m->metadata, m->metadata_size, &infoDict, NULL);
     250            dbgmsg (tor, "err is %d", err);
     251            if ((metainfoParsed = !err))
    250252            {
    251253                /* yay we have bencoded metainfo... merge it into our .torrent file */
    252254                tr_benc newMetainfo;
    253                 char * path = tr_strdup( tor->info.torrent );
    254 
    255                 if( !tr_bencLoadFile( &newMetainfo, TR_FMT_BENC, path ) )
     255                char * path = tr_strdup (tor->info.torrent);
     256
     257                if (!tr_bencLoadFile (&newMetainfo, TR_FMT_BENC, path))
    256258                {
    257259                    bool hasInfo;
     
    260262
    261263                    /* remove any old .torrent and .resume files */
    262                     remove( path );
    263                     tr_torrentRemoveResume( tor );
    264 
    265                     dbgmsg( tor, "Saving completed metadata to \"%s\"", path );
    266                     tr_bencMergeDicts( tr_bencDictAddDict( &newMetainfo, "info", 0 ), &infoDict );
    267 
    268                     memset( &info, 0, sizeof( tr_info ) );
    269                     success = tr_metainfoParse( tor->session, &newMetainfo, &info, &hasInfo, &infoDictLength );
    270 
    271                     if( success && !tr_getBlockSize( info.pieceSize ) )
     264                    remove (path);
     265                    tr_torrentRemoveResume (tor);
     266
     267                    dbgmsg (tor, "Saving completed metadata to \"%s\"", path);
     268                    tr_bencMergeDicts (tr_bencDictAddDict (&newMetainfo, "info", 0), &infoDict);
     269
     270                    memset (&info, 0, sizeof (tr_info));
     271                    success = tr_metainfoParse (tor->session, &newMetainfo, &info, &hasInfo, &infoDictLength);
     272
     273                    if (success && !tr_getBlockSize (info.pieceSize))
    272274                    {
    273                         tr_torrentSetLocalError( tor, "%s", _( "Magnet torrent's metadata is not usable" ) );
     275                        tr_torrentSetLocalError (tor, "%s", _ ("Magnet torrent's metadata is not usable"));
    274276                        success = false;
    275277                    }
    276278
    277                     if( success )
     279                    if (success)
    278280                    {
    279281                        /* keep the new info */
     
    282284
    283285                        /* save the new .torrent file */
    284                         tr_bencToFile( &newMetainfo, TR_FMT_BENC, tor->info.torrent );
    285                         tr_sessionSetTorrentFile( tor->session, tor->info.hashString, tor->info.torrent );
    286                         tr_torrentGotNewInfoDict( tor );
    287                         tr_torrentSetDirty( tor );
     286                        tr_bencToFile (&newMetainfo, TR_FMT_BENC, tor->info.torrent);
     287                        tr_sessionSetTorrentFile (tor->session, tor->info.hashString, tor->info.torrent);
     288                        tr_torrentGotNewInfoDict (tor);
     289                        tr_torrentSetDirty (tor);
    288290                    }
    289291
    290                     tr_bencFree( &newMetainfo );
     292                    tr_bencFree (&newMetainfo);
    291293                }
    292294
    293                 tr_bencFree( &infoDict );
    294                 tr_free( path );
    295             }
    296         }
    297 
    298         if( success )
    299         {
    300             incompleteMetadataFree( tor->incompleteMetadata );
     295                tr_bencFree (&infoDict);
     296                tr_free (path);
     297            }
     298        }
     299
     300        if (success)
     301        {
     302            incompleteMetadataFree (tor->incompleteMetadata);
    301303            tor->incompleteMetadata = NULL;
    302304        }
     
    304306        {
    305307            const int n = m->pieceCount;
    306             for( i=0; i<n; ++i )
     308            for (i=0; i<n; ++i)
    307309            {
    308310                m->piecesNeeded[i].piece = i;
     
    310312            }
    311313            m->piecesNeededCount = n;
    312             dbgmsg( tor, "metadata error; trying again. %d pieces left", n );
    313 
    314             tr_err( "magnet status: checksum passed %d, metainfo parsed %d",
    315                     (int)checksumPassed, (int)metainfoParsed );
     314            dbgmsg (tor, "metadata error; trying again. %d pieces left", n);
     315
     316            tr_err ("magnet status: checksum passed %d, metainfo parsed %d",
     317                  (int)checksumPassed, (int)metainfoParsed);
    316318        }
    317319    }
     
    319321
    320322bool
    321 tr_torrentGetNextMetadataRequest( tr_torrent * tor, time_t now, int * setme_piece )
     323tr_torrentGetNextMetadataRequest (tr_torrent * tor, time_t now, int * setme_piece)
    322324{
    323325    bool have_request = false;
    324326    struct tr_incomplete_metadata * m;
    325327
    326     assert( tr_isTorrent( tor ) );
     328    assert (tr_isTorrent (tor));
    327329
    328330    m = tor->incompleteMetadata;
    329331
    330     if( ( m != NULL )
    331         && ( m->piecesNeededCount > 0 )
    332         && ( m->piecesNeeded[0].requestedAt + MIN_REPEAT_INTERVAL_SECS < now ) )
     332    if ((m != NULL)
     333        && (m->piecesNeededCount > 0)
     334        && (m->piecesNeeded[0].requestedAt + MIN_REPEAT_INTERVAL_SECS < now))
    333335    {
    334336        int i;
    335337        const int piece = m->piecesNeeded[0].piece;
    336338
    337         tr_removeElementFromArray( m->piecesNeeded, 0,
    338                                    sizeof( struct metadata_node ),
    339                                    m->piecesNeededCount-- );
     339        tr_removeElementFromArray (m->piecesNeeded, 0,
     340                                   sizeof (struct metadata_node),
     341                                   m->piecesNeededCount--);
    340342
    341343        i = m->piecesNeededCount++;
     
    343345        m->piecesNeeded[i].requestedAt = now;
    344346
    345         dbgmsg( tor, "next piece to request: %d", piece );
     347        dbgmsg (tor, "next piece to request: %d", piece);
    346348        *setme_piece = piece;
    347349        have_request = true;
     
    352354
    353355double
    354 tr_torrentGetMetadataPercent( const tr_torrent * tor )
     356tr_torrentGetMetadataPercent (const tr_torrent * tor)
    355357{
    356358    double ret;
    357359
    358     if( tr_torrentHasMetadata( tor ) )
     360    if (tr_torrentHasMetadata (tor))
    359361        ret = 1.0;
    360362    else {
    361363        const struct tr_incomplete_metadata * m = tor->incompleteMetadata;
    362         if( !m || !m->pieceCount )
     364        if (!m || !m->pieceCount)
    363365            ret = 0.0;
    364366        else
     
    370372
    371373char*
    372 tr_torrentInfoGetMagnetLink( const tr_info * inf )
     374tr_torrentInfoGetMagnetLink (const tr_info * inf)
    373375{
    374376    int i;
    375377    const char * name;
    376     struct evbuffer * s = evbuffer_new( );
    377 
    378     evbuffer_add_printf( s, "magnet:?xt=urn:btih:%s", inf->hashString );
     378    struct evbuffer * s = evbuffer_new ();
     379
     380    evbuffer_add_printf (s, "magnet:?xt=urn:btih:%s", inf->hashString);
    379381
    380382    name = inf->name;
    381     if( name && *name )
    382     {
    383         evbuffer_add_printf( s, "%s", "&dn=" );
    384         tr_http_escape( s, name, -1, true );
    385     }
    386 
    387     for( i=0; i<inf->trackerCount; ++i )
    388     {
    389         evbuffer_add_printf( s, "%s", "&tr=" );
    390         tr_http_escape( s, inf->trackers[i].announce, -1, true );
    391     }
    392 
    393     return evbuffer_free_to_str( s );
    394 }
     383    if (name && *name)
     384    {
     385        evbuffer_add_printf (s, "%s", "&dn=");
     386        tr_http_escape (s, name, -1, true);
     387    }
     388
     389    for (i=0; i<inf->trackerCount; ++i)
     390    {
     391        evbuffer_add_printf (s, "%s", "&tr=");
     392        tr_http_escape (s, inf->trackers[i].announce, -1, true);
     393    }
     394
     395    return evbuffer_free_to_str (s);
     396}
Note: See TracChangeset for help on using the changeset viewer.