btcontent.cpp

最经典的bittorrent协议的实现的源码

#include "btcontent.h"

#ifdef WINDOWS
#include <direct.h>
#include <io.h>
#include <memory.h>
// include windows sha1 header here.

#else
#include <unistd.h>
#include <sys/param.h>

#if defined(USE_STANDALONE_SHA1)
#include "sha1.h"
#elif defined(HAVE_OPENSSL_SHA_H)
#include <openssl/sha.h>
#elif defined(HAVE_SSL_SHA_H)
#include <ssl/sha.h>
#elif defined(HAVE_SHA_H)
#include <sha.h>
#endif

#endif

#include <stdio.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>

#include "btconfig.h"
#include "bencode.h"
#include "peer.h"
#include "httpencode.h"
#include "tracker.h"
#include "peerlist.h"
#include "ctcs.h"
#include "console.h"
#include "bttime.h"

#define meta_str(keylist,pstr,pint) decode_query(b,flen,(keylist),(pstr),(pint),(int64_t*) 0,QUERY_STR)
#define meta_int(keylist,pint) decode_query(b,flen,(keylist),(const char**) 0,(pint),(int64_t*) 0,QUERY_INT)
#define meta_pos(keylist) decode_query(b,flen,(keylist),(const char**) 0,(size_t*) 0,(int64_t*) 0,QUERY_POS)

#define CACHE_FIT(ca,roff,rlen)	\
(max_uint64_t((ca)->bc_off,(roff)) <= \
 min_uint64_t(((ca)->bc_off + (ca)->bc_len - 1),(roff + rlen - 1)))


btContent BTCONTENT;

static void Sha1(char *ptr,size_t len,unsigned char *dm)
{
#if defined(USE_STANDALONE_SHA1)
  SHA1_CTX context;
  SHA1Init(&context);
  SHA1Update(&context,(unsigned char*)ptr,len);
  SHA1Final(dm,&context);
#else
#ifdef WINDOWS
  ;
#else
  SHA_CTX context;
  SHA1_Init(&context);
  SHA1_Update(&context,(unsigned char*)ptr,len);
  SHA1_Final(dm,&context);
#endif
#endif
}

btContent::btContent()
{
  m_announce = global_piece_buffer = (char*) 0;
  m_hash_table = (unsigned char *) 0;
  pBF = (BitField*) 0;
  pBMasterFilter = (BitField*) 0;
  pBRefer = (BitField*) 0;
  pBChecked = (BitField*) 0;
  m_create_date = m_seed_timestamp = (time_t) 0;
  time(&m_start_timestamp);
  m_cache_oldest = m_cache_newest = (BTCACHE *)0;
  m_cache_size = m_cache_used = 0;
  m_flush_failed = m_flush_tried = (time_t) 0;
  m_check_piece = 0;
  m_flushq = (BTFLUSH *)0;
  m_filters = m_current_filter = (BFNODE *)0;
}

int btContent::CreateMetainfoFile(const char *mifn)
{
  FILE *fp;
  fp = fopen(mifn, "r");
  if( fp ){
    CONSOLE.Warning(1, "error, file \"%s\" already exists.", mifn);
    return -1;
  }else if( ENOENT != errno ){
    CONSOLE.Warning(1, "error, couldn't create \"%s\".", mifn);
    return -1;
  }

  fp = fopen(mifn, "w");

  if( !fp ){
    CONSOLE.Warning(1, "error, open \"%s\" failed:  %s", mifn, strerror(errno));
    return -1;
  }
  if( bencode_begin_dict(fp) != 1 ) goto err;

  // announce
  if( bencode_str("announce", fp) != 1 ) goto err;
  if( bencode_str(m_announce, fp) != 1 ) goto err;
  // create date
  if( bencode_str("creation date", fp) != 1 ) goto err;
  if( bencode_int(m_create_date, fp) != 1 ) goto err;

  // info dict
  if( bencode_str("info", fp) != 1 ) goto err;
  if( bencode_begin_dict(fp) != 1 ) goto err;

  if( m_btfiles.FillMetaInfo(fp) != 1 ) goto err;

  // piece length
  if( bencode_str("piece length", fp) != 1 ) goto err;
  if( bencode_int(m_piece_length, fp) != 1 ) goto err;
  
  // hash table;
  if( bencode_str("pieces", fp) != 1 ) goto err;
  if( bencode_buf((const char*) m_hash_table, m_hashtable_length, fp) != 1 )
    goto err;

  if( bencode_end_dict_list(fp) != 1 ) goto err; // end info
  if( bencode_end_dict_list(fp) != 1 ) goto err; // end torrent

  fclose(fp);
  return 0;
 err:
  if( fp ) fclose(fp);
  return -1;
}

