/*

 * lftp - file transfer program

 *

 * Copyright (c) 1996-2016 by Alexander V. Lukyanov (lav@yars.free.net)

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 3 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program.  If not, see <http://www.gnu.org/licenses/>.

 */

#include <config.h>

#include <stdlib.h>

#include <assert.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <unistd.h>

#include <fcntl.h>

#include <errno.h>

#include <sha1.h>

#include <dirent.h>

#include "Torrent.h"

#include "TorrentTracker.h"

#include "DHT.h"

#include "log.h"

#include "url.h"

#include "misc.h"

#include "plural.h"

CDECL_BEGIN

#include "human.h"

CDECL_END

static ResType torrent_vars[] = {

   {"torrent:port-range", "6881-6889", ResMgr::RangeValidate, ResMgr::NoClosure},

   {"torrent:max-peers", "60", ResMgr::UNumberValidate},

   {"torrent:save-metadata", "yes", ResMgr::BoolValidate, ResMgr::NoClosure},

   {"torrent:stop-min-ppr", "1.4", ResMgr::FloatValidate},

   {"torrent:stop-on-ratio", "2.0", ResMgr::FloatValidate},

   {"torrent:seed-max-time", "30d", ResMgr::TimeIntervalValidate},

   {"torrent:seed-min-peers", "3", ResMgr::UNumberValidate},

   {"torrent:ip", "", ResMgr::IPv4AddrValidate, ResMgr::NoClosure},

   {"torrent:retracker", ""},

   {"torrent:use-dht", "yes", ResMgr::BoolValidate, ResMgr::NoClosure},

   {"torrent:timeout", "7d", ResMgr::TimeIntervalValidate, ResMgr::NoClosure},

#if INET6

   {"torrent:ipv6", "", ResMgr::IPv6AddrValidate, ResMgr::NoClosure},

#endif

   {0}

};

static ResDecls torrent_vars_register(torrent_vars);

#if INET6

#ifdef HAVE_IFADDRS_H

#include <ifaddrs.h>

#endif

static const char *FindGlobalIPv6Address()

{

#ifdef HAVE_IFADDRS_H

   struct ifaddrs *ifaddrs=0;

   getifaddrs(&ifaddrs);

   for(struct ifaddrs *ifa=ifaddrs; ifa; ifa=ifa->ifa_next) {

      if(ifa->ifa_addr && ifa->ifa_addr->sa_family==AF_INET6) {

	 struct in6_addr *addr=&((struct sockaddr_in6*)ifa->ifa_addr)->sin6_addr;

	 if(!IN6_IS_ADDR_UNSPECIFIED(addr) && !IN6_IS_ADDR_LOOPBACK(addr)

	 && !IN6_IS_ADDR_LINKLOCAL(addr) && !IN6_IS_ADDR_SITELOCAL(addr)

	 && !IN6_IS_ADDR_MULTICAST(addr)) {

	    char *buf=xstring::tmp_buf(INET6_ADDRSTRLEN);

	    inet_ntop(AF_INET6, addr, buf, INET6_ADDRSTRLEN);

	    freeifaddrs(ifaddrs);

	    return buf;

	 }

      }

   }

   freeifaddrs(ifaddrs);

#endif

   return 0;

}

#endif

void Torrent::ClassInit()

{

   static bool inited;

   if(inited)

      return;

   inited=true;

#if INET6

   const char *ipv6=ResMgr::Query("torrent:ipv6",0);

   if(!*ipv6)

   {

      ipv6=FindGlobalIPv6Address();

      if(ipv6) {

	 ProtoLog::LogNote(9,"found IPv6 address: %s",ipv6);

	 ResMgr::Set("torrent:ipv6",0,ipv6);

      }

   }

#endif

}

xstring Torrent::my_peer_id;

xstring Torrent::my_key;

unsigned Torrent::my_key_num;

xmap<Torrent*> Torrent::torrents;

SMTaskRef<TorrentListener> Torrent::listener;

SMTaskRef<TorrentListener> Torrent::listener_udp;

SMTaskRef<DHT> Torrent::dht;

#if INET6

SMTaskRef<TorrentListener> Torrent::listener_ipv6;

SMTaskRef<TorrentListener> Torrent::listener_ipv6_udp;

SMTaskRef<DHT> Torrent::dht_ipv6;

#endif

SMTaskRef<FDCache> Torrent::fd_cache;

Ref<TorrentBlackList> Torrent::black_list;

void Torrent::StartDHT()

