Changeset 1144

Timestamp:

03/15/10 12:42:05 (3 years ago)

Author:

rakshasa

Message:

• Added '-D' flag which turns of redirects for deprecated commands. Use this to ensure your scripts/webui.

• Moved DownloadInfo? to src/torrent.

• Applied the magnet-uri patch.

Location:

trunk

Files:

• libtorrent/src/dht/dht_node.cc (modified) (1 diff)
• libtorrent/src/dht/dht_router.cc (modified) (1 diff)
• libtorrent/src/dht/dht_server.cc (modified) (1 diff)
• libtorrent/src/dht/dht_server.h (modified) (1 diff)
• libtorrent/src/dht/dht_tracker.h (modified) (1 diff)
• libtorrent/src/download/Makefile.am (modified) (1 diff)
• libtorrent/src/download/download_constructor.cc (modified) (5 diffs)
• libtorrent/src/download/download_constructor.h (modified) (2 diffs)
• libtorrent/src/download/download_main.cc (modified) (9 diffs)
• libtorrent/src/download/download_main.h (modified) (3 diffs)
• libtorrent/src/download/download_wrapper.cc (modified) (2 diffs)
• libtorrent/src/download/download_wrapper.h (modified) (1 diff)
• libtorrent/src/net/address_list.cc (modified) (1 diff)
• libtorrent/src/net/address_list.h (modified) (2 diffs)
• libtorrent/src/net/data_buffer.h (modified) (2 diffs)
• libtorrent/src/net/socket_base.cc (modified) (1 diff)
• libtorrent/src/net/socket_base.h (modified) (1 diff)
• libtorrent/src/protocol/Makefile.am (modified) (1 diff)
• libtorrent/src/protocol/extensions.cc (modified) (12 diffs)
• libtorrent/src/protocol/extensions.h (modified) (11 diffs)
• libtorrent/src/protocol/handshake.cc (modified) (3 diffs)
• libtorrent/src/protocol/handshake_manager.cc (modified) (1 diff)
• libtorrent/src/protocol/peer_connection_base.cc (modified) (6 diffs)
• libtorrent/src/protocol/peer_connection_base.h (modified) (2 diffs)
• libtorrent/src/protocol/peer_connection_leech.cc (modified) (4 diffs)
• libtorrent/src/protocol/peer_connection_metadata.cc (added)
• libtorrent/src/protocol/peer_connection_metadata.h (added)
• libtorrent/src/protocol/peer_factory.cc (modified) (2 diffs)
• libtorrent/src/protocol/peer_factory.h (modified) (1 diff)
• libtorrent/src/torrent/Makefile.am (modified) (2 diffs)
• libtorrent/src/torrent/data/file_list.cc (modified) (2 diffs)
• libtorrent/src/torrent/data/file_list.h (modified) (1 diff)
• libtorrent/src/torrent/download.cc (modified) (7 diffs)
• libtorrent/src/torrent/download.h (modified) (4 diffs)
• libtorrent/src/torrent/download_info.h (moved) (moved from trunk/libtorrent/src/download/download_info.h) (10 diffs)
• libtorrent/src/torrent/object_stream.cc (modified) (1 diff)
• libtorrent/src/torrent/object_stream.h (modified) (1 diff)
• libtorrent/src/torrent/peer/connection_list.cc (modified) (5 diffs)
• libtorrent/src/torrent/resume.cc (modified) (3 diffs)
• libtorrent/src/torrent/torrent.cc (modified) (1 diff)
• libtorrent/src/torrent/tracker_list.cc (modified) (1 diff)
• libtorrent/src/tracker/tracker_dht.cc (modified) (1 diff)
• libtorrent/src/tracker/tracker_http.cc (modified) (1 diff)
• libtorrent/src/tracker/tracker_manager.cc (modified) (1 diff)
• libtorrent/src/tracker/tracker_udp.cc (modified) (1 diff)
• rtorrent/src/command_download.cc (modified) (4 diffs)
• rtorrent/src/command_helpers.h (modified) (1 diff)
• rtorrent/src/core/dht_manager.cc (modified) (1 diff)
• rtorrent/src/core/download.cc (modified) (1 diff)
• rtorrent/src/core/download.h (modified) (3 diffs)
• rtorrent/src/core/download_factory.cc (modified) (4 diffs)
• rtorrent/src/core/download_factory.h (modified) (1 diff)
• rtorrent/src/core/download_list.cc (modified) (10 diffs)
• rtorrent/src/core/download_list.h (modified) (1 diff)
• rtorrent/src/core/manager.cc (modified) (4 diffs)
• rtorrent/src/core/manager.h (modified) (1 diff)
• rtorrent/src/display/utils.cc (modified) (2 diffs)
• rtorrent/src/main.cc (modified) (3 diffs)
• rtorrent/src/ui/download.cc (modified) (1 diff)

trunk/libtorrent/src/dht/dht_node.cc

@@ -41 +41 @@
 #include "torrent/object.h"
 
-// For SACompact...
-#include "download/download_info.h"
+#include "net/address_list.h" // For SA.
 
 #include "dht_node.h"

trunk/libtorrent/src/dht/dht_router.cc

@@ -42 +42 @@
 
 #include "torrent/dht_manager.h"
+#include "torrent/download_info.h"
 #include "torrent/exceptions.h"
 #include "utils/sha1.h"

trunk/libtorrent/src/dht/dht_server.cc

@@ -43 +43 @@
 #include "torrent/exceptions.h"
 #include "torrent/connection_manager.h"
+#include "torrent/download_info.h"
 #include "torrent/object.h"
 #include "torrent/object_stream.h"

trunk/libtorrent/src/dht/dht_server.h

@@ -45 +45 @@
 #include "net/socket_datagram.h"
 #include "net/throttle_node.h"
-#include "download/download_info.h"  // for SocketAddressCompact
 #include "torrent/hash_string.h"
 #include "torrent/object_raw_bencode.h"

trunk/libtorrent/src/dht/dht_tracker.h

@@ -43 +43 @@
 #include <rak/socket_address.h>
 
-#include "download/download_info.h"  // for SocketAddressCompact
+#include "net/address_list.h" // For SA.
 #include "torrent/object_raw_bencode.h"
 

trunk/libtorrent/src/download/Makefile.am

@@ -15 +15 @@
         download_constructor.cc \
         download_constructor.h \
-        download_info.h \
         download_main.cc \
         download_main.h \

trunk/libtorrent/src/download/download_constructor.cc

@@ -82 +82 @@
 
 void
