Changeset 13781


Ignore:
Timestamp:
Jan 7, 2013, 6:16:34 PM (8 years ago)
Author:
jordan
Message:

copyediting: update torrent-magnet.c to the new indentation style

File:
1 edited

Legend:

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

    r13722 r13781  
    4242enum
    4343{
    44     /* don't ask for the same metadata piece more than this often */
    45     MIN_REPEAT_INTERVAL_SECS = 3
     44  /* don't ask for the same metadata piece more than this often */
     45  MIN_REPEAT_INTERVAL_SECS = 3
    4646};
    4747
    4848struct metadata_node
    4949{
    50     time_t requestedAt;
    51     int piece;
     50  time_t requestedAt;
     51  int piece;
    5252};
    5353
    5454struct tr_incomplete_metadata
    5555{
    56     uint8_t * metadata;
    57     int metadata_size;
    58     int pieceCount;
    59 
    60     /** sorted from least to most recently requested */
    61     struct metadata_node * piecesNeeded;
    62     int piecesNeededCount;
     56  uint8_t * metadata;
     57  int metadata_size;
     58  int pieceCount;
     59
     60  /** sorted from least to most recently requested */
     61  struct metadata_node * piecesNeeded;
     62  int piecesNeededCount;
    6363};
    6464
     
    6666incompleteMetadataFree (struct tr_incomplete_metadata * m)
    6767{
    68     tr_free (m->metadata);
    69     tr_free (m->piecesNeeded);
    70     tr_free (m);
     68  tr_free (m->metadata);
     69  tr_free (m->piecesNeeded);
     70  tr_free (m);
    7171}
    7272
     
    7474tr_torrentSetMetadataSizeHint (tr_torrent * tor, int size)
    7575{
    76     if (!tr_torrentHasMetadata (tor))
    77     {
    78         if (tor->incompleteMetadata == NULL)
    79         {
    80             int i;
    81             struct tr_incomplete_metadata * m;
    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);
    86             m->pieceCount = n;
    87             m->metadata = tr_new (uint8_t, size);
    88             m->metadata_size = size;
    89             m->piecesNeededCount = n;
    90             m->piecesNeeded = tr_new (struct metadata_node, n);
    91 
    92             for (i=0; i<n; ++i) {
    93                 m->piecesNeeded[i].piece = i;
    94                 m->piecesNeeded[i].requestedAt = 0;
     76  if (!tr_torrentHasMetadata (tor))
     77    {
     78      if (tor->incompleteMetadata == NULL)
     79        {
     80          int i;
     81          struct tr_incomplete_metadata * m;
     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);
     86          m->pieceCount = n;
     87          m->metadata = tr_new (uint8_t, size);
     88          m->metadata_size = size;
     89          m->piecesNeededCount = n;
     90          m->piecesNeeded = tr_new (struct metadata_node, n);
     91
     92          for (i=0; i<n; ++i)
     93            {
     94              m->piecesNeeded[i].piece = i;
     95              m->piecesNeeded[i].requestedAt = 0;
    9596            }
    9697
    97             tor->incompleteMetadata = m;
     98          tor->incompleteMetadata = m;
    9899        }
    99100    }
     
    103104findInfoDictOffset (const tr_torrent * tor)
    104105{
    105     size_t fileLen;
    106     uint8_t * fileContents;
    107     int offset = 0;
    108 
    109     /* load the file, and find the info dict's offset inside the file */
    110     if ((fileContents = tr_loadFile (tor->info.torrent, &fileLen)))
    111     {
    112         tr_variant top;
    113 
    114         if (!tr_variantFromBenc (&top, fileContents, fileLen))
    115         {
    116             tr_variant * infoDict;
    117 
    118             if (tr_variantDictFindDict (&top, TR_KEY_info, &infoDict))
     106  size_t fileLen;
     107  uint8_t * fileContents;
     108  int offset = 0;
     109
     110  /* load the file, and find the info dict's offset inside the file */
     111  if ((fileContents = tr_loadFile (tor->info.torrent, &fileLen)))
     112    {
     113      tr_variant top;
     114
     115      if (!tr_variantFromBenc (&top, fileContents, fileLen))
     116        {
     117          tr_variant * infoDict;
     118
     119          if (tr_variantDictFindDict (&top, TR_KEY_info, &infoDict))
    119120            {
    120                 int infoLen;
    121                 char * infoContents = tr_variantToStr (infoDict, TR_VARIANT_FMT_BENC, &infoLen);
    122                 const uint8_t * i = (const uint8_t*) tr_memmem ((char*)fileContents, fileLen, infoContents, infoLen);
    123                 offset = i != NULL ? i - fileContents : 0;
    124                 tr_free (infoContents);
     121              int infoLen;
     122              char * infoContents = tr_variantToStr (infoDict, TR_VARIANT_FMT_BENC, &infoLen);
     123              const uint8_t * i = (const uint8_t*) tr_memmem ((char*)fileContents, fileLen, infoContents, infoLen);
     124              offset = i != NULL ? i - fileContents : 0;
     125              tr_free (infoContents);
    125126            }
    126127
    127             tr_variantFree (&top);
    128         }
    129 
    130         tr_free (fileContents);
    131     }
    132 
    133     return offset;
     128          tr_variantFree (&top);
     129        }
     130
     131      tr_free (fileContents);
     132    }
     133
     134  return offset;
    134135}
    135136
     
    137138ensureInfoDictOffsetIsCached (tr_torrent * tor)
    138139{
    139     assert (tr_torrentHasMetadata (tor));
    140 
    141     if (!tor->infoDictOffsetIsCached)
    142     {
    143         tor->infoDictOffset = findInfoDictOffset (tor);
    144         tor->infoDictOffsetIsCached = true;
     140  assert (tr_torrentHasMetadata (tor));
     141
     142  if (!tor->infoDictOffsetIsCached)
     143    {
     144      tor->infoDictOffset = findInfoDictOffset (tor);
     145      tor->infoDictOffsetIsCached = true;
    145146    }
    146147}
     
    149150tr_torrentGetMetadataPiece (tr_torrent * tor, int piece, int * len)
    150151{
    151     char * ret = NULL;
    152 
    153     assert (tr_isTorrent (tor));
    154     assert (piece >= 0);
    155     assert (len != NULL);
    156 
    157     if (tr_torrentHasMetadata (tor))
    158     {
    159         FILE * fp;
    160 
    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)
    168         {
    169             const int o = piece  * METADATA_PIECE_SIZE;
    170 
    171             if (!fseek (fp, tor->infoDictOffset + o, SEEK_SET))
     152  char * ret = NULL;
     153
     154  assert (tr_isTorrent (tor));
     155  assert (piece >= 0);
     156  assert (len != NULL);
     157
     158  if (tr_torrentHasMetadata (tor))
     159    {
     160      FILE * fp;
     161
     162      ensureInfoDictOffsetIsCached (tor);
     163
     164      assert (tor->infoDictLength > 0);
     165      assert (tor->infoDictOffset >= 0);
     166
     167      fp = fopen (tor->info.torrent, "rb");
     168      if (fp != NULL)
     169        {
     170          const int o = piece  * METADATA_PIECE_SIZE;
     171
     172          if (!fseek (fp, tor->infoDictOffset + o, SEEK_SET))
    172173            {
    173                 const int l = o + METADATA_PIECE_SIZE <= tor->infoDictLength
    174                             ? METADATA_PIECE_SIZE
    175                             : tor->infoDictLength - o;
    176 
    177                 if (0<l && l<=METADATA_PIECE_SIZE)
     174              const int l = o + METADATA_PIECE_SIZE <= tor->infoDictLength
     175                          ? METADATA_PIECE_SIZE
     176                          : tor->infoDictLength - o;
     177
     178              if (0<l && l<=METADATA_PIECE_SIZE)
    178179                {
    179                     char * buf = tr_new (char, l);
    180                     const int n = fread (buf, 1, l, fp);
    181                     if (n == l)
     180                  char * buf = tr_new (char, l);
     181                  const int n = fread (buf, 1, l, fp);
     182                  if (n == l)
    182183                    {
    183                         *len = l;
    184                         ret = buf;
    185                         buf = NULL;
     184                      *len = l;
     185                      ret = buf;
     186                      buf = NULL;
    186187                    }
    187188
    188                     tr_free (buf);
     189                  tr_free (buf);
    189190                }
    190191            }
    191192
    192             fclose (fp);
     193          fclose (fp);
    193194        }
    194195    }
     
    200201tr_torrentSetMetadataPiece (tr_torrent  * tor, int piece, const void  * data, int len)
    201202{
    202     int i;
    203     struct tr_incomplete_metadata * m;
    204     const int offset = piece * METADATA_PIECE_SIZE;
    205 
    206     assert (tr_isTorrent (tor));
    207 
    208     dbgmsg (tor, "got metadata piece %d", piece);
    209 
    210     /* are we set up to download metadata? */
    211     m = tor->incompleteMetadata;
    212     if (m == NULL)
    213         return;
    214 
    215     /* does this data pass the smell test? */
    216     if (offset + len > m->metadata_size)
    217         return;
    218 
    219     /* do we need this piece? */
    220     for (i=0; i<m->piecesNeededCount; ++i)
    221         if (m->piecesNeeded[i].piece == piece)
    222             break;
    223     if (i==m->piecesNeededCount)
    224         return;
    225 
    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);
    233 
    234     /* are we done? */
    235     if (m->piecesNeededCount == 0)
    236     {
    237         bool success = false;
    238         bool checksumPassed = false;
    239         bool metainfoParsed = false;
    240         uint8_t sha1[SHA_DIGEST_LENGTH];
    241 
    242         /* we've got a complete set of metainfo... see if it passes the checksum test */
    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)))
    246         {
    247             /* checksum passed; now try to parse it as benc */
    248             tr_variant infoDict;
    249             const int err = tr_variantFromBenc (&infoDict, m->metadata, m->metadata_size);
    250             dbgmsg (tor, "err is %d", err);
    251             if ((metainfoParsed = !err))
     203  int i;
     204  struct tr_incomplete_metadata * m;
     205  const int offset = piece * METADATA_PIECE_SIZE;
     206
     207  assert (tr_isTorrent (tor));
     208
     209  dbgmsg (tor, "got metadata piece %d", piece);
     210
     211  /* are we set up to download metadata? */
     212  m = tor->incompleteMetadata;
     213  if (m == NULL)
     214    return;
     215
     216  /* does this data pass the smell test? */
     217  if (offset + len > m->metadata_size)
     218    return;
     219
     220  /* do we need this piece? */
     221  for (i=0; i<m->piecesNeededCount; ++i)
     222    if (m->piecesNeeded[i].piece == piece)
     223      break;
     224  if (i==m->piecesNeededCount)
     225    return;
     226
     227  memcpy (m->metadata + offset, data, len);
     228
     229  tr_removeElementFromArray (m->piecesNeeded, i,
     230                             sizeof (struct metadata_node),
     231                             m->piecesNeededCount--);
     232
     233  dbgmsg (tor, "saving metainfo piece %d... %d remain", piece, m->piecesNeededCount);
     234
     235  /* are we done? */
     236  if (m->piecesNeededCount == 0)
     237    {
     238      bool success = false;
     239      bool checksumPassed = false;
     240      bool metainfoParsed = false;
     241      uint8_t sha1[SHA_DIGEST_LENGTH];
     242
     243      /* we've got a complete set of metainfo... see if it passes the checksum test */
     244      dbgmsg (tor, "metainfo piece %d was the last one", piece);
     245      tr_sha1 (sha1, m->metadata, m->metadata_size, NULL);
     246      if ((checksumPassed = !memcmp (sha1, tor->info.hash, SHA_DIGEST_LENGTH)))
     247        {
     248          /* checksum passed; now try to parse it as benc */
     249          tr_variant infoDict;
     250          const int err = tr_variantFromBenc (&infoDict, m->metadata, m->metadata_size);
     251          dbgmsg (tor, "err is %d", err);
     252          if ((metainfoParsed = !err))
    252253            {
    253                 /* yay we have bencoded metainfo... merge it into our .torrent file */
    254                 tr_variant newMetainfo;
    255                 char * path = tr_strdup (tor->info.torrent);
    256 
    257                 if (!tr_variantFromFile (&newMetainfo, TR_VARIANT_FMT_BENC, path))
     254              /* yay we have bencoded metainfo... merge it into our .torrent file */
     255              tr_variant newMetainfo;
     256              char * path = tr_strdup (tor->info.torrent);
     257
     258              if (!tr_variantFromFile (&newMetainfo, TR_VARIANT_FMT_BENC, path))
    258259                {
    259                     bool hasInfo;
    260                     tr_info info;
    261                     int infoDictLength;
    262 
    263                     /* remove any old .torrent and .resume files */
    264                     remove (path);
    265                     tr_torrentRemoveResume (tor);
    266 
    267                     dbgmsg (tor, "Saving completed metadata to \"%s\"", path);
    268                     tr_variantMergeDicts (tr_variantDictAddDict (&newMetainfo, TR_KEY_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))
     260                  bool hasInfo;
     261                  tr_info info;
     262                  int infoDictLength;
     263
     264                  /* remove any old .torrent and .resume files */
     265                  remove (path);
     266                  tr_torrentRemoveResume (tor);
     267
     268                  dbgmsg (tor, "Saving completed metadata to \"%s\"", path);
     269                  tr_variantMergeDicts (tr_variantDictAddDict (&newMetainfo, TR_KEY_info, 0), &infoDict);
     270
     271                  memset (&info, 0, sizeof (tr_info));
     272                  success = tr_metainfoParse (tor->session, &newMetainfo, &info, &hasInfo, &infoDictLength);
     273
     274                  if (success && !tr_getBlockSize (info.pieceSize))
    274275                    {
    275                         tr_torrentSetLocalError (tor, "%s", _("Magnet torrent's metadata is not usable"));
    276                         success = false;
     276                      tr_torrentSetLocalError (tor, "%s", _("Magnet torrent's metadata is not usable"));
     277                      success = false;
    277278                    }
    278279
    279                     if (success)
     280                  if (success)
    280281                    {
    281                         /* keep the new info */
    282                         tor->info = info;
    283                         tor->infoDictLength = infoDictLength;
    284 
    285                         /* save the new .torrent file */
    286                         tr_variantToFile (&newMetainfo, TR_VARIANT_FMT_BENC, tor->info.torrent);
    287                         tr_sessionSetTorrentFile (tor->session, tor->info.hashString, tor->info.torrent);
    288                         tr_torrentGotNewInfoDict (tor);
    289                         tr_torrentSetDirty (tor);
     282                      /* keep the new info */
     283                      tor->info = info;
     284                      tor->infoDictLength = infoDictLength;
     285
     286                      /* save the new .torrent file */
     287                      tr_variantToFile (&newMetainfo, TR_VARIANT_FMT_BENC, tor->info.torrent);
     288                      tr_sessionSetTorrentFile (tor->session, tor->info.hashString, tor->info.torrent);
     289                      tr_torrentGotNewInfoDict (tor);
     290                      tr_torrentSetDirty (tor);
    290291                    }
    291292
    292                     tr_variantFree (&newMetainfo);
     293                  tr_variantFree (&newMetainfo);
    293294                }
    294295
    295                 tr_variantFree (&infoDict);
    296                 tr_free (path);
     296              tr_variantFree (&infoDict);
     297              tr_free (path);
    297298            }
    298299        }
    299300
    300         if (success)
    301         {
    302             incompleteMetadataFree (tor->incompleteMetadata);
    303             tor->incompleteMetadata = NULL;
     301      if (success)
     302        {
     303          incompleteMetadataFree (tor->incompleteMetadata);
     304          tor->incompleteMetadata = NULL;
    304305        }
    305306        else /* drat. */
    306307        {
    307             const int n = m->pieceCount;
    308             for (i=0; i<n; ++i)
     308          const int n = m->pieceCount;
     309          for (i=0; i<n; ++i)
    309310            {
    310                 m->piecesNeeded[i].piece = i;
    311                 m->piecesNeeded[i].requestedAt = 0;
     311              m->piecesNeeded[i].piece = i;
     312              m->piecesNeeded[i].requestedAt = 0;
    312313            }
    313             m->piecesNeededCount = n;
    314             dbgmsg (tor, "metadata error; trying again. %d pieces left", n);
    315 
    316             tr_err ("magnet status: checksum passed %d, metainfo parsed %d",
     314          m->piecesNeededCount = n;
     315          dbgmsg (tor, "metadata error; trying again. %d pieces left", n);
     316
     317          tr_err ("magnet status: checksum passed %d, metainfo parsed %d",
    317318                  (int)checksumPassed, (int)metainfoParsed);
    318319        }
     
    323324tr_torrentGetNextMetadataRequest (tr_torrent * tor, time_t now, int * setme_piece)
    324325{
    325     bool have_request = false;
    326     struct tr_incomplete_metadata * m;
    327 
    328     assert (tr_isTorrent (tor));
    329 
    330     m = tor->incompleteMetadata;
    331 
    332     if ((m != NULL)
    333         && (m->piecesNeededCount > 0)
    334         && (m->piecesNeeded[0].requestedAt + MIN_REPEAT_INTERVAL_SECS < now))
    335     {
    336         int i;
    337         const int piece = m->piecesNeeded[0].piece;
    338 
    339         tr_removeElementFromArray (m->piecesNeeded, 0,
    340                                    sizeof (struct metadata_node),
    341                                    m->piecesNeededCount--);
    342 
    343         i = m->piecesNeededCount++;
    344         m->piecesNeeded[i].piece = piece;
    345         m->piecesNeeded[i].requestedAt = now;
    346 
    347         dbgmsg (tor, "next piece to request: %d", piece);
    348         *setme_piece = piece;
    349         have_request = true;
    350     }
    351 
    352     return have_request;
     326  bool have_request = false;
     327  struct tr_incomplete_metadata * m;
     328
     329  assert (tr_isTorrent (tor));
     330
     331  m = tor->incompleteMetadata;
     332
     333  if ((m != NULL) && (m->piecesNeededCount > 0)
     334                  && (m->piecesNeeded[0].requestedAt + MIN_REPEAT_INTERVAL_SECS < now))
     335    {
     336      int i;
     337      const int piece = m->piecesNeeded[0].piece;
     338
     339      tr_removeElementFromArray (m->piecesNeeded, 0,
     340                                 sizeof (struct metadata_node),
     341                                 m->piecesNeededCount--);
     342
     343      i = m->piecesNeededCount++;
     344      m->piecesNeeded[i].piece = piece;
     345      m->piecesNeeded[i].requestedAt = now;
     346
     347      dbgmsg (tor, "next piece to request: %d", piece);
     348      *setme_piece = piece;
     349      have_request = true;
     350    }
     351
     352  return have_request;
    353353}
    354354
     
    356356tr_torrentGetMetadataPercent (const tr_torrent * tor)
    357357{
    358     double ret;
    359 
    360     if (tr_torrentHasMetadata (tor))
    361         ret = 1.0;
    362     else {
    363         const struct tr_incomplete_metadata * m = tor->incompleteMetadata;
    364         if (!m || !m->pieceCount)
    365             ret = 0.0;
    366         else
    367             ret = (m->pieceCount - m->piecesNeededCount) / (double)m->pieceCount;
    368     }
    369 
    370     return ret;
    371 }
    372 
    373 char*
     358  double ret;
     359
     360  if (tr_torrentHasMetadata (tor))
     361    {
     362      ret = 1.0;
     363    }
     364  else
     365    {
     366      const struct tr_incomplete_metadata * m = tor->incompleteMetadata;
     367
     368      if (!m || !m->pieceCount)
     369        ret = 0.0;
     370      else
     371        ret = (m->pieceCount - m->piecesNeededCount) / (double)m->pieceCount;
     372    }
     373
     374  return ret;
     375}
     376
     377char *
    374378tr_torrentInfoGetMagnetLink (const tr_info * inf)
    375379{
    376     unsigned int i;
    377     const char * name;
    378     struct evbuffer * s = evbuffer_new ();
    379 
    380     evbuffer_add_printf (s, "magnet:?xt=urn:btih:%s", inf->hashString);
    381 
    382     name = inf->name;
    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 }
     380  unsigned int i;
     381  const char * name;
     382  struct evbuffer * s = evbuffer_new ();
     383
     384  evbuffer_add_printf (s, "magnet:?xt=urn:btih:%s", inf->hashString);
     385
     386  name = inf->name;
     387  if (name && *name)
     388    {
     389      evbuffer_add_printf (s, "%s", "&dn=");
     390      tr_http_escape (s, name, -1, true);
     391    }
     392
     393  for (i=0; i<inf->trackerCount; ++i)
     394    {
     395      evbuffer_add_printf (s, "%s", "&tr=");
     396      tr_http_escape (s, inf->trackers[i].announce, -1, true);
     397    }
     398
     399  return evbuffer_free_to_str (s);
     400}
Note: See TracChangeset for help on using the changeset viewer.