{

   if(!ResMgr::QueryBool("torrent:use-dht",0)) {

      StopDHT();

      StopListenerUDP();

      return;

   }

   if(dht)

      return;

   StartListenerUDP();

   const char *home=get_lftp_cache_dir();

   const char *nodename=get_nodename();

   mkdir(xstring::format("%s/DHT",home),0700);

   const char *ip=ResMgr::Query("torrent:ip",0);

   if(!ip || !ip[0])

      ip="127.0.0.1";

   sockaddr_compact ip_packed;

   ip_packed.get_space(4);

   inet_pton(AF_INET,ip,ip_packed.get_non_const());

   ip_packed.set_length(4);

   xstring node_id;

   DHT::MakeNodeId(node_id,ip_packed);

   dht=new DHT(AF_INET,node_id);

   dht->state_file.setf("%s/DHT/ipv4-%s",home,nodename);

   if(listener_udp->GetPort())

      dht->Load();

#if INET6

   ip=ResMgr::Query("torrent:ipv6",0);

   if(!ip || !ip[0])

      ip="::1";

   ip_packed.get_space(16);

   inet_pton(AF_INET6,ip,ip_packed.get_non_const());

   ip_packed.set_length(16);

   DHT::MakeNodeId(node_id,ip_packed);

   dht_ipv6=new DHT(AF_INET6,node_id);

   dht_ipv6->state_file.setf("%s/DHT/ipv6-%s",home,nodename);

   if(listener_ipv6_udp->GetPort())

      dht_ipv6->Load();

#endif

}

void Torrent::StopDHT()

{

   if(!dht)

      return;

   dht->Save();

   dht=0;

#if INET6

   dht_ipv6->Save();

   dht_ipv6=0;

#endif

}

void Torrent::StartListener()

{

   if(listener)

      return;

   listener=new TorrentListener(AF_INET);

   listener->Roll(); // try to allocate ipv4 port first

#if INET6

   listener_ipv6=new TorrentListener(AF_INET6);

#endif

}

void Torrent::StopListener()

{

   listener=0;

#if INET6

   listener_ipv6=0;

#endif

}

void Torrent::StartListenerUDP()

{

   if(listener_udp)

      return;

   listener_udp=new TorrentListener(AF_INET,SOCK_DGRAM);

#if INET6

   listener_ipv6_udp=new TorrentListener(AF_INET6,SOCK_DGRAM);

#endif

}

void Torrent::StopListenerUDP()

{

   listener_udp=0;

#if INET6

   listener_ipv6_udp=0;

#endif

}

Torrent::Torrent(const char *mf,const char *c,const char *od)

   : metainfo_url(mf),

     pieces_timer(10),

     cwd(c), output_dir(od), rate_limit(mf),

     seed_timer("torrent:seed-max-time",0),

     timeout_timer("torrent:timeout",0),

     optimistic_unchoke_timer(30), peers_scan_timer(1),

     am_interested_timer(1), shutting_down_timer(60),

     dht_announce_timer(10*60),

     dht_announce_count(0), dht_announce_count_ipv6(0)

{

   shutting_down=false;

   complete=false;

   end_game=false;

   is_private=false;

   validating=false;

   force_valid=false;

   build_md=false;

   stop_if_complete=false;

   stop_if_known=false;

   md_saved=false;

   validate_index=0;

   metadata_size=0;

   info=0;

   pieces=0;

   piece_length=0;

   total_pieces=0;

   last_piece_length=0;

   total_length=0;

   total_sent=0;

   total_recv=0;

   total_left=0;

   complete_pieces=0;

   connected_peers_count=0;

   active_peers_count=0;

   complete_peers_count=0;

   am_interested_peers_count=0;

   am_not_choking_peers_count=0;

   max_peers=60;

   seed_min_peers=3;

   stop_on_ratio=2;

   stop_min_ppr=1,

   last_piece=TorrentPeer::NO_PIECE;

   min_piece_sources=0;

   avg_piece_sources=0;

   pieces_available_pct=0;

   current_min_ppr=0;

   current_max_ppr=0;

   Reconfig(0);

   if(!my_peer_id) {

      my_peer_id.set("-lftp47-");

      my_peer_id.appendf("%04x",(unsigned)getpid() & 0xffff);

      my_peer_id.appendf("%08x",(unsigned)now.UnixTime());

      assert(my_peer_id.length()==PEER_ID_LEN);

   }

   if(!my_key) {

      for(int i=0; i<10; i++)

	 my_key.appendf("%02x",unsigned(random()/13%256));

      my_key_num=random();

   }

   dht_announce_timer.Stop();

}