-DownloadConstructor::initialize(const Object& b) {
+DownloadConstructor::initialize(Object& b) {
+  if (!b.has_key_map("info") && b.has_key_string("magnet-uri"))
+    parse_magnet_uri(b, b.get_key_string("magnet-uri"));
+
   if (b.has_key_string("encoding"))
     m_defaultEncoding = b.get_key_string("encoding");
 
-  m_download->info()->set_private(b.get_key("info").has_key_value("private") && 
-                                  b.get_key("info").get_key_value("private") == 1);
+  m_download->info()->change_flags(DownloadInfo::flag_private,
+                                   b.get_key("info").has_key_value("private") && 
+                                   b.get_key("info").get_key_value("private") == 1);
 
   parse_name(b.get_key("info"));
@@ -137 +141 @@
     throw input_error("Download has unordered info dictionary.");
 
-  uint32_t chunkSize = b.get_key_value("piece length");
-
-  if (chunkSize <= (1 << 10) || chunkSize > (128 << 20))
-    throw input_error("Torrent has an invalid \"piece length\".");
+  uint32_t chunkSize;
+
+  if (b.has_key_value("meta_download") && b.get_key_value("meta_download"))
+    m_download->info()->set_flags(DownloadInfo::flag_meta_download);
+
+  if (m_download->info()->is_meta_download()) {
+    if (b.get_key_string("pieces").length() != HashString::size_data)
+      throw input_error("Meta-download has invalid piece data.");
+
+    chunkSize = 1;
+    parse_single_file(b, chunkSize);
+
+  } else {
+    chunkSize = b.get_key_value("piece length");
+
+    if (chunkSize <= (1 << 10) || chunkSize > (128 << 20))
+      throw input_error("Torrent has an invalid \"piece length\".");
+  }
 
   if (b.has_key("length")) {
@@ -149 +167 @@
     fileList->set_root_dir("./" + m_download->info()->name());
 
-  } else {
+  } else if (!m_download->info()->is_meta_download()) {
     throw input_error("Torrent must have either length or files entry.");
   }
 
-  if (fileList->size_bytes() == 0)
+  if (fileList->size_bytes() == 0 && !m_download->info()->is_meta_download())
     throw input_error("Torrent has zero length.");
 
@@ -240 +258 @@
 
   FileList* fileList = m_download->main()->file_list();
-  fileList->initialize(b.get_key_value("length"), chunkSize);
+  fileList->initialize(chunkSize == 1 ? 1 : b.get_key_value("length"), chunkSize);
   fileList->set_multi_file(false);
 
@@ -344 +362 @@
 }
 
-}
+static const char*
+parse_base32_sha1(const char* pos, HashString& hash) {
+  HashString::iterator hashItr = hash.begin();
+
+  static const int base_shift = 8+8-5;
+  int shift = base_shift;
+  uint16_t decoded = 0;
+
+  while (*pos) {
+    char c = *pos++;
+    uint16_t value;
+
+    if (c >= 'A' && c <= 'Z')
+      value = c - 'A';
+    else if (c >= 'a' && c <= 'z')
+      value = c - 'a';
+    else if (c >= '2' && c <= '7')
+      value = 26 + c - '2';
+    else if (c == '&')
+      break;
+    else
+      return NULL;
+
+    decoded |= (value << shift);
+    if (shift <= 8) {
+      // Too many characters for a base32 SHA1.
+      if (hashItr == hash.end())
+        return NULL;
+
+      *hashItr++ = (decoded >> 8);
+      decoded <<= 8;
+      shift += 3;
+    } else {
+      shift -= 5;
+    }
+  }
+
+  return hashItr != hash.end() || shift != base_shift ? NULL : pos;
+}
+
+void
+DownloadConstructor::parse_magnet_uri(Object& b, const std::string& uri) {
+  if (std::strncmp(uri.c_str(), "magnet:?", 8))
+    throw input_error("Invalid magnet URI.");
+
+  const char* pos = uri.c_str() + 8;
+
+  Object trackers(Object::create_list());
+  HashString hash;
+  bool hashValid = false;
+
+  while (*pos) {
+    const char* tagStart = pos;
+    while (*pos != '=')
+      if (!*pos++)
+        break;
+
+    raw_string tag(tagStart, pos - tagStart);
+    pos++;
+
+    // hash may be base32 encoded (optional in BEP 0009 and common practice)
+    if (raw_bencode_equal_c_str(tag, "xt")) {
+      if (strncmp(pos, "urn:btih:", 9))
+        throw input_error("Invalid magnet URI.");
+
+      pos += 9;
+
+      const char* nextPos = parse_base32_sha1(pos, hash);
+      if (nextPos != NULL) {
+        pos = nextPos;
+        hashValid = true;
+        continue;
+      }
+    }
+
+    // everything else, including sometimes the hash, is url encoded.
+    std::string decoded;
+    while (*pos) {
+      char c = *pos++;
+      if (c == '%') {
+        if (sscanf(pos, "%02hhx", &c) != 1)
+          throw input_error("Invalid magnet URI.");
+
+        pos += 2;
+
+      } else if (c == '&') {
+        break;
+      }
+
+      decoded.push_back(c);
+    }
+
+    if (raw_bencode_equal_c_str(tag, "xt")) {
+      // url-encoded hash as per magnet URN specs
+      if (decoded.length() == hash.size_data) {
+        hash = *HashString::cast_from(decoded);
+        hashValid = true;
+
+      // hex-encoded hash as per BEP 0009
+      } else if (decoded.length() == hash.size_data * 2) {
+        std::string::iterator hexItr = decoded.begin();
+        for (HashString::iterator itr = hash.begin(), last = hash.end(); itr != last; itr++, hexItr += 2)
+          *itr = (rak::hexchar_to_value(*hexItr) << 4) + rak::hexchar_to_value(*(hexItr + 1));
+        hashValid = true;
+
+      } else {
+        throw input_error("Invalid magnet URI.");
+      }
+
+    } else if (raw_bencode_equal_c_str(tag, "tr")) {
+      trackers.insert_back(Object::create_list()).insert_back(decoded);
+    }
+    // could also handle "dn" = display name (torrent name), but we can't really use that
+  }
+
+  if (!hashValid)
+    throw input_error("Invalid magnet URI.");
+
+  Object& info = b.insert_key("info", Object::create_map());
+  info.insert_key("pieces", hash.str());
+  info.insert_key("name", rak::transform_hex(hash.str()) + ".meta");
+  info.insert_key("meta_download", (int64_t)1);
+
+  if (!trackers.as_list().empty()) {
+    b.insert_preserve_copy("announce", trackers.as_list().begin()->as_list().begin()->as_string());
+    b.insert_preserve_type("announce-list", trackers);
+  }
+}
+
+}

trunk/libtorrent/src/download/download_constructor.h

@@ -56 +56 @@
   DownloadConstructor() : m_download(NULL), m_encodingList(NULL) {}
 
-  void                initialize(const Object& b);
+  void                initialize(Object& b);
 
   void                set_download(DownloadWrapper* d)         { m_download = d; }
@@ -65 +65 @@
   void                parse_tracker(const Object& b);
   void                parse_info(const Object& b);
+  void                parse_magnet_uri(Object& b, const std::string& uri);
 
   void                add_tracker_group(const Object& b);

trunk/libtorrent/src/download/download_main.cc

@@ -59 +59 @@
 #include "chunk_selector.h"
 #include "chunk_statistics.h"
-#include "download_info.h"
 #include "download_main.h"
 #include "download_manager.h"
@@ -65 +64 @@
 
 namespace torrent {
+
+DownloadInfo::DownloadInfo() :
+  m_flags(flag_compact | flag_accepting_new_peers | flag_pex_enabled | flag_pex_active),
+
+  m_upRate(60),
+  m_downRate(60),
+  m_skipRate(60),
+  
+  m_uploadedBaseline(0),
+  m_completedBaseline(0),
+  m_sizePex(0),
+  m_maxSizePex(8),
+  m_metadataSize(0),
+  
+  m_loadDate(rak::timer::current_seconds()) {
+}
 
 DownloadMain::DownloadMain() :
@@ -155 +170 @@
   m_chunkStatistics->initialize(file_list()->size_chunks());
 
-  info()->set_open(true);
+  info()->set_flags(DownloadInfo::flag_open);
 }
 
@@ -166 +181 @@
     return;
 
-  info()->set_open(false);
+  info()->unset_flags(DownloadInfo::flag_open);
 
   // Don't close the tracker manager here else it will cause STOPPED
@@ -191 +206 @@
     throw internal_error("Tried to start an active download");
 
-  info()->set_active(true);
+  info()->set_flags(DownloadInfo::flag_active);
   m_lastConnectedSize = 0;
 
@@ -207 +222 @@
   // Set this early so functions like receive_connect_peers() knows
   // not to eat available peers.
-  info()->set_active(false);
+  info()->unset_flags(DownloadInfo::flag_active);
 
   m_slotStopHandshakes(this);
@@ -355 +370 @@
       m_connectionList->size() < m_connectionList->min_size() / 2 &&
       m_peerList.available_list()->size() < m_peerList.available_list()->max_size() / 4) {
-    m_info->set_pex_active(true);
+    m_info->set_flags(DownloadInfo::flag_pex_active);
 
     // Only set PEX_ENABLE if we don't have max_size_pex set to zero.
@@ -365 +380 @@
 //              m_peerList.available_list()->size() >= m_peerList.available_list()->max_size() / 2) {
     togglePex = PeerConnectionBase::PEX_DISABLE;
-    m_info->set_pex_active(false);
+    m_info->unset_flags(DownloadInfo::flag_pex_active);
   }
 
@@ -456 +471 @@
 }
 
-}
+void
+DownloadMain::set_metadata_size(size_t size) {
+  if (m_info->is_meta_download()) {
+    if (m_fileList.size_bytes() < 2)
+      file_list()->reset_filesize(size);
+    else if (size != m_fileList.size_bytes())
+      throw communication_error("Peer-supplied metadata size mismatch.");
+
+  } else if (m_info->metadata_size() && m_info->metadata_size() != size) {
+      throw communication_error("Peer-supplied metadata size mismatch.");
+  }
+
+  m_info->set_metadata_size(size);
+}
+
+}

trunk/libtorrent/src/download/download_main.h

@@ -44 +44 @@
 #include "globals.h"
 
-#include "download_info.h"
 #include "delegator.h"
 
@@ -50 +49 @@
 #include "download/available_list.h"
 #include "net/data_buffer.h"
+#include "torrent/download_info.h"
 #include "torrent/data/file_list.h"
 #include "torrent/peer/peer_list.h"
@@ -116 +116 @@
 
   bool                want_pex_msg()                             { return m_info->is_pex_active() && m_peerList.available_list()->want_more(); }; 
+
+  void                set_metadata_size(size_t s);
 
   // Carefull with these.

trunk/libtorrent/src/download/download_wrapper.cc

@@ -102 +102 @@
   info()->mutable_local_id().assign(id.c_str());
 
-  info()->slot_completed() = rak::make_mem_fun(m_main.file_list(), &FileList::completed_bytes);
-  info()->slot_left()      = rak::make_mem_fun(m_main.file_list(), &FileList::left_bytes);
+  info()->slot_left() = sigc::mem_fun(m_main.file_list(), &FileList::left_bytes);
+  info()->slot_completed() = sigc::mem_fun(m_main.file_list(), &FileList::completed_bytes);
 
   m_main.slot_hash_check_add(rak::make_mem_fun(this, &DownloadWrapper::check_chunk_hash));
@@ -277 +277 @@
       // If PEX was disabled since the last peer exchange, deactivate it now.
       } else if (info()->is_pex_active()) {
-        info()->set_pex_active(false);
+        info()->unset_flags(DownloadInfo::flag_pex_active);
 
         for (ConnectionList::iterator itr = m_main.connection_list()->begin(); itr != m_main.connection_list()->end(); ++itr)

trunk/libtorrent/src/download/download_wrapper.h

@@ -43 +43 @@
 
 #include "data/chunk_handle.h"
-#include "download/download_info.h"
 
 #include "download_main.h"

trunk/libtorrent/src/net/address_list.cc

@@ -39 +39 @@
 #include <algorithm>
 #include <rak/functional.h>
-
-#include "download/download_info.h"  // for SocketAddressCompact
 
 #include "address_list.h"

trunk/libtorrent/src/net/address_list.h

@@ -54 +54 @@
 
   void                        parse_address_compact(raw_string s);
-  void                        parse_address_compact(const std::string& s) {
-    return parse_address_compact(raw_string(s.data(), s.size()));
-  }
+  void                        parse_address_compact(const std::string& s);
 
 private:
@@ -76 +74 @@
 };
 
