ctcs.cpp

最新的enhanced ctorrent源码

    snprintf(message, CTCS_BUFSIZE, "CTCONFIG %d %d %f %d %d %d %d %d",
      (int)arg_verbose, (int)cfg_seed_hours, cfg_seed_ratio,
      (int)cfg_max_peers, (int)cfg_min_peers, (int)arg_file_to_download,
      (int)cfg_cache_size, WORLD.IsPaused());

  return SendMessage(message);
}

int Ctcs::Set_Config(char *msgbuf)
{
  if(msgbuf[9] != '.'){
    int arg = atoi(msgbuf+9);
    if( arg_verbose && !arg ) CONSOLE.Debug("Verbose output off");
    arg_verbose = arg;
  }
  if(msgbuf[11] != '.') cfg_seed_hours = atoi(msgbuf+11);
  msgbuf = strchr(msgbuf+11, ' ') + 1;
  if(msgbuf[0] != '.') cfg_seed_ratio = atof(msgbuf);
  msgbuf = strchr(msgbuf, ' ') + 1;
  if(msgbuf[0] != '.') cfg_max_peers = atoi(msgbuf);
  msgbuf = strchr(msgbuf, ' ') + 1;
  if(msgbuf[0] != '.') cfg_min_peers = atoi(msgbuf);
  msgbuf = strchr(msgbuf, ' ') + 1;
  if(msgbuf[0] != '.'){
    size_t foo = atoi(msgbuf);
    if(foo != arg_file_to_download){
      arg_file_to_download = foo;
      BTCONTENT.SetFilter();
    }
  }
  if( m_protocol >= 2 ){
    msgbuf = strchr(msgbuf, ' ') + 1;
    if(msgbuf[0] != '.'){
      cfg_cache_size = atoi(msgbuf);
      BTCONTENT.CacheConfigure();
    }
  }
  if( m_protocol == 1 ){
    msgbuf = strchr(msgbuf, ' ') + 1;
    // old cfg_exit_zero_peers option
  }
  msgbuf = strchr(msgbuf, ' ') + 1;
  if(msgbuf[0] != '.'){
    if(atoi(msgbuf)){
      if( !WORLD.IsPaused() ) WORLD.Pause();
    }else if( WORLD.IsPaused() ) WORLD.Resume();
  }

  return 0;
}


int Ctcs::Send_Detail()
{
  char message[CTCS_BUFSIZE];
  int r=0;
  size_t n=0;
  BTFILE *file=0;
  BitField tmpFilter, availbf;

  snprintf( message, CTCS_BUFSIZE, "CTDETAIL %lld %d %ld %ld",
    BTCONTENT.GetTotalFilesLength(),
    (int)(BTCONTENT.GetPieceLength()), (long)now,
    (long)(BTCONTENT.GetSeedTime()) );
  r = SendMessage(message);

  if(r==0) r = SendMessage("CTFILES");

  WORLD.Pieces_I_Can_Get(&availbf);

  while( r==0 && (file = BTCONTENT.GetNextFile(file)) ){
    ++n;
    BTCONTENT.SetTmpFilter(n, &tmpFilter);
    BitField tmpBitField = *BTCONTENT.pBF;
    tmpBitField.Except(tmpFilter);
    BitField tmpavail = availbf;
    tmpavail.Except(tmpFilter);

    if( m_protocol == 1 )
      snprintf( message, CTCS_BUFSIZE, "CTFILE %d %d %d %llu %s",
        (int)n, (int)(BTCONTENT.getFilePieces(n)),
        (int)(tmpBitField.Count()),
        (unsigned long long)(file->bf_length), file->bf_filename );
    else
      snprintf( message, CTCS_BUFSIZE, "CTFILE %d %d %d %d %llu %s",
        (int)n, (int)(BTCONTENT.getFilePieces(n)),
        (int)(tmpBitField.Count()), (int)(tmpavail.Count()),
        (unsigned long long)(file->bf_length), file->bf_filename );

    r = SendMessage(message);
  }
  if(r==0) r = SendMessage("CTFDONE");
  return r;
}