Torrent::~Torrent()

{

}

bool Torrent::TrackersDone() const

{

   if(shutting_down && shutting_down_timer.Stopped())

      return true;

   for(int i=0; i

      if(trackers[i]->IsActive())

	 return false;

   }

   return true;

}

int Torrent::Done() const

{

   return (shutting_down && TrackersDone());

}

void Torrent::ShutdownTrackers() const

{

   for(int i=0; i

      trackers[i]->Shutdown();

   }

}

void Torrent::Shutdown()

{

   if(shutting_down)

      return;

   Enter(this);

   LogNote(3,"Shutting down...");

   shutting_down=true;

   shutting_down_timer.Reset();

   ShutdownTrackers();

   DenounceDHT();

   PrepareToDie();

   Leave();

}

void Torrent::AddTorrent(Torrent *t)

{

   if(FindTorrent(t->GetInfoHash()))

      return;

   if(GetTorrentsCount()==0) {

      StartListener();

      StartDHT();

   }

   torrents.add(t->GetInfoHash(),t);

}

void Torrent::RemoveTorrent(Torrent *t)

{

   if(t!=FindTorrent(t->info_hash))

      return;

   torrents.remove(t->GetInfoHash());

   if(GetTorrentsCount()==0) {

      StopListener();

      StopDHT();

      StopListenerUDP();

      fd_cache=0;

      black_list=0;

   }

}

void Torrent::PrepareToDie()

{

   metainfo_copy=0;

   building=0;

   peers.unset();

   if(info_hash && this==FindTorrent(info_hash))

      RemoveTorrent(this);

}

void Torrent::SetError(Error *e)

{

   if(invalid_cause)

      return;

   invalid_cause=e;

   LogError(0,"%s: %s",

      invalid_cause->IsFatal()?"Fatal error":"Transient error",

      invalid_cause->Text());

   Shutdown();

}

void Torrent::SetError(const char *msg)

{

   SetError(Error::Fatal(msg));

}

double Torrent::GetRatio() const

{

   if(total_sent==0 || total_length==total_left)

      return 0;

   return total_sent/double(total_length-total_left);

}

void Torrent::SetDownloader(unsigned piece,unsigned block,const TorrentPeer *o,const TorrentPeer *n)

{

   piece_info[piece].set_downloader(block,o,n,BlocksInPiece(piece));

}

void Torrent::AccountSend(unsigned p,unsigned len)

{

   total_sent+=len;

   send_rate.Add(len);

   piece_info[p].add_ratio(float(len)/PieceLength(p));

}

void Torrent::AccountRecv(unsigned p,unsigned len)

{

   total_recv+=len;

   recv_rate.Add(len);

}

BeNode *Torrent::Lookup(xmap_p<BeNode>& dict,const char *name,BeNode::be_type_t type)

{

   BeNode *node=dict.lookup(name);

   if(!node) {

      SetError(xstring::format("Meta-data: `%s' key missing",name));

      return 0;

   }

   if(node->type!=type) {

      SetError(xstring::format("Meta-data: wrong `%s' type, must be %s",name,BeNode::TypeName(type)));

      return 0;

   }

   return node;

}

void Torrent::InitTranslation()

{

   const char *charset="UTF-8"; // default

   recv_translate_utf8=new DirectedBuffer(DirectedBuffer::GET);

   recv_translate_utf8->SetTranslation(charset,true);

   if(metainfo_tree) {

      BeNode *b_charset=metainfo_tree->lookup("encoding",BeNode::BE_STR);

      if(b_charset)

	 charset=b_charset->str;

   }

   recv_translate=new DirectedBuffer(DirectedBuffer::GET);

   recv_translate->SetTranslation(charset,true);

}

void Torrent::TranslateString(BeNode *node) const

{

   if(node->str_lc)

      return;

   recv_translate->ResetTranslation();

   recv_translate->PutTranslated(node->str);

   node->str_lc.nset(recv_translate->Get(),recv_translate->Size());

   recv_translate->Skip(recv_translate->Size());

}

void Torrent::TranslateStringFromUTF8(BeNode *node) const

{

   if(node->str_lc)

      return;

   const Ref<DirectedBuffer>& tr=recv_translate_utf8;

   tr->ResetTranslation();

   tr->PutTranslated(node->str);

   node->str_lc.nset(tr->Get(),tr->Size());

   tr->Skip(tr->Size());

}