+inline void
+AddressList::parse_address_compact(const std::string& s) {
+  return parse_address_compact(raw_string(s.data(), s.size()));
+}
+
+// Move somewhere else.
+struct SocketAddressCompact {
+  SocketAddressCompact() {}
+  SocketAddressCompact(uint32_t a, uint16_t p) : addr(a), port(p) {}
+  SocketAddressCompact(const rak::socket_address_inet* sa) : addr(sa->address_n()), port(sa->port_n()) {}
+
+  operator rak::socket_address () const {
+    rak::socket_address sa;
+    sa.sa_inet()->clear();
+    sa.sa_inet()->set_port_n(port);
+    sa.sa_inet()->set_address_n(addr);
+
+    return sa;
+  }
+
+  uint32_t addr;
+  uint16_t port;
+
+  const char*         c_str() const { return reinterpret_cast<const char*>(this); }
+} __attribute__ ((packed));
+
 }
 

trunk/libtorrent/src/net/data_buffer.h

@@ -49 +49 @@
 
   DataBuffer          clone() const        { DataBuffer d = *this; d.m_owned = false; return d; }
+  DataBuffer          release()            { DataBuffer d = *this; set(NULL, NULL, false); return d; }
 
   char*               data() const         { return m_data; }
@@ -71 +72 @@
 inline void
 DataBuffer::clear() {
-  if (!empty())
+  if (!empty() && m_owned)
     delete[] m_data;
 

trunk/libtorrent/src/net/socket_base.cc

@@ -48 +48 @@
 namespace torrent {
 
-char* SocketBase::m_nullBuffer = new char[1 << 17];
+char* SocketBase::m_nullBuffer = new char[SocketBase::null_buffer_size];
 
 SocketBase::~SocketBase() {

trunk/libtorrent/src/net/socket_base.h

@@ -69 +69 @@
   void operator = (const SocketBase&);
 
+  static const size_t null_buffer_size = 1 << 17;
+
   static char*        m_nullBuffer;
 };

trunk/libtorrent/src/protocol/Makefile.am

@@ -18 +18 @@
         peer_connection_leech.cc \
         peer_connection_leech.h \
+        peer_connection_metadata.cc \
+        peer_connection_metadata.h \
         peer_factory.cc \
         peer_factory.h \

trunk/libtorrent/src/protocol/extensions.cc

@@ -44 +44 @@
 #include "download/available_list.h"
 #include "download/download_main.h"
+#include "download/download_manager.h"
+#include "download/download_wrapper.h"
 #include "protocol/peer_connection_base.h"
 #include "torrent/connection_manager.h"
@@ -58 +60 @@
 const ExtHandshakeMessage::key_list_type ExtHandshakeMessage::keys = {
   { key_e,            "e" },
+  { key_m_utMetadata, "m::ut_metadata" },
   { key_m_utPex,      "m::ut_pex" },
+  { key_metadataSize, "metadata_size" },
   { key_p,            "p" },
   { key_reqq,         "reqq" },
@@ -69 +73 @@
 };
 
+// DEBUG: Add type info.
+template <>
+const ExtMetadataMessage::key_list_type ExtMetadataMessage::keys = {
+  { key_msgType,      "msg_type" },
+  { key_piece,        "piece" },
+  { key_totalSize,    "total_size" },
+};
+
 struct message_type {
   const char* key;
@@ -76 +88 @@
 const message_type message_keys[] = { 
   { "HANDSHAKE", key_handshake_LAST },
-  { "ut_pex", key_m_utPex }
+  { "ut_pex", key_m_utPex },
+  { "metadata_size", key_m_utMetadata }
 };
 
@@ -134 +147 @@
   message[key_reqq] = 2048;  // maximum request queue size
 
+  if (!m_download->info()->is_meta_download())
+    message[key_metadataSize] = m_download->info()->metadata_size();
+
   message[key_m_utPex] = is_local_enabled(UT_PEX) ? UT_PEX : 0;
+  message[key_m_utMetadata] = UT_METADATA;
 
   char buffer[1024];
@@ -201 +218 @@
 void
 ProtocolExtension::read_start(int type, uint32_t length, bool skip) {
-  if (is_default() || (type >= FIRST_INVALID) || length > (1 << 14))
+  if (is_default() || (type >= FIRST_INVALID) || length > (1 << 15))
     throw communication_error("Received invalid extension message.");
 
@@ -221 +238 @@
 }
 
-void
+bool
 ProtocolExtension::read_done() {
+  bool result = true;
+
   try {
     switch(m_readType) {
-    case SKIP_EXTENSION:
-      delete [] m_read;
-      m_read = NULL;
-      return;
-
-    case HANDSHAKE:
-      parse_handshake();
-      break;
-
-    case UT_PEX:
-      parse_ut_pex();
-      break;
-
+    case SKIP_EXTENSION: break;
+    case HANDSHAKE: result = parse_handshake(); break;
+    case UT_PEX:    result = parse_ut_pex(); break;
+    case UT_METADATA: result = parse_ut_metadata(); break;
     default:
       throw internal_error("ProtocolExtension::read_done called with invalid extension type.");
@@ -253 +263 @@
   m_readType = FIRST_INVALID;
   m_flags |= flag_received_ext;
+
+  return result;
 }
 
@@ -266 +278 @@
 }
 
-void
+bool
 ProtocolExtension::parse_handshake() {
   ExtHandshakeMessage message;
@@ -304 +316 @@
     m_maxQueueLength = message[key_reqq].as_value();
 
+  if (message[key_metadataSize].is_value())
+    m_download->set_metadata_size(message[key_metadataSize].as_value());
+
   m_flags &= ~flag_initial_handshake;
-}
-
-void
+
+  return true;
+}
+
+bool
 ProtocolExtension::parse_ut_pex() {
   // Ignore message if we're still in the handshake (no connection
@@ -317 +334 @@
   // TODO: Check if pex is enabled?
   if (!message[key_pex_added].is_raw_string())
-    return;
+    return true;
 
   raw_string peers = message[key_pex_added].as_raw_string();
 
   if (peers.empty())
-    return;
+    return true;
 
   // TODO: Sort the list before adding it.
@@ -331 +348 @@
  
   m_download->peer_list()->insert_available(&l);
-}
-
-}
+
+  return true;
+}
+
+bool
+ProtocolExtension::parse_ut_metadata() {
+  ExtMetadataMessage message;
+
+  // Piece data comes after bencoded extension message.
+  const char* dataStart = static_map_read_bencode(m_read, m_readPos, message);
+
+  switch(message[key_msgType].as_value()) {
+  case 0:
+    // Can't process new request while still having data to send.
+    if (has_pending_message())
+      return false;
+
+    send_metadata_piece(message[key_piece].as_value());
+    break;
+
+  case 1:
+    if (m_connection == NULL)
+      break;
+
+    m_connection->receive_metadata_piece(message[key_piece].as_value(), dataStart, m_readPos - dataStart);
+    break;
+
+  case 2:
+    if (m_connection == NULL)
+      break;
+
+    m_connection->receive_metadata_piece(message[key_piece].as_value(), NULL, 0);
+    break;
+  };
+
+  return true;
+}
+
+void
+ProtocolExtension::send_metadata_piece(size_t piece) {
+  // Reject out-of-range piece, or if we don't have the complete metadata yet.
+  size_t metadataSize = m_download->info()->metadata_size();
+  size_t pieceEnd = (metadataSize + metadata_piece_size - 1) >> metadata_piece_shift;
+
+  if (m_download->info()->is_meta_download() || piece >= pieceEnd) {
+    // reject: { "msg_type" => 2, "piece" => ... }
+    m_pendingType = UT_METADATA;
+    m_pending = build_bencode(40, "d8:msg_typei2e5:piecei%zuee", piece);
+    return;
+  }
+
+  // These messages will be rare, so we'll just build the
+  // metadata here instead of caching it uselessly.
+  char* buffer = new char[metadataSize];
+  object_buffer_t result = object_write_bencode_c(object_write_to_buffer, NULL, object_buffer_t(buffer, buffer + metadataSize), 
+                                                 &(*manager->download_manager()->find(m_download->info()))->bencode()->get_key("info"));
+
+  // data: { "msg_type" => 1, "piece" => ..., "total_size" => ... } followed by piece data (outside of dictionary)
+  size_t length = piece == pieceEnd - 1 ? m_download->info()->metadata_size() % metadata_piece_size : metadata_piece_size;
+  m_pendingType = UT_METADATA;
+  m_pending = build_bencode(length + 128, "d8:msg_typei1e5:piecei%zue10:total_sizei%zuee", piece, metadataSize);
+
+  memcpy(m_pending.end(), buffer + (piece << metadata_piece_shift), length);
+  m_pending.set(m_pending.data(), m_pending.end() + length, m_pending.owned());
+  delete [] buffer;
+}
+
+bool
+ProtocolExtension::request_metadata_piece(const Piece* p) {
+  if (p->offset() % metadata_piece_size)
+    throw internal_error("ProtocolExtension::request_metadata_piece got misaligned piece offset.");
+
+  if (has_pending_message())
+    return false;
+
+  m_pendingType = UT_METADATA;
+  m_pending = build_bencode(40, "d8:msg_typei0e5:piecei%uee", (unsigned)(p->offset() >> metadata_piece_shift));
+  return true;
+}
+
+}