int btContent::InitialFromFS(const char *pathname, char *ann_url, size_t piece_length)
{
  size_t n, percent;

  // piece length
  m_piece_length = piece_length;
  if( m_piece_length % 65536 ){ 
    m_piece_length /= 65536;
    m_piece_length *= 65536;
  }

  // This is really just a sanity check on the piece length to create.
  if( !m_piece_length || m_piece_length > 4096*1024 )
    m_piece_length = 262144;
  
  m_announce = ann_url;
  m_create_date = time((time_t*) 0);

  if(m_btfiles.BuildFromFS(pathname) < 0) return -1;

  global_piece_buffer = new char[m_piece_length];
#ifndef WINDOWS
  if( !global_piece_buffer ) return -1;
#endif
  
  // n pieces
  m_npieces = m_btfiles.GetTotalLength() / m_piece_length;
  if( m_btfiles.GetTotalLength() % m_piece_length ) m_npieces++;

  // create hash table.
  m_hashtable_length = m_npieces * 20;
  m_hash_table = new unsigned char[m_hashtable_length];
#ifndef WINDOWS
  if( !m_hash_table ) return -1;
#endif

  percent = m_npieces / 100;
  if( !percent ) percent = 1;

  CONSOLE.Interact_n("");
  for( n = 0; n < m_npieces; n++ ){
    if( GetHashValue(n, m_hash_table + n * 20) < 0 ) return -1;
    if( n % percent == 0 || n == m_npieces-1 ){
      CONSOLE.InteractU("Create hash table: %d/%d", (int)n+1, (int)m_npieces);
    }
  }
  return 0;
}

int btContent::PrintOut()
{
  CONSOLE.Print("META INFO");
  CONSOLE.Print("Announce: %s", m_announce);
  if( m_create_date ){
    char s[42];
    ctime_r(&m_create_date, s);
    if( s[strlen(s)-1] == '\n' ) s[strlen(s)-1] = '\0';
    CONSOLE.Print("Created On: %s", s);
  }
  CONSOLE.Print("Piece length: %lu", (unsigned long)m_piece_length);
  m_btfiles.PrintOut();
  return 0;
}

int btContent::PrintFiles()
{
  m_btfiles.PrintOut();
  return 0;
}