int Ctcs::Send_Peers()
{
  btPeer *peer=0;
  char message[CTCS_BUFSIZE];
  char txtid[PEER_ID_LEN*2+3];
  struct sockaddr_in psin;
  int r=0;

  r=SendMessage("CTPEERS");
  while( r==0 && (peer = WORLD.GetNextPeer(peer)) ){
    TextPeerID(peer->id, txtid);
     peer->GetAddress(&psin);

     snprintf(message, CTCS_BUFSIZE, "CTPEER %s %s %c%c%c%c %d %d %llu %llu %d",
       txtid, inet_ntoa(psin.sin_addr),
       peer->Is_Remote_UnChoked() ? 'U' : 'C',
       peer->Is_Local_Interested() ? 'i' : 'n',
       peer->Is_Local_UnChoked() ? 'U' : 'C',
       peer->Is_Remote_Interested() ? 'i' : 'n',
       (int)(peer->RateDL()), (int)(peer->RateUL()),
       (unsigned long long)(peer->TotalDL()),
         (unsigned long long)(peer->TotalUL()),
       (int)(peer->bitfield.Count()) );
     r = SendMessage(message);
  }
  if(r==0) r = SendMessage("CTPDONE");
  return r;
}


int Ctcs::Send_Info(int sev, const char *info)
{
  char message[CTCS_BUFSIZE];

  snprintf(message, CTCS_BUFSIZE, "CTINFO %d %s", sev, info);
  return SendMessage(message);
}


int Ctcs::Initial()
{
  char *s;

  strncpy(m_host, arg_ctcs, MAXHOSTNAMELEN-1);
  m_host[MAXHOSTNAMELEN-1] = '\0';
  if( s = strchr(m_host, ':') ) *s='\0';
  m_port = atoi(s=(strchr(arg_ctcs, ':')+1));
  if(strchr(s, ':')){
    CONSOLE.Input("Enter CTCS password: ", m_pass, CTCS_PASS_SIZE);
  } else *m_pass = '\0';

  return 0;
}


int Ctcs::Connect()
{
  ssize_t r;
  m_last_timestamp = now;

  if(_s2sin(m_host,m_port,&m_sin) < 0) {
    CONSOLE.Warning(2, "warn, get CTCS ip address failed.");
    return -1;
  }

  m_sock = socket(AF_INET,SOCK_STREAM,0);
  if(INVALID_SOCKET == m_sock) return -1;

  if(setfd_nonblock(m_sock) < 0) {CLOSE_SOCKET(m_sock); return -1; }

  r = connect_nonb(m_sock,(struct sockaddr*)&m_sin);

  if( r == -1 ){ CLOSE_SOCKET(m_sock); return -1;}
  else if( r == -2 ) m_status = T_CONNECTING;
  else{
    m_status = T_READY;
    if( Send_Protocol() != 0 && errno != EINPROGRESS ){
      CONSOLE.Warning(2, "warn, send protocol to CTCS failed:  %s",
        strerror(errno));
      return -1;
    }
    if( Send_Auth() != 0 && errno != EINPROGRESS ) {
      CONSOLE.Warning(2, "warn, send password to CTCS failed:  %s",
        strerror(errno));
      return -1;
    }
    if( Send_Torrent(BTCONTENT.GetPeerId(), arg_metainfo_file) != 0 &&
        errno != EINPROGRESS ){
      CONSOLE.Warning(2, "warn, send torrent to CTCS failed:  %s",
        strerror(errno));
      return -1;
    }
  }
  return 0;
}