trunk/libtorrent/src/protocol/extensions.h

@@ -45 +45 @@
 #include "torrent/object_static_map.h"
 
-#include "download/download_info.h"
+#include "torrent/download_info.h"
+#include "net/address_list.h"
 #include "net/data_buffer.h"
 
@@ -62 +63 @@
     HANDSHAKE = 0,
     UT_PEX,
+    UT_METADATA,
 
     FIRST_INVALID,    // first invalid message ID
@@ -83 +85 @@
   static const int    extension_count = FIRST_INVALID - HANDSHAKE - 1;
 
+  // Fixed size of a metadata piece (16 KB).
+  static const size_t metadata_piece_shift = 14;
+  static const size_t metadata_piece_size  = 1 << metadata_piece_shift;
+
   ProtocolExtension();
   ~ProtocolExtension() { delete [] m_read; }
@@ -93 +99 @@
 
   void                set_info(PeerInfo* peerInfo, DownloadMain* download) { m_peerInfo = peerInfo; m_download = download; }
+  void                set_connection(PeerConnectionBase* c)                { m_connection = c; }
 
   DataBuffer          generate_handshake_message();
@@ -114 +121 @@
   // Handle reading extension data from peer.
   void                read_start(int type, uint32_t length, bool skip);
-  void                read_done();
+  bool                read_done();
 
   char*               read_position()                  { return m_readPos; }
@@ -134 +141 @@
   void                reset()                          { std::memset(&m_idMap, 0, sizeof(m_idMap)); }
 
+  bool                request_metadata_piece(const Piece* p);
+
+  // To handle cases where the extension protocol needs to send a reply.
+  bool                has_pending_message() const      { return m_pendingType != HANDSHAKE; }
+  MessageType         pending_message_type() const     { return m_pendingType; }
+  DataBuffer          pending_message_data()           { return m_pending.release(); }
+  void                clear_pending_message()          { if (m_pending.empty()) m_pendingType = HANDSHAKE; }
+
 private:
-  void                parse_handshake();
-  void                parse_ut_pex();
+  bool                parse_handshake();
+  bool                parse_ut_pex();
+  bool                parse_ut_metadata();
 
   static DataBuffer   build_bencode(size_t maxLength, const char* format, ...) ATTRIBUTE_PRINTF(2);
 
   void                peer_toggle_remote(int type, bool active);
+  void                send_metadata_piece(size_t piece);
 
   // Map of IDs peer uses for each extension message type, excluding
@@ -151 +168 @@
   PeerInfo*           m_peerInfo;
   DownloadMain*       m_download;
+  PeerConnectionBase* m_connection;
 
   uint8_t             m_readType;
@@ -156 +174 @@
   char*               m_read;
   char*               m_readPos;
+
+  MessageType         m_pendingType;
+  DataBuffer          m_pending;
 };
 
@@ -164 +185 @@
 enum ext_handshake_keys {
   key_e,
+  key_m_utMetadata,
   key_m_utPex,
+  key_metadataSize,
   key_p,
   key_reqq,
@@ -176 +199 @@
 };
 
+enum ext_metadata_keys {
+  key_msgType,
+  key_piece,
+  key_totalSize,
+  key_metadata_LAST
+};
+
 typedef static_map_type<ext_handshake_keys, key_handshake_LAST> ExtHandshakeMessage;
 typedef static_map_type<ext_pex_keys, key_pex_LAST> ExtPEXMessage;
+typedef static_map_type<ext_metadata_keys, key_metadata_LAST> ExtMetadataMessage;
 
 //
@@ -190 +221 @@
   m_peerInfo(NULL),
   m_download(NULL),
+  m_connection(NULL),
   m_readType(FIRST_INVALID),
-  m_read(NULL) {
+  m_read(NULL),
+  m_pendingType(HANDSHAKE) {
 
   reset();
+  set_local_enabled(UT_METADATA);
 }
 

trunk/libtorrent/src/protocol/handshake.cc

@@ -37 +37 @@
 #include "config.h"
 
-#include "download/download_info.h"
 #include "download/download_main.h"
 #include "net/throttle_list.h"
 #include "torrent/dht_manager.h"
+#include "torrent/download_info.h"
 #include "torrent/exceptions.h"
 #include "torrent/error.h"
@@ -751 +751 @@
     case READ_MESSAGE:
     case POST_HANDSHAKE:
+      // For meta-downloads, we aren't interested in the bitfield or
+      // extension messages here, PCMetadata handles all that. The
+      // bitfield only refers to the single-chunk meta-data, so fake that.
+      if (m_download->info()->is_meta_download()) {
+        m_bitfield.set_size_bits(1);
+        m_bitfield.allocate();
+        m_bitfield.set(0);
+        read_done();
+        break;
+      }
+
       fill_read_buffer(5);
 
@@ -1057 +1068 @@
   m_peerInfo->mutable_id().assign((const char*)m_readBuffer.position());
   m_readBuffer.consume(20);
+
+  // For meta downloads, we require support of the extension protocol.
+  if (m_download->info()->is_meta_download() && !m_peerInfo->supports_extensions())
+    throw handshake_error(ConnectionManager::handshake_dropped, e_handshake_unwanted_connection);
 }
 

trunk/libtorrent/src/protocol/handshake_manager.cc

@@ -41 +41 @@
 #include "torrent/exceptions.h"
 #include "torrent/error.h"
-#include "download/download_info.h"
 #include "download/download_main.h"
 #include "torrent/connection_manager.h"
+#include "torrent/download_info.h"
 #include "torrent/peer/peer_info.h"
 #include "torrent/peer/client_list.h"

trunk/libtorrent/src/protocol/peer_connection_base.cc

@@ -48 +48 @@
 #include "download/chunk_selector.h"
 #include "download/chunk_statistics.h"
-#include "download/download_info.h"
 #include "download/download_main.h"
 #include "net/socket_base.h"
 #include "torrent/connection_manager.h"
+#include "torrent/download_info.h"
 #include "torrent/throttle.h"
 #include "torrent/peer/peer_info.h"
@@ -94 +94 @@
     delete m_extensions;
 
-  if (m_extensionMessage.owned())
-    m_extensionMessage.clear();
+  m_extensionMessage.clear();
 }
 
@@ -116 +115 @@
   m_encryption = *encryptionInfo;
   m_extensions = extensions;
+
+  m_extensions->set_connection(this);
 
   m_peerChunks.set_peer_info(m_peerInfo);
@@ -582 +583 @@
   }
 
-  if (m_extensions->is_complete())
-    m_extensions->read_done();
+  // If extension can't be processed yet (due to a pending write),
+  // disable reads until the pending message is completely sent.
+  if (m_extensions->is_complete() && !m_extensions->is_invalid() && !m_extensions->read_done()) {
+    manager->poll()->remove_read(this);
+    return false;
+  }
 
   return m_extensions->is_complete();
@@ -694 +699 @@
     return false;
 
-  // clear() deletes the buffer, only do that if we made a copy,
-  // otherwise the buffer is shared among all connections.
-  if (m_extensionMessage.owned())
-    m_extensionMessage.clear();
-  else 
-    m_extensionMessage.set(NULL, NULL, false);
+  m_extensionMessage.clear();
+
+  // If we have an unprocessed message, process it now and enable reads again.
+  if (m_extensions->is_complete() && !m_extensions->is_invalid()) {
+    // DEBUG: What, this should fail when we block, no?
+    if (!m_extensions->read_done())
+      throw internal_error("PeerConnectionBase::up_extension could not process complete extension message.");
+
+    manager->poll()->insert_read(this);
+  }
 
   return true;
@@ -858 +867 @@
 }
 
-}
+// Extension protocol needs to send a reply.
+bool
+PeerConnectionBase::send_ext_message() {
+  write_prepare_extension(m_extensions->pending_message_type(), m_extensions->pending_message_data());
+  m_extensions->clear_pending_message();
+  return true;
+}
+
+void
+PeerConnectionBase::receive_metadata_piece(uint32_t piece, const char* data, uint32_t length) {
+}
+
+}

trunk/libtorrent/src/protocol/peer_connection_base.h

@@ -141 +141 @@
   void                write_insert_poll_safe();
 
+  // Communication with the protocol extensions
+  virtual void        receive_metadata_piece(uint32_t piece, const char* data, uint32_t length);
+
 protected:
   static const uint32_t extension_must_encrypt = ~uint32_t();
@@ -180 +183 @@
 
   bool                send_pex_message();
+  bool                send_ext_message();
 
   DownloadMain*       m_download;

trunk/libtorrent/src/protocol/peer_connection_leech.cc

@@ -45 +45 @@
 #include "download/chunk_selector.h"
 #include "download/chunk_statistics.h"
-#include "download/download_info.h"
 #include "download/download_main.h"
 #include "torrent/dht_manager.h"
+#include "torrent/download_info.h"
 #include "torrent/peer/connection_list.h"
 #include "torrent/peer/peer_info.h"
@@ -334 +334 @@
     }
 