void Torrent::SHA1(const xstring& str,xstring& buf)

{

   buf.get_space(SHA1_DIGEST_SIZE);

   sha1_buffer(str.get(),str.length(),buf.get_non_const());

   buf.set_length(SHA1_DIGEST_SIZE);

}

void Torrent::ValidatePiece(unsigned p)

{

   const xstring& buf=Torrent::RetrieveBlock(p,0,PieceLength(p));

   bool valid=false;

   if(buf.length()==PieceLength(p)) {

      xstring& sha1=xstring::get_tmp();

      SHA1(buf,sha1);

      if(building) {

	 building->SetPiece(p,sha1);

	 valid=true;

      } else {

	 valid=!memcmp(pieces->get()+p*SHA1_DIGEST_SIZE,sha1,SHA1_DIGEST_SIZE);

      }

   }

   if(!valid) {

      if(building) {

	 SetError("File validation error");

	 return;

      }

      if(buf.length()==PieceLength(p))

	 LogError(11,"piece %u digest mismatch",p);

      if(my_bitfield->get_bit(p)) {

	 total_left+=PieceLength(p);

	 complete_pieces--;

	 my_bitfield->set_bit(p,0);

      }

      SetBlocksAbsent(p);

   } else {

      LogNote(11,"piece %u ok",p);

      if(!my_bitfield->get_bit(p)) {

	 total_left-=PieceLength(p);

	 complete_pieces++;

	 my_bitfield->set_bit(p,1);

	 piece_info[p].free_block_map();

      }

   }

}

template<typename T>

static inline int cmp(T a,T b)