int Ctcs::IntervalCheck(fd_set *rfdp, fd_set *wfdp)
{
  if( T_FREE == m_status ){
    if( now - m_last_timestamp >= m_interval ){
      if(Connect() < 0){ Reset(15); return -1; }

      FD_SET(m_sock, rfdp);
      if( m_status == T_CONNECTING ) FD_SET(m_sock, wfdp);
    }else if( now < m_last_timestamp ) m_last_timestamp = now;
  }else{
    if( m_status == T_CONNECTING ){
      FD_SET(m_sock, rfdp);
      FD_SET(m_sock, wfdp);
    }else if (INVALID_SOCKET != m_sock){
      if( now > m_statustime ){
        Report_Status(
          WORLD.GetSeedsCount(),
          WORLD.GetPeersCount() - WORLD.GetSeedsCount() - WORLD.GetConnCount(),
          BTCONTENT.pBF->Count(), BTCONTENT.GetNPieces(),
          Self.RateDL(), Self.RateUL(),
          Self.TotalDL(), Self.TotalUL(),
          cfg_max_bandwidth_down, cfg_max_bandwidth_up,
          BTCONTENT.CacheUsed()/1024 );
        m_statustime = now;
      }
      FD_SET(m_sock, rfdp);
      if( out_buffer.Count() ) FD_SET(m_sock, wfdp);
    }
  }
  return m_sock;
}


int Ctcs::SocketReady(fd_set *rfdp, fd_set *wfdp, int *nfds,
  fd_set *rfdnextp, fd_set *wfdnextp)
{
  if( T_FREE == m_status ) return 0;

  if( T_CONNECTING == m_status && FD_ISSET(m_sock,wfdp) ){
    int error = 0;
    socklen_t n = sizeof(error);
    (*nfds)--;
    FD_CLR(m_sock, wfdnextp);
    if( FD_ISSET(m_sock, rfdp) ){
      (*nfds)--;
      FD_CLR(m_sock, rfdnextp);
    }
    if(getsockopt(m_sock, SOL_SOCKET,SO_ERROR,&error,&n) < 0 ||
       error != 0 ){
      if( ECONNREFUSED != error )
        CONSOLE.Warning(2, "warn, connect to CTCS failed:  %s",
          strerror(error));
      Reset(15);
      return -1;
    }else{
      m_status = T_READY; 
      if( Send_Protocol() != 0 && errno != EINPROGRESS ){
        CONSOLE.Warning(2, "warn, send protocol to CTCS failed:  %s",
          strerror(errno));
        return -1;
      }
      if( Send_Auth() != 0 && errno != EINPROGRESS ) {
        CONSOLE.Warning(2, "warn, send password to CTCS failed:  %s",
          strerror(errno));
        return -1;
      }
      if( Send_Torrent(BTCONTENT.GetPeerId(), arg_metainfo_file) == 0
          && errno != EINPROGRESS ){
        CONSOLE.Warning(2, "warn, send torrent to CTCS failed:  %s",
          strerror(errno));
        return -1;
      }
    }
  }else if( T_CONNECTING == m_status && FD_ISSET(m_sock,rfdp) ){
    int error = 0;
    socklen_t n = sizeof(error);
    (*nfds)--;
    FD_CLR(m_sock, rfdnextp);
    getsockopt(m_sock, SOL_SOCKET,SO_ERROR,&error,&n);
    CONSOLE.Warning(2, "warn, connect to CTCS failed:  %s", strerror(error));
    Reset(15);
    return -1;
  }else if( INVALID_SOCKET != m_sock ){
    if( FD_ISSET(m_sock, rfdp) ){
      (*nfds)--;
      FD_CLR(m_sock,rfdnextp);
      CheckMessage();
    }
    if( INVALID_SOCKET != m_sock && FD_ISSET(m_sock, wfdp) ){
      (*nfds)--;
      FD_CLR(m_sock,wfdnextp);
      if( out_buffer.Count() && out_buffer.FlushOut(m_sock) < 0){
        Reset(5);
        return -1;
      }
    }
  }
  return 0;
}


void Ctcs::RestartTracker()
{
  Tracker.SetPause();  // prevents downloader from exiting
  Tracker.SetStoped(); // finish the tracker
  // Now we need to wait until the tracker updates (T_FINISHED == m_status),
  // then Tracker.Resume().
  Tracker.SetRestart();
}