int btContent::InitialFromMI(const char *metainfo_fname,const char *saveas)
{
#define ERR_RETURN()	{if(b) delete []b; return -1;}
  unsigned char *ptr = m_shake_buffer;
  char *b;
  const char *s;
  size_t flen, q, r;

  m_cache_hit = m_cache_miss = m_cache_pre = 0;
  time(&m_cache_eval_time);

  b = _file2mem(metainfo_fname,&flen);
  if ( !b ) return -1;

  // announce
  if( !meta_str("announce",&s,&r) ) ERR_RETURN();
  if( r > MAXPATHLEN ) ERR_RETURN();
  m_announce = new char [r + 1];
  memcpy(m_announce, s, r);
  m_announce[r] = '\0';
  
  // infohash
  if( !(r = meta_pos("info")) ) ERR_RETURN();
  if( !(q = decode_dict(b + r, flen - r, (char *) 0)) ) ERR_RETURN();
  Sha1(b + r, q, m_shake_buffer + 28);

  if( meta_int("creation date",&r) ) m_create_date = (time_t) r;
 
  // hash table
  if( !meta_str("info|pieces",&s,&m_hashtable_length) ||
      m_hashtable_length % 20 != 0 ) ERR_RETURN();

  m_hash_table = new unsigned char[m_hashtable_length];

#ifndef WINDOWS
  if( !m_hash_table ) ERR_RETURN();
#endif
  memcpy(m_hash_table, s, m_hashtable_length);

  if( !meta_int("info|piece length",&m_piece_length) ) ERR_RETURN();
  m_npieces = m_hashtable_length / 20;

  cfg_req_queue_length = (m_piece_length / cfg_req_slice_size) * 2 - 1;

  if( m_piece_length < cfg_req_slice_size )
    cfg_req_slice_size = m_piece_length;
  
  if( m_btfiles.BuildFromMI(b, flen, saveas) < 0 ) ERR_RETURN();

  delete []b;
  b = (char *)0;
  
  if( arg_flg_exam_only ){
    PrintOut();
    return 0;
  }else{
    arg_flg_exam_only = 1;
    PrintOut();
    arg_flg_exam_only = 0;
  }

  if( (r = m_btfiles.CreateFiles()) < 0 ) ERR_RETURN();

  global_piece_buffer = new char[m_piece_length];
#ifndef WINDOWS
  if( !global_piece_buffer ) ERR_RETURN();
#endif

  pBF = new BitField(m_npieces);
#ifndef WINDOWS
  if( !pBF ) ERR_RETURN();
#endif

  pBRefer = new BitField(m_npieces);
#ifndef WINDOWS
  if( !pBRefer ) ERR_RETURN();
#endif

  pBChecked = new BitField(m_npieces);
#ifndef WINDOWS
  if( !pBChecked ) ERR_RETURN();
#endif

  //create the file filter
  pBMasterFilter = new BitField(m_npieces);
#ifndef WINDOWS
   if( !pBMasterFilter ) ERR_RETURN();
#endif
  if( arg_file_to_download ) SetFilter();

  m_left_bytes = m_btfiles.GetTotalLength() / m_piece_length;
  if( m_btfiles.GetTotalLength() % m_piece_length ) m_left_bytes++;
  if( m_left_bytes != m_npieces ) ERR_RETURN();
  
  m_left_bytes = m_btfiles.GetTotalLength();

  if( arg_flg_check_only ){
    if( r && CheckExist() < 0 ) ERR_RETURN();
    m_btfiles.PrintOut(); // show file completion
    CONSOLE.Print("Already/Total: %d/%d (%d%%)", (int)(pBF->Count()),
      (int)m_npieces, (int)(100 * pBF->Count() / m_npieces));
    if( !arg_flg_force_seed_mode ){
      SaveBitfield();
      exit(0);
    }
  }else if( pBRefer->SetReferFile(arg_bitfield_file) < 0 ){
    CONSOLE.Warning(2, "warn, couldn't set bit field refer file \"%s\":  %s",
      arg_bitfield_file, strerror(errno));
    CONSOLE.Warning(2, "This is normal if you are starting or seeding.");
    pBRefer->SetAll();  // need to check all pieces
  }else if( unlink(arg_bitfield_file) < 0 ){
    CONSOLE.Warning(2, "warn, couldn't delete bit field file \"%s\":  %s",
      arg_bitfield_file, strerror(errno));
  }
  if( !r ){  // don't hash-check if the files were just created
    m_check_piece = m_npieces;
    pBChecked->SetAll();
    delete pBRefer;
    if( arg_flg_force_seed_mode ){
      CONSOLE.Warning(2, "Files were not present; overriding force mode!");
    }
  }else if( arg_flg_force_seed_mode && !arg_flg_check_only ){
    size_t idx = 0;
    *pBF = *pBRefer;
    if( pBF->IsFull() ){
      CONSOLE.Interact("Skipping hash checks and forcing seed mode.");
      CONSOLE.Interact(
       "-----> STOP NOW if you have not downloaded the whole torrent! <-----");
      m_left_bytes = 0;
    }else for( ; idx < m_npieces; idx++ ){
      if( pBF->IsSet(idx) )
        m_left_bytes -= GetPieceLength(idx);
    }
    m_check_piece = m_npieces;
    pBChecked->SetAll();
    delete pBRefer;
  }

  m_cache = new BTCACHE *[m_npieces];
  if( !m_cache ){
    CONSOLE.Warning(1, "error, allocate cache index failed");
    ERR_RETURN();
  }
  memset(m_cache, 0, m_npieces * sizeof(BTCACHE*));
  CacheConfigure();

  *ptr = (unsigned char) 19; ptr++; // protocol string length
  memcpy(ptr,"BitTorrent protocol",19); ptr += 19; //  protocol string
  memset(ptr,0,8);		// reserved set zero.

  {				// peer id
        char *sptr = arg_user_agent;
        char *dptr = (char *)m_shake_buffer + 48;
        char *eptr = dptr + PEER_ID_LEN;
        while (*sptr) *dptr++ = *sptr++;
        while (dptr < eptr) *dptr++ = (unsigned char)random();
  }
  return 0;
}