-    if (down_extension())
-      m_down->set_state(ProtocolRead::IDLE);
-
+    if (!down_extension())
+      return false;
+
+    if (m_extensions->has_pending_message())
+      write_insert_poll_safe();
+
+    m_down->set_state(ProtocolRead::IDLE);
     return true;
 
@@ -434 +438 @@
           return;
 
+        if (m_extensions->has_pending_message())
+          write_insert_poll_safe();
+
         m_down->set_state(ProtocolRead::IDLE);
         break;
@@ -547 +554 @@
       send_pex_message()) {
     // Don't do anything else if send_pex_message() succeeded.
+
+  } else if (m_extensions->has_pending_message() && m_up->can_write_extension() &&
+             send_ext_message()) {
+    // Same.
 
   } else if (!m_upChoke.choked() &&

trunk/libtorrent/src/protocol/peer_factory.cc

@@ -39 +39 @@
 #include "peer_factory.h"
 #include "peer_connection_leech.h"
+#include "peer_connection_metadata.h"
 
 namespace torrent {
@@ -63 +64 @@
 }
 
+PeerConnectionBase*
+createPeerConnectionMetadata(bool encrypted) {
+  PeerConnectionBase* pc = new PeerConnectionMetadata;
+
+  return pc;
 }
+
+}

trunk/libtorrent/src/protocol/peer_factory.h

@@ -45 +45 @@
 PeerConnectionBase* createPeerConnectionSeed(bool encrypted);
 PeerConnectionBase* createPeerConnectionInitialSeed(bool encrypted);
+PeerConnectionBase* createPeerConnectionMetadata(bool encrypted);
 
 }

trunk/libtorrent/src/torrent/Makefile.am

@@ -17 +17 @@
         download.cc \
         download.h \
+        download_info.h \
         error.cc \
         error.h \
@@ -66 +67 @@
         dht_manager.h \
         download.h \
+        download_info.h \
         error.h \
         exceptions.h \

trunk/libtorrent/src/torrent/data/file_list.cc

@@ -467 +467 @@
   m_isOpen = true;
   m_frozenRootDir = m_rootDir;
+
+  // For meta-downloads, if the file exists, we have to assume that
+  // it is either 0 or 1 length or the correct size. If the size
+  // turns out wrong later, a storage_error will be thrown elsewhere
+  // to alert the user in this (unlikely) case.
+  //
+  // DEBUG: Make this depend on a flag...
+  if (size_bytes() < 2) {
+    rak::file_stat stat;
+
+    // This probably recurses into open() once, but that is harmless.
+    if (stat.update((*begin())->frozen_path()) && stat.size() > 1)
+      return reset_filesize(stat.size());
+  }
 }
 
@@ -662 +676 @@
 }
 
-}
+void
+FileList::reset_filesize(int64_t size) {
+  close();
+  m_chunkSize = size;
+  m_torrentSize = size;
+  (*begin())->set_size_bytes(size);
+  (*begin())->set_range(m_chunkSize);
+  open(open_no_create);
+}
+
+}

trunk/libtorrent/src/torrent/data/file_list.h

@@ -168 +168 @@
   void                update_completed() LIBTORRENT_NO_EXPORT;
 
+  // Used for meta downloads; we only know the
+  // size after the first extension handshake.
+  void                reset_filesize(int64_t) LIBTORRENT_NO_EXPORT;
+
 private:
   bool                open_file(File* node, const Path& lastPath, int flags) LIBTORRENT_NO_EXPORT;

trunk/libtorrent/src/torrent/download.cc

@@ -53 +53 @@
 #include "protocol/peer_connection_base.h"
 #include "protocol/peer_factory.h"
-#include "download/download_info.h"
 #include "peer/peer_info.h"
 #include "tracker/tracker_manager.h"
+#include "torrent/download_info.h"
 #include "torrent/data/file.h"
 #include "torrent/peer/connection_list.h"
@@ -67 +67 @@
 namespace torrent {
 
+const DownloadInfo*
+Download::info() const { return m_ptr->info(); }
+
 void
 Download::open(int flags) {
@@ -124 +127 @@
   if (!(flags & start_keep_baseline)) {
     m_ptr->info()->set_uploaded_baseline(m_ptr->info()->up_rate()->total());
-    m_ptr->info()->set_completed_baseline(m_ptr->info()->slot_completed()());
+    m_ptr->info()->set_completed_baseline(m_ptr->main()->file_list()->completed_bytes());
   }
 
@@ -186 +189 @@
 }
 
-bool
-Download::is_open() const {
-  return m_ptr->info()->is_open();
-}
-
-bool
-Download::is_active() const {
-  return m_ptr->info()->is_active();
-}
+// bool
+// Download::is_open() const {
+//   return m_ptr->info()->is_open();
+// }
+
+// bool
+// Download::is_active() const {
+//   return m_ptr->info()->is_active();
+// }
 
 bool
@@ -206 +209 @@
 }
 
-bool
-Download::is_private() const {
-  return m_ptr->info()->is_private();
-}
-
-bool
-Download::is_pex_active() const {
-  return m_ptr->info()->is_pex_active();
-}
-
-bool
-Download::is_pex_enabled() const {
-  return m_ptr->info()->is_pex_enabled();
-}
+// bool
+// Download::is_private() const {
+//   return m_ptr->info()->is_private();
+// }
+
+// bool
+// Download::is_pex_active() const {
+//   return m_ptr->info()->is_pex_active();
+// }
+
+// bool
+// Download::is_pex_enabled() const {
+//   return m_ptr->info()->is_pex_enabled();
+// }
 
 void
 Download::set_pex_enabled(bool enabled) {
-  m_ptr->info()->set_pex_enabled(enabled);
-}
+  m_ptr->info()->change_flags(DownloadInfo::flag_pex_enabled, enabled);
+}
+
+// bool
+// Download::is_meta_download() const {
+//   return m_ptr->info()->is_meta_download();
+// }
 
 const std::string&