{

   if(a>b)

      return 1;

   if(a

      return -1;

   return 0;

}

static Torrent *cmp_torrent;

int Torrent::PiecesNeededCmp(const unsigned *a,const unsigned *b)

{

   int ra=cmp_torrent->piece_info[*a].get_sources_count();

   int rb=cmp_torrent->piece_info[*b].get_sources_count();

   int c=cmp(ra,rb);

   if(c) return c;

   return cmp(*a,*b);

}

int Torrent::PeersCompareActivity(const SMTaskRef<TorrentPeer> *p1,const SMTaskRef<TorrentPeer> *p2)

{

   TimeDiff i1((*p1)->activity_timer.TimePassed());

   TimeDiff i2((*p2)->activity_timer.TimePassed());

   return cmp(i1.Seconds(),i2.Seconds());

}

int Torrent::PeersCompareRecvRate(const SMTaskRef<TorrentPeer> *p1,const SMTaskRef<TorrentPeer> *p2)

{

   float r1((*p1)->peer_recv_rate.Get());

   float r2((*p2)->peer_recv_rate.Get());

   int c=cmp(r1,r2);

   if(c) return c;

   return PeersCompareSendRate(p1,p2);

}

int Torrent::PeersCompareSendRate(const SMTaskRef<TorrentPeer> *p1,const SMTaskRef<TorrentPeer> *p2)

{

   float r1((*p1)->peer_send_rate.Get());

   float r2((*p2)->peer_send_rate.Get());

   return cmp(r1,r2);

}

bool Torrent::SeededEnough() const

{

   return (stop_on_ratio>0 && GetRatio()>=stop_on_ratio

	   && GetMinPerPieceRatio()>=stop_min_ppr)

      || seed_timer.Stopped();

}

void Torrent::CleanPeers()

{

   Enter();

   // remove uninteresting peers and request more

   for(int i=0; i

      const TorrentPeer *peer=peers[i];

      if(peer->ActivityTimedOut()) {

	 LogNote(4,"removing uninteresting peer %s (%s)",peer->GetName(),peers[i]->Status());

	 BlackListPeer(peer,"2h");

	 peers.remove(i--);

      }

   }

   Leave();

}

void Torrent::StartTrackers()

{

   for(int i=0; i

      trackers[i]->Start();

   }

}

int Torrent::GetPort()

{

   int port=0;

   if(listener && !port)

      port=listener->GetPort();

#if INET6

   if(listener_ipv6 && !port)

      port=listener_ipv6->GetPort();

#endif

   if(listener_udp && !port)

      return listener_udp->GetPort();

#if INET6

   if(listener_ipv6_udp && !port)

      port=listener_ipv6_udp->GetPort();

#endif

   return port;

}

void Torrent::AnnounceDHT()

{

   if(is_private)

      return;

   CleanPeers();

   if(dht)

      dht->AnnouncePeer(this);

#if INET6

   if(dht_ipv6)

      dht_ipv6->AnnouncePeer(this);

#endif

   dht_announce_timer.Reset();

}

void Torrent::DenounceDHT()

{

   if(is_private)

      return;

   if(dht)

      dht->DenouncePeer(this);

#if INET6

   if(dht_ipv6)

      dht_ipv6->DenouncePeer(this);

#endif

}

void Torrent::DHT_Announced(int af)

{

   if(af==AF_INET)

      dht_announce_count++;

#if INET6

   else if(af==AF_INET6)

      dht_announce_count_ipv6++;

#endif

}

const char *Torrent::DHT_Status() const

{

   if(!HasDHT() || Private())

      return "";

   static xstring status;

   status.nset("",0);

   if(dht_announce_count || dht_announce_count_ipv6) {

      status.append(_("announced via "));

      if(dht_announce_count)

	 status.appendf("ipv4:%d",dht_announce_count);

#if INET6

      if(dht_announce_count_ipv6) {

	 if(dht_announce_count)

	    status.append(", ");

	 status.appendf("ipv6:%d",dht_announce_count_ipv6);

      }

#endif

   }

   if(!dht_announce_timer.Stopped() && !validating) {

      if(status.length()>0)

	 status.append("; ");

      status.appendf(_("next announce in %s"),

	 dht_announce_timer.TimeLeft().toString(TimeInterval::TO_STR_TRANSLATE));

   }

   return status;

}

const char *Torrent::GetMetadataPath() const

{

   if(!QueryBool("torrent:save-metadata",0))

      return NULL;

   xstring& path=xstring::cat(get_lftp_data_dir(),"/torrent",NULL);

   mkdir(path,0700);

   path.append("/md");

   mkdir(path,0700);

   path.append('/');

   info_hash.hexdump_to(path);

   return path;

}

bool Torrent::SaveMetadata() const

{

   if(md_saved)

      return true;  // saved already.

   const char *path=GetMetadataPath();

   if(!path)

      return false;

   int fd=open(path,O_CREAT|O_WRONLY,0600);

   if(fd<0) {

      LogError(9,"open(%s): %s",path,strerror(errno));

      return false;

   }

   int bytes_to_write=metadata.length();

   int res=write(fd,metadata.get(),bytes_to_write);

   int saved_errno=errno;

   ftruncate(fd,bytes_to_write);

   close(fd);

   if(res==bytes_to_write)

      return true;  // no error, fd is closed.

   if(res<0)

      LogError(9,"write(%s): %s",path,strerror(saved_errno));

   else

      LogError(9,"write(%s): short write (only wrote %d bytes)",path,res);

   return false;

}

bool Torrent::LoadMetadata(const char *path)

{

   int fd=open(path,O_RDONLY);

   if(fd<0) {

      LogError(9,"open(%s): %s",path,strerror(errno));

      return false;

   }

   struct stat st;

   if(fstat(fd,&st)==-1) {

      close(fd);

      return false;

   }

   int bytes_to_read=st.st_size;

   xstring md;

   int res=read(fd,md.add_space(bytes_to_read),bytes_to_read);

   int saved_errno=errno;

   close(fd);

   if(res==bytes_to_read) {

      // no error, fd is closed.

      md.add_commit(res);

      xstring new_info_hash;

      SHA1(md,new_info_hash);

      if(info_hash && info_hash.ne(new_info_hash)) {

	 LogError(9,"cached metadata does not match info_hash");

	 return false;

      }

      LogNote(9,"got metadata from %s",path);

      if(SetMetadata(md)) {

	 md_saved=true;

	 return true;

      }

      return false;

   }

   if(res<0)

      LogError(9,"read(%s): %s",path,strerror(saved_errno));

   else

      LogError(9,"read(%s): short read (only read %d bytes)",path,res);

   return false;

}

void Torrent::FetchMetadataFromURL(const char *url)

{

   ParsedURL u(url,true);

   if(!u.proto) {

      u.proto.set("file");

      u.path.set(url);  // undo %xx translation

   }

   LogNote(9,"Retrieving meta-data from `%s'...\n",url);

   FileCopyPeer *metainfo_src=new FileCopyPeerFA(&u,FA::RETRIEVE);

   FileCopyPeer *metainfo_dst=new FileCopyPeerMemory(10000000);

   metainfo_copy=new FileCopy(metainfo_src,metainfo_dst,false);

}

void Torrent::StartMetadataDownload()

{

   const char *path=GetMetadataPath();

   if(path && access(path,R_OK)>=0) {

      // we have the metadata cached

      if(LoadMetadata(path)) {

	 if(stop_if_known) {

	    LogNote(2,"found cached metadata, stopping");

	    Shutdown();

	 } else {

	    Startup();

	 }

	 return;

      }

   }

   md_download.nset("",0);

   // add torrent without metadata to announce it and get peers to get MD from.

   AddTorrent(this);

}

void Torrent::SetTotalLength(off_t tl)

{

   total_length=tl;

   LogNote(4,"Total length is %llu",total_length);

   total_left=total_length;

   last_piece_length=total_length%piece_length;

   if(last_piece_length==0)

      last_piece_length=piece_length;

   total_pieces=(total_length+piece_length-1)/piece_length;

   my_bitfield=new BitField(total_pieces);

   blocks_in_piece=(piece_length+BLOCK_SIZE-1)/BLOCK_SIZE;

   blocks_in_last_piece=(last_piece_length+BLOCK_SIZE-1)/BLOCK_SIZE;

   piece_info=new TorrentPiece[total_pieces]();

}

void Torrent::StartValidating()

{

   validate_index=0;

   validating=true;

   recv_rate.Reset();

}

bool Torrent::SetMetadata(const xstring& md)

{

   metadata.set(md);

   timeout_timer.Reset();

   xstring new_info_hash;

   SHA1(metadata,new_info_hash);

   if(info_hash && info_hash.ne(new_info_hash)) {

      metadata.unset();

      SetError("metadata does not match info_hash");

      return false;

   }

   info_hash.set(new_info_hash);

   if(!info) {

      int rest;

      info=BeNode::Parse(metadata,metadata.length(),&rest);

      if(!info) {

	 SetError("cannot parse metadata");

	 return false;

      }

      xmap_p<BeNode> d;

      d.add("info",info);

      metainfo_tree=new BeNode(&d);

      InitTranslation();

   }

   BeNode *b_piece_length=Lookup(info,"piece length",BeNode::BE_INT);

   if(!b_piece_length || b_piece_length->num<1024 || b_piece_length->num>INT_MAX/4) {

      SetError("Meta-data: invalid piece length");

      return false;

   }

   piece_length=b_piece_length->num;

   LogNote(4,"Piece length is %u",piece_length);

   BeNode *b_name=info->lookup("name",BeNode::BE_STR);

   BeNode *b_name_utf8=info->lookup("name.utf-8",BeNode::BE_STR);

   if(b_name_utf8) {

      TranslateStringFromUTF8(b_name_utf8);

      name.set(b_name_utf8->str_lc);

   } else if(b_name) {

      TranslateString(b_name);

      name.set(b_name->str_lc);

   } else {

      name.truncate();

      info_hash.hexdump_to(name);

   }

   Reconfig(0);

   BeNode *files=info->lookup("files");

   if(!files) {

      BeNode *length=Lookup(info,"length",BeNode::BE_INT);

      if(!length || length->num<0) {

	 SetError("Meta-data: invalid or missing length");

	 return false;

      }

      total_length=length->num;

   } else {

      if(files->type!=BeNode::BE_LIST) {

	 SetError("Meta-data: wrong `info/files' type, must be LIST");

	 return false;

      }

      total_length=0;

      for(int i=0; i<files->list.length(); i++) {

	 if(files->list[i]->type!=BeNode::BE_DICT) {

	    SetError(xstring::format("Meta-data: wrong `info/files[%d]' type, must be LIST",i));

	    return false;

	 }

	 BeNode *f=Lookup(files->list[i]->dict,"length",BeNode::BE_INT);

	 if(!f || f->num<0) {

	    SetError("Meta-data: invalid or missing file length");

	    return false;

	 }

	 if(!Lookup(files->list[i]->dict,"path",BeNode::BE_LIST)) {

	    SetError("Meta-data: file path missing");

	    return false;

	 }

	 total_length+=f->num;

      }

   }

   this->files=new TorrentFiles(files,this);

   SetTotalLength(total_length);

   BeNode *b_pieces=Lookup(info,"pieces",BeNode::BE_STR);

   if(!b_pieces) {

      SetError("Meta-data: `pieces' missing");

      return false;

   }

   pieces=&b_pieces->str;

   if(pieces->length()!=SHA1_DIGEST_SIZE*total_pieces) {

      SetError("Meta-data: invalid `pieces' length");

      return false;

   }

   is_private=info->lookup_int("private");