btContent::~btContent()
{
  if(m_hash_table) delete []m_hash_table;
  if(m_announce) delete []m_announce;
  if(global_piece_buffer) delete []global_piece_buffer;
  if(pBF) delete pBF;
}

void btContent::_Set_InfoHash(unsigned char buf[20]) 
{ 
  memcpy(m_shake_buffer + 28, buf, 20);
}

// returns <0 if error; if using cache: 1 if read from disk, 0 otherwise
ssize_t btContent::ReadSlice(char *buf,size_t idx,size_t off,size_t len)
{
  ssize_t retval = 0;
  uint64_t offset = (uint64_t)idx * (uint64_t)m_piece_length + off;

  if( !m_cache_size ) return buf ? m_btfiles.IO(buf, offset, len, 0) : 0;
  else{
    size_t len2;
    int flg_rescan;
    BTCACHE *p;

    p = m_cache[idx];
    for( ; p && offset + len > p->bc_off && !CACHE_FIT(p,offset,len);
        p = p->bc_next );

    for( ; len && p && CACHE_FIT(p, offset, len); ){
      flg_rescan = 0;
      if( offset < p->bc_off ){
        len2 = p->bc_off - offset;
        if( CacheIO(buf, offset, len2, 0) < 0 ) return -1;
        retval = 1;
        if(buf) m_cache_miss += len2 / DEFAULT_SLICE_SIZE +
                                ((len2 % DEFAULT_SLICE_SIZE) ? 1 : 0);
        else m_cache_pre += len2 / DEFAULT_SLICE_SIZE +
                            ((len2 % DEFAULT_SLICE_SIZE) ? 1 : 0);
        flg_rescan = 1;
      }else{
        char *src;
        if( offset > p->bc_off ){
          len2 = p->bc_off + p->bc_len - offset;
          if( len2 > len ) len2 = len;
          src = p->bc_buf + offset - p->bc_off;
        }else{
          len2 = (len > p->bc_len) ? p->bc_len : len;
          src = p->bc_buf;
        }
        if( buf ){
          memcpy(buf, src, len2);
          m_cache_hit += len2 / DEFAULT_SLICE_SIZE +
                         ((len2 % DEFAULT_SLICE_SIZE) ? 1 : 0);
        }else{  // prefetch only, update the age
          if( m_cache_newest != p ){
            if( p->age_prev ) p->age_prev->age_next = p->age_next;
            else if( p->age_next ) m_cache_oldest = p->age_next;
            if( p->age_next ) p->age_next->age_prev = p->age_prev;
            m_cache_newest->age_next = p;
            p->age_next = (BTCACHE *)0;
            p->age_prev = m_cache_newest;
            m_cache_newest = p;
          }
        }
      }

      if( buf ) buf += len2;
      offset += len2;
      len -= len2;

      if( len ){
        if( flg_rescan ){
          for( p = m_cache[idx];
               p && (offset + len) > p->bc_off && !CACHE_FIT(p,offset,len);
               p = p->bc_next );
        }else{
          p = p->bc_next;
        }
      }
    }// end for;
  
    if( len ){
      if(buf) m_cache_miss += len / DEFAULT_SLICE_SIZE +
                              ((len % DEFAULT_SLICE_SIZE) ? 1 : 0);
      else m_cache_pre += len / DEFAULT_SLICE_SIZE +
                          ((len % DEFAULT_SLICE_SIZE) ? 1 : 0);
      retval = CacheIO(buf, offset, len, 0);
      return (retval < 0) ? retval : 1;
    }
  }