@@ -510 +518 @@
 void
 Download::set_connection_type(ConnectionType t) {
+  if (m_ptr->info()->is_meta_download()) {
+    m_ptr->main()->connection_list()->slot_new_connection(&createPeerConnectionMetadata);
+    return;
+  }
+
   switch (t) {
   case CONNECTION_LEECH:
@@ -518 +531 @@
     break;
   case CONNECTION_INITIAL_SEED:
-    if (is_active() && m_ptr->main()->initial_seeding() == NULL)
+    if (info()->is_active() && m_ptr->main()->initial_seeding() == NULL)
       throw input_error("Can't switch to initial seeding: download is active.");
     m_ptr->main()->connection_list()->slot_new_connection(&createPeerConnectionInitialSeed);

trunk/libtorrent/src/torrent/download.h

@@ -50 +50 @@
 
 class ConnectionList;
+class DownloadInfo;
 
 // Download is safe to copy and destory as it is just a pointer to an
@@ -69 +70 @@
 
   Download(DownloadWrapper* d = NULL) : m_ptr(d) {}
+
+  const DownloadInfo* info() const;
 
   // Not active atm. Opens and prepares/closes the files.
@@ -90 +93 @@
   bool                is_valid() const { return m_ptr; }
 
-  bool                is_open() const;
-  bool                is_active() const;
+//   bool                is_open() const;
+//   bool                is_active() const;
 
   bool                is_hash_checked() const;
   bool                is_hash_checking() const;
 
-  bool                is_private() const;
-  bool                is_pex_active() const;
-  bool                is_pex_enabled() const;
+//   bool                is_private() const;
+//   bool                is_pex_active() const;
+//   bool                is_pex_enabled() const;
   void                set_pex_enabled(bool enabled);
+
+//   bool                is_meta_download() const;
 
   // Returns "" if the object is not valid.
@@ -186 +191 @@
     CONNECTION_SEED,
     CONNECTION_INITIAL_SEED,
+    CONNECTION_METADATA,
   } ConnectionType;
 

trunk/libtorrent/src/torrent/download_info.h

@@ -41 +41 @@
 #include <string>
 #include <inttypes.h>
-#include <rak/functional.h>
 #include <rak/socket_address.h>
-#include <rak/timer.h>
 #include <sigc++/signal.h>
 
-#include "torrent/rate.h"
-#include "torrent/hash_string.h"
+#include <torrent/rate.h>
+#include <torrent/hash_string.h>
 
 namespace torrent {
@@ -53 +51 @@
 class FileList;
 class DownloadMain;
-class Rate;
 
 // This will become a Download 'handle' of kinds.
@@ -59 +56 @@
 class DownloadInfo {
 public:
-  typedef rak::const_mem_fun0<FileList, uint64_t>                      slot_stat_type;
-
+  typedef sigc::slot0<uint64_t>                                        slot_stat_type;
   typedef sigc::signal1<void, const std::string&>                      signal_string_type;
   typedef sigc::signal1<void, uint32_t>                                signal_chunk_type;
@@ -72 +68 @@
   };
 
-  DownloadInfo() :
-    m_isOpen(false),
-    m_isActive(false),
-    m_isCompact(true),
-    m_isAcceptingNewPeers(true),
-    m_isPrivate(false),
-    m_pexEnabled(true),
-    m_pexActive(true),
+  static const int flag_open                = (1 << 0);
+  static const int flag_active              = (1 << 1);
+  static const int flag_compact             = (1 << 2);
+  static const int flag_accepting_new_peers = (1 << 3);
+  static const int flag_private             = (1 << 4);
+  static const int flag_meta_download       = (1 << 5);
+  static const int flag_pex_enabled         = (1 << 6);
+  static const int flag_pex_active          = (1 << 7);
 
-    m_upRate(60),
-    m_downRate(60),
-    m_skipRate(60),
-
-    m_uploadedBaseline(0),
-    m_completedBaseline(0),
-    m_sizePex(0),
-    m_maxSizePex(8),
-
-    m_loadDate(rak::timer::current_seconds()) {
-  }
+  DownloadInfo();
 
   const std::string&  name() const                                 { return m_name; }
@@ -105 +91 @@
   HashString&         mutable_local_id()                           { return m_localId; }
 
-  bool                is_open() const                              { return m_isOpen; }
-  void                set_open(bool s)                             { m_isOpen = s; }
+  bool                is_open() const                              { return m_flags & flag_open; }
+  bool                is_active() const                            { return m_flags & flag_active; }
+  bool                is_compact() const                           { return m_flags & flag_compact; }
+  bool                is_accepting_new_peers() const               { return m_flags & flag_accepting_new_peers; }
+  bool                is_private() const                           { return m_flags & flag_private; }
+  bool                is_meta_download() const                     { return m_flags & flag_meta_download; }
+  bool                is_pex_enabled() const                       { return m_flags & flag_pex_enabled; }
+  bool                is_pex_active() const                        { return m_flags & flag_pex_active; }
 
-  bool                is_active() const                            { return m_isActive; }
-  void                set_active(bool s)                           { m_isActive = s; }
+  void                set_flags(int flags)                         { m_flags |= flags; }
+  void                unset_flags(int flags)                       { m_flags &= ~flags; }
+  void                change_flags(int flags, bool state)          { if (state) set_flags(flags); else unset_flags(flags); }
 
-  bool                is_compact() const                           { return m_isCompact; }
-  void                set_compact(bool s)                          { m_isCompact = s; }
-
-  bool                is_accepting_new_peers() const               { return m_isAcceptingNewPeers; }
-  void                set_accepting_new_peers(bool s)              { m_isAcceptingNewPeers = s; }
-
-  bool                is_private() const                           { return m_isPrivate; }
-  void                set_private(bool p)                          { m_isPrivate = p; if (p) m_pexEnabled = false; }
-
-  bool                is_pex_enabled() const                       { return m_pexEnabled; }
-  void                set_pex_enabled(bool enabled)                { m_pexEnabled = enabled && !m_isPrivate; }
-
-  bool                is_pex_active() const                        { return m_pexActive; }
-  void                set_pex_active(bool active)                  { m_pexActive = active; }
+  void                set_private()                                { set_flags(flag_private); unset_flags(flag_pex_enabled); }
+  void                set_pex_enabled()                            { if (!is_private()) set_flags(flag_pex_enabled); }
 
   Rate*               up_rate()                                    { return &m_upRate; }
@@ -137 +118 @@
   uint64_t            completed_adjusted() const                   { return std::max<int64_t>(m_slotStatCompleted() - completed_baseline(), 0); }
   void                set_completed_baseline(uint64_t b)           { m_completedBaseline = b; }
+
+  size_t              metadata_size() const                        { return m_metadataSize; }
+  void                set_metadata_size(size_t size)               { m_metadataSize = size; }
 
   uint32_t            size_pex() const                             { return m_sizePex; }
@@ -152 +136 @@
   uint32_t            udp_tries() const                            { return 2; }
 
+  slot_stat_type&     slot_left()                                  { return m_slotStatLeft; }
   slot_stat_type&     slot_completed()                             { return m_slotStatCompleted; }
-  slot_stat_type&     slot_left()                                  { return m_slotStatLeft; }
 
   signal_string_type& signal_network_log()                         { return m_signalNetworkLog; }
@@ -165 +149 @@
   HashString          m_localId;
 
-  // TODO: Use flags.
-  bool                m_isOpen;
-  bool                m_isActive;
-  bool                m_isCompact;
-  bool                m_isAcceptingNewPeers;
-  bool                m_isPrivate;
-  bool                m_pexEnabled;
-  bool                m_pexActive;
+  int                 m_flags;
 
   Rate                m_upRate;
@@ -182 +159 @@
   uint32_t            m_sizePex;
   uint32_t            m_maxSizePex;
+  size_t              m_metadataSize;
 
   uint32_t            m_loadDate;
 
+  slot_stat_type      m_slotStatLeft;
   slot_stat_type      m_slotStatCompleted;
-  slot_stat_type      m_slotStatLeft;
 
   signal_string_type  m_signalNetworkLog;
@@ -193 +171 @@
 };
 
-// Move somewhere else.
-struct SocketAddressCompact {
-  SocketAddressCompact() {}
-  SocketAddressCompact(uint32_t a, uint16_t p) : addr(a), port(p) {}
-  SocketAddressCompact(const rak::socket_address_inet* sa) : addr(sa->address_n()), port(sa->port_n()) {}
-
-  operator rak::socket_address () const {
-    rak::socket_address sa;
-    sa.sa_inet()->clear();
-    sa.sa_inet()->set_port_n(port);
-    sa.sa_inet()->set_address_n(addr);
-
-    return sa;
-  }
-
-  uint32_t addr;
-  uint16_t port;
-
-  const char*         c_str() const { return reinterpret_cast<const char*>(this); }
-} __attribute__ ((packed));
-
 }
 

trunk/libtorrent/src/torrent/object_stream.cc

@@ -624 +624 @@
 }
 
+object_buffer_t
+object_write_to_size(void* data, object_buffer_t buffer) {
+  *reinterpret_cast<uint64_t*>(data) += std::distance(buffer.first, buffer.second);
+
+  return buffer;
+}
+
 //
 // static_map operations:

trunk/libtorrent/src/torrent/object_stream.h

@@ -73 +73 @@
 object_buffer_t object_write_to_sha1(void* data, object_buffer_t buffer) LIBTORRENT_EXPORT;
 object_buffer_t object_write_to_stream(void* data, object_buffer_t buffer) LIBTORRENT_EXPORT;
+// Measures bencode size, 'data' is uint64_t*.
+object_buffer_t object_write_to_size(void* data, object_buffer_t buffer) LIBTORRENT_EXPORT;
 
 //

trunk/libtorrent/src/torrent/peer/connection_list.cc

@@ -41 +41 @@
 
 #include "download/choke_manager.h"
-#include "download/download_info.h"
 #include "download/download_main.h"
 #include "net/address_list.h"
 #include "protocol/peer_connection_base.h"
 #include "torrent/exceptions.h"
+#include "torrent/download_info.h"
 
 #include "connection_list.h"
@@ -85 +85 @@
   base_type::push_back(peerConnection);
 
-  m_download->info()->set_accepting_new_peers(size() < m_maxSize);
+  m_download->info()->change_flags(DownloadInfo::flag_accepting_new_peers, size() < m_maxSize);
   m_signalConnected(peerConnection);
 
@@ -104 +104 @@
   base_type::pop_back();
 
-  m_download->info()->set_accepting_new_peers(size() < m_maxSize);
-
+  m_download->info()->change_flags(DownloadInfo::flag_accepting_new_peers, size() < m_maxSize);
   m_signalDisconnected(peerConnection);
 
@@ -144 +143 @@
     erase(--end(), flags);
 
-  m_download->info()->set_accepting_new_peers(size() < m_maxSize);
+  m_download->info()->change_flags(DownloadInfo::flag_accepting_new_peers, size() < m_maxSize);
 }
 
@@ -207 +206 @@
 
   m_maxSize = v;
-  m_download->info()->set_accepting_new_peers(size() < m_maxSize);
+  m_download->info()->change_flags(DownloadInfo::flag_accepting_new_peers, size() < m_maxSize);
   m_download->upload_choke_manager()->balance();
 }

trunk/libtorrent/src/torrent/resume.cc

@@ -40 +40 @@
 #include <rak/socket_address.h>
 
-// For SocketAddressCompact.
-#include "download/download_info.h"
 #include "peer/peer_info.h"
 #include "peer/peer_list.h"
@@ -48 +46 @@
 #include "data/file_list.h"
 #include "data/transfer_list.h"
+#include "net/address_list.h"
 
 #include "common.h"
 #include "bitfield.h"
 #include "download.h"
+#include "download_info.h"
 #include "object.h"
 #include "tracker.h"
@@ -240 +240 @@
       filesItr->insert_key("mtime", (int64_t)fs.modified_time());
 
-    } else if (!download.is_active()) {
+    } else if (!download.info()->is_active()) {
 
       // When stopped, all chunks should have received sync, thus the

trunk/libtorrent/src/torrent/torrent.cc

@@ -321 +321 @@
   ctor.initialize(*object);
 
-  std::string infoHash = object_sha1(&object->get_key("info"));
+  std::string infoHash;
+  if (download->info()->is_meta_download())
+    infoHash = object->get_key("info").get_key("pieces").as_string();
+  else
+    infoHash = object_sha1(&object->get_key("info"));
 
   if (manager->download_manager()->find(infoHash) != manager->download_manager()->end())
     throw input_error("Info hash already used by another torrent.");
+
+  if (!download->info()->is_meta_download()) {
+    char buffer[1024];
+    uint64_t metadata_size = 0;
+    object_write_bencode_c(&object_write_to_size, &metadata_size, object_buffer_t(buffer, buffer + sizeof(buffer)), &object->get_key("info"));
+    download->main()->set_metadata_size(metadata_size);
+  }
 
   download->set_hash_queue(manager->hash_queue());

trunk/libtorrent/src/torrent/tracker_list.cc

@@ -39 +39 @@
 #include <rak/functional.h>
 
-#include "download/download_info.h"
+#include "torrent/download_info.h"
 #include "net/address_list.h"
 #include "tracker/tracker_manager.h"

trunk/libtorrent/src/tracker/tracker_dht.cc

@@ -42 +42 @@
 #include "dht/dht_router.h"
 #include "torrent/connection_manager.h"
+#include "torrent/download_info.h"
 #include "torrent/dht_manager.h"
 #include "torrent/exceptions.h"

trunk/libtorrent/src/tracker/tracker_http.cc

@@ -42 +42 @@
 #include <rak/string_manip.h>
 
-#include "download/download_info.h"
 #include "net/address_list.h"
 #include "torrent/connection_manager.h"
+#include "torrent/download_info.h"
 #include "torrent/exceptions.h"
 #include "torrent/http.h"

trunk/libtorrent/src/tracker/tracker_manager.cc

@@ -37 +37 @@
 #include "config.h"
 
-#include "download/download_info.h"
+#include "torrent/download_info.h"
 #include "torrent/exceptions.h"
 #include "torrent/tracker.h"

trunk/libtorrent/src/tracker/tracker_udp.cc

@@ -43 +43 @@
 #include <cstdio>
 
-#include "download/download_info.h"
 #include "net/address_list.h"
 #include "torrent/exceptions.h"
 #include "torrent/connection_manager.h"
+#include "torrent/download_info.h"
 #include "torrent/poll.h"
 #include "torrent/tracker_list.h"

trunk/rtorrent/src/command_download.cc

@@ -337 +337 @@
   char host[1024];
 
-  if (download->download()->is_private())
+  if (download->download()->info()->is_private())
     throw torrent::input_error("Download is private.");
 
@@ -601 +601 @@
   ADD_CD_STRING("add_peer",        std::ptr_fun(&apply_d_add_peer));
 
-  ADD_CD_VALUE("is_open",          rak::on(std::mem_fun(&core::Download::download), std::mem_fun(&torrent::Download::is_open)));
-  ADD_CD_VALUE("is_active",        rak::on(std::mem_fun(&core::Download::download), std::mem_fun(&torrent::Download::is_active)));
+  ADD_CD_VALUE("is_open",          rak::on(std::mem_fun(&core::Download::info), std::mem_fun(&torrent::DownloadInfo::is_open)));
+  ADD_CD_VALUE("is_active",        rak::on(std::mem_fun(&core::Download::info), std::mem_fun(&torrent::DownloadInfo::is_active)));
   ADD_CD_VALUE("is_hash_checked",  rak::on(std::mem_fun(&core::Download::download), std::mem_fun(&torrent::Download::is_hash_checked)));
   ADD_CD_VALUE("is_hash_checking", rak::on(std::mem_fun(&core::Download::download), std::mem_fun(&torrent::Download::is_hash_checking)));
   ADD_CD_VALUE("is_multi_file",    rak::on(std::mem_fun(&core::Download::file_list), std::mem_fun(&torrent::FileList::is_multi_file)));
-  ADD_CD_VALUE("is_private",       rak::on(std::mem_fun(&core::Download::download), std::mem_fun(&torrent::Download::is_private)));
-  ADD_CD_VALUE("is_pex_active",    rak::on(std::mem_fun(&core::Download::download), std::mem_fun(&torrent::Download::is_pex_active)));
+  ADD_CD_VALUE("is_private",       rak::on(std::mem_fun(&core::Download::info), std::mem_fun(&torrent::DownloadInfo::is_private)));
+  ADD_CD_VALUE("is_pex_active",    rak::on(std::mem_fun(&core::Download::info), std::mem_fun(&torrent::DownloadInfo::is_pex_active)));
 
   ADD_CD_VARIABLE_STRING_PUBLIC("custom1", "rtorrent", "custom1");
@@ -677 +677 @@
   ADD_CD_VALUE_UNI("peers_accounted",     rak::on(std::mem_fun(&core::Download::download), std::mem_fun(&torrent::Download::peers_accounted)));
 
-  ADD_CD_VALUE_MEM_BI("peer_exchange", &core::Download::download, &torrent::Download::set_pex_enabled, &torrent::Download::is_pex_enabled);
-
   ADD_CD_VALUE_MEM_UNI("up_rate",      &torrent::Download::mutable_up_rate, &torrent::Rate::rate);
   ADD_CD_VALUE_MEM_UNI("up_total",     &torrent::Download::mutable_up_rate, &torrent::Rate::total);
@@ -723 +721 @@
   // NEWISH:
   CMD_D_VOID("d.initialize_logs",         &cmd_d_initialize_logs);
-}
+
+  CMD_D_VOID_SLOT("d.peer_exchange",      rak::on(std::mem_fun(&core::Download::info), std::mem_fun(&torrent::DownloadInfo::is_pex_enabled)));
+  CMD_D_VALUE_SLOT("d.peer_exchange.set", rak::on2(std::mem_fun(&core::Download::download), std::mem_fun(&torrent::Download::set_pex_enabled)));
+}

trunk/rtorrent/src/command_helpers.h

@@ -226 +226 @@
   CMD_D_SLOT(key, call_unknown, rpc::object_fn(slot), "i:", "")
 
+#define CMD_D_VOID_SLOT(key, slot) \
+  CMD_D_SLOT(key, call_unknown, rpc::object_void_fn<core::Download*>(slot), "i:", "")
+
+#define CMD_D_VALUE_SLOT(key, slot) \
+  CMD_D_SLOT(key, call_value, rpc::object_value_fn<core::Download*>(slot), "i:i", "")
+
 #define CMD_FUNC_SINGLE(key, command) \
   rpc::commands.insert_type(key, new rpc::CommandFunction(command), &rpc::CommandFunction::call, rpc::CommandMap::flag_public_xmlrpc, NULL, NULL);

trunk/rtorrent/src/core/dht_manager.cc

@@ -195 +195 @@
 
     for (itr = control->core()->download_list()->begin(), end = control->core()->download_list()->end(); itr != end; ++itr)
-      if ((*itr)->is_active() && !(*itr)->download()->is_private())
+      if ((*itr)->download()->info()->is_active() && !(*itr)->download()->info()->is_private())
         break;
       

trunk/rtorrent/src/core/download.cc

@@ -160 +160 @@
 void
 Download::set_throttle_name(const std::string& throttleName) {
-  if (m_download.is_active())
+  if (m_download.info()->is_active())
     throw torrent::input_error("Cannot set throttle on active download.");
 

trunk/rtorrent/src/core/download.h

@@ -40 +40 @@
 #include <sigc++/connection.h>
 #include <torrent/download.h>
+#include <torrent/download_info.h>
 #include <torrent/hash_string.h>
 #include <torrent/tracker_list.h>
@@ -71 +72 @@
   ~Download();
 
-  bool                is_open() const                          { return m_download.is_open(); }
-  bool                is_active() const                        { return m_download.is_active(); }
+  const torrent::DownloadInfo* info() const                             { return m_download.info(); }
+
+  bool                is_open() const                          { return m_download.info()->is_open(); }
+  bool                is_active() const                        { return m_download.info()->is_active(); }
   bool                is_done() const                          { return m_download.file_list()->is_done(); }
   bool                is_downloading() const                   { return is_active() && !is_done(); }
@@ -80 +83 @@
   // return true when the torrent is closed. Remove this redundant
   // test in the next milestone.
-  bool                is_hash_checked() const                  { return m_download.is_open() && m_download.is_hash_checked(); }
+  bool                is_hash_checked() const                  { return is_open() && m_download.is_hash_checked(); }
   bool                is_hash_checking() const                 { return m_download.is_hash_checking(); }
 

trunk/rtorrent/src/core/download_factory.cc

@@ -88 +88 @@
 }
 
+bool
+is_magnet_uri(const std::string& uri) {
+  return
+    std::strncmp(uri.c_str(), "magnet:?", 8) == 0;
+}
+
 DownloadFactory::DownloadFactory(Manager* m) :
   m_manager(m),
@@ -154 +160 @@
     m_variables["tied_to_file"] = (int64_t)false;
 
+  } else if (is_magnet_uri(m_uri)) {
+    // DEBUG: Use m_object.
+    m_stream = new std::stringstream();
+    *m_stream << "d10:magnet-uri" << m_uri.length() << ":" << m_uri << "e";
+
+    m_variables["tied_to_file"] = (int64_t)false;
+    receive_loaded();
+
   } else {
     std::fstream stream(rak::path_expand(m_uri).c_str(), std::ios::in | std::ios::binary);
@@ -204 +218 @@
 
   torrent::Object* root = download->bencode();
+
+  if (download->download()->info()->is_meta_download()) {
+    torrent::Object& meta = root->insert_key("rtorrent_meta_download", torrent::Object::create_map());
+    meta.insert_key("start", m_start);
+    meta.insert_key("print_log", m_printLog);
+ 
+    torrent::Object::list_type& commands = meta.insert_key("commands", torrent::Object::create_list()).as_list();
+
+    for (command_list_type::iterator itr = m_commands.begin(); itr != m_commands.end(); ++itr)
+      commands.push_back(*itr);
+  }
 
   if (m_session) {
@@ -261 +286 @@
 
   if (!m_session && m_variables["tied_to_file"].as_value())
-    rpc::call_command("d.set_tied_to_file", m_uri, rpc::make_target(download));
-
-  rpc::call_command("d.set_peer_exchange", rpc::call_command_value("get_peer_exchange"), rpc::make_target(download));
+    rpc::call_command("d.set_tied_to_file", m_uri.empty() ? m_variables["tied_file"] : m_uri, rpc::make_target(download));
+
+  rpc::call_command("d.peer_exchange.set", rpc::call_command_value("get_peer_exchange"), rpc::make_target(download));
 
   torrent::resume_load_addresses(*download->download(), resumeObject);

trunk/rtorrent/src/core/download_factory.h

@@ -114 +114 @@
 
 bool is_network_uri(const std::string& uri);
+bool is_magnet_uri(const std::string& uri);
 
 }

trunk/rtorrent/src/core/download_list.cc

@@ -38 +38 @@
 
 #include <algorithm>
+#include <fstream>
 #include <iostream>
 #include <sigc++/adaptors/bind.h>
 #include <rak/functional.h>
 #include <rak/string_manip.h>
+#include <torrent/data/file.h>
 #include <torrent/exceptions.h>
 #include <torrent/download.h>
@@ -237 +239 @@
   check_contains(download);
 
-  if (download->download()->is_open())
+  if (download->download()->info()->is_open())
     return;
   
@@ -262 +264 @@
 void
 DownloadList::close_directly(Download* download) {
-  if (download->download()->is_active()) {
+  if (download->download()->info()->is_active()) {
     download->download()->stop(torrent::Download::stop_skip_tracker);
 
@@ -269 +271 @@
   }
 
-  if (download->download()->is_open())
+  if (download->download()->info()->is_open())
     download->download()->close();
 }
@@ -321 +323 @@
   try {
 
-    if (download->download()->is_active())
+    if (download->download()->info()->is_active())
       return;
 
@@ -370 +372 @@
 
     // If the DHT server is set to auto, start it now.
-    if (!download->download()->is_private())
+    if (!download->download()->info()->is_private())
       control->dht_manager()->auto_start();
 
@@ -406 +408 @@
     }
 
-    if (!download->download()->is_active())
+    if (!download->download()->info()->is_active())
       return;
 
@@ -475 +477 @@
   int64_t hashing = rpc::call_command_value("d.get_hashing", rpc::make_target(download));
   rpc::call_command_set_value("d.set_hashing", Download::variable_hashing_stopped, rpc::make_target(download));
+
+  if (download->is_done() && download->download()->info()->is_meta_download())
+    return process_meta_download(download);
 
   switch (hashing) {
@@ -567 +572 @@
   check_contains(download);
 
+  if (download->download()->info()->is_meta_download())
+    return process_meta_download(download);
+
   rpc::call_command("d.set_complete", (int64_t)1, rpc::make_target(download));
 
@@ -600 +608 @@
 }
 
-}
+void
+DownloadList::process_meta_download(Download* download) {
+  rpc::call_command("d.stop", torrent::Object(), rpc::make_target(download));
+  rpc::call_command("d.close", torrent::Object(), rpc::make_target(download));
+
+  std::string metafile = (*download->file_list()->begin())->frozen_path();
+  std::fstream file(metafile.c_str(), std::ios::in | std::ios::binary);
+  if (!file.is_open()) {
+    control->core()->push_log("Could not read download metadata.");
+    return;
+  }
+
+  torrent::Object* bencode = new torrent::Object(torrent::Object::create_map());
+  file >> bencode->insert_key("info", torrent::Object());
+  if (file.fail()) {
+    delete bencode;
+    control->core()->push_log("Could not create download, the input is not a valid torrent.");
+    return;
+  }
+  file.close();
+
+  // Steal the keys we still need. The old download has no use for them.
+  bencode->insert_key("rtorrent_meta_download", torrent::Object()).swap(download->bencode()->get_key("rtorrent_meta_download"));
+  if (download->bencode()->has_key("announce"))
+    bencode->insert_key("announce", torrent::Object()).swap(download->bencode()->get_key("announce"));
+  if (download->bencode()->has_key("announce-list"))
+    bencode->insert_key("announce-list", torrent::Object()).swap(download->bencode()->get_key("announce-list"));
+
+  erase_ptr(download);
+  control->core()->try_create_download_from_meta_download(bencode, metafile);
+}
+
+}

trunk/rtorrent/src/core/download_list.h

@@ -163 +163 @@
   void                received_finished(Download* d);
   void                confirm_finished(Download* d);
+
+  void                process_meta_download(Download* d);
 };
 

trunk/rtorrent/src/core/manager.cc

@@ -40 +40 @@
 #include <cstring>
 #include <fstream>
+#include <sstream>
 #include <unistd.h>
 #include <sys/select.h>
@@ -53 +54 @@
 #include <torrent/error.h>
 #include <torrent/exceptions.h>
+#include <torrent/object_stream.h>
 #include <torrent/resume.h>
 #include <torrent/tracker_list.h>
@@ -396 +398 @@
       !(flags & create_raw_data) &&
       !is_network_uri(uri) &&
+      !is_magnet_uri(uri) &&
       !file_status_cache()->insert(uri, 0))
     return;
@@ -414 +417 @@
     f->load(uri);
 
+  f->commit();
+}
+
+void
+Manager::try_create_download_from_meta_download(torrent::Object* bencode, const std::string& metafile) {
+  DownloadFactory* f = new DownloadFactory(this);
+
+  f->variables()["tied_to_file"] = (int64_t)true;
+  f->variables()["tied_file"] = metafile;
+
+  torrent::Object& meta = bencode->get_key("rtorrent_meta_download");
+  torrent::Object::list_type& commands = meta.get_key_list("commands");
+  for (torrent::Object::list_type::const_iterator itr = commands.begin(); itr != commands.end(); ++itr)
+    f->commands().insert(f->commands().end(), itr->as_string());
+
+  f->set_start(meta.get_key_value("start"));
+  f->set_print_log(meta.get_key_value("print_log"));
+  f->slot_finished(sigc::bind(sigc::ptr_fun(&rak::call_delete_func<core::DownloadFactory>), f));
+
+  // Bit of a waste to create the bencode repesentation here
+  // only to have the DownloadFactory decode it.
+  std::stringstream s;
+  s.imbue(std::locale::classic());
+  s << *bencode;
+  f->load_raw_data(s.str());
   f->commit();
 }

trunk/rtorrent/src/core/manager.h

@@ -129 +129 @@
   void                try_create_download(const std::string& uri, int flags, const command_list_type& commands);
   void                try_create_download_expand(const std::string& uri, int flags, command_list_type commands = command_list_type());
+  void                try_create_download_from_meta_download(torrent::Object* bencode, const std::string& metafile);
 
 private:

trunk/rtorrent/src/display/utils.cc

@@ -133 +133 @@
 char*
 print_download_info(char* first, char* last, core::Download* d) {
-  if (!d->download()->is_open())
+  if (!d->download()->info()->is_open())
     first = print_buffer(first, last, "[CLOSED]  ");
-  else if (!d->download()->is_active())
+  else if (!d->download()->info()->is_active())
     first = print_buffer(first, last, "[OPEN]    ");
   else
@@ -152 +152 @@
                        (double)d->download()->up_rate()->total() / (1 << 20));
 
-  if (d->download()->is_active() && !d->is_done()) {
+  if (d->download()->info()->is_active() && !d->is_done()) {
     first = print_buffer(first, last, " ");
     first = print_download_percentage_done(first, last, d);

trunk/rtorrent/src/main.cc

@@ -87 +87 @@
     optionParser.insert_flag('h', sigc::ptr_fun(&print_help));
     optionParser.insert_flag('n', OptionParser::Slot());
+    optionParser.insert_flag('D', OptionParser::Slot());
 
     optionParser.insert_option('b', sigc::bind<0>(sigc::ptr_fun(&rpc::call_command_set_string), "bind"));
@@ -303 +304 @@
 
     // Deprecated commands. Don't use these anymore.
+
+    if (!OptionParser::has_flag('D', argc, argv)) {
 
     rpc::parse_command_multiple
@@ -348 +351 @@
        "method.insert = get_max_memory_usage,redirect|const,pieces.memory.max\n"
        "method.insert = set_max_memory_usage,redirect|const,pieces.memory.max.set\n"
+
+       "method.insert = d.get_peer_exchange,redirect|const,d.peer_exchange\n"
     );
+
+    }
 
     if (OptionParser::has_flag('n', argc, argv))

trunk/rtorrent/src/ui/download.cc

@@ -164 +164 @@
   element->push_column("Chunks:",           te_command("cat=$d.get_completed_chunks=,\" / \",$d.get_size_chunks=,\" * \",$d.get_chunk_size="));
   element->push_column("Priority:",         te_command("d.get_priority="));
-  element->push_column("Peer exchange:",    te_command("cat=$if=$d.get_peer_exchange=\\,enabled\\,disabled,\\ ,"
+  element->push_column("Peer exchange:",    te_command("cat=$if=$d.peer_exchange=\\,enabled\\,disabled,\\ ,"
                                                        "$if=$d.is_pex_active=\\,active\\,$d.is_private=\\,private\\,inactive,"
                                                        "\\ (,$d.get_size_pex=,/,$d.get_max_size_pex=,)"));