Changeset 3740

Timestamp:

08/23/08 08:09:52 (5 months ago)

Author:

andar

Message:

lt sync 2626

Location:

branches/1.0.0_RC/libtorrent

Files:

• bindings/python/src/torrent_handle.cpp (modified) (3 diffs)
• include/libtorrent/alert.hpp (modified) (1 diff)
• include/libtorrent/alert_types.hpp (modified) (1 diff)
• include/libtorrent/bencode.hpp (modified) (1 diff)
• include/libtorrent/pe_crypto.hpp (modified) (2 diffs)
• include/libtorrent/torrent.hpp (modified) (2 diffs)
• src/bt_peer_connection.cpp (modified) (3 diffs)
• src/identify_client.cpp (modified) (4 diffs)
• src/kademlia/dht_tracker.cpp (modified) (1 diff)
• src/lazy_bdecode.cpp (modified) (1 diff)
• src/natpmp.cpp (modified) (4 diffs)
• src/pe_crypto.cpp (modified) (2 diffs)
• src/peer_connection.cpp (modified) (4 diffs)
• src/storage.cpp (modified) (2 diffs)
• src/torrent.cpp (modified) (6 diffs)
• src/torrent_handle.cpp (modified) (1 diff)

branches/1.0.0_RC/libtorrent/bindings/python/src/torrent_handle.cpp

@@ -5 +5 @@
 #include <libtorrent/torrent_handle.hpp>
 #include <boost/python.hpp>
+#include <boost/python/tuple.hpp>
 #include <boost/lexical_cast.hpp>
 #include "gil.hpp"
@@ -171 +172 @@
 list get_download_queue(torrent_handle& handle)
 {
+    using boost::python::make_tuple;
+
     list ret;
 
@@ -194 +197 @@
             block_info["bytes_progress"] = i->blocks[k].bytes_progress;
             block_info["block_size"] = i->blocks[k].block_size;
-            block_info["peer"] = std::make_pair(
+            block_info["peer"] = make_tuple(
                 boost::lexical_cast<std::string>(i->blocks[k].peer.address()), i->blocks[k].peer.port());
             block_list.append(block_info);

branches/1.0.0_RC/libtorrent/include/libtorrent/alert.hpp

@@ -83 +83 @@
                         progress_notification = 0x80,
                         ip_block_notification = 0x100,
+                        performance_warning = 0x200,
 
                         all_categories = 0xffffffff

branches/1.0.0_RC/libtorrent/include/libtorrent/alert_types.hpp

@@ -152 +152 @@
         };
 
+        struct TORRENT_EXPORT performance_alert: torrent_alert
+        {
+                enum performance_warning_t
+                {
+                        outstanding_disk_buffer_limit_reached,
+                        outstanding_request_limit_reached,
+                };
+
+                performance_alert(torrent_handle const& h
+                        , performance_warning_t w)
+                        : torrent_alert(h)
+                        , warning_code(w)
+                {}
+
+                virtual std::auto_ptr<alert> clone() const
+                { return std::auto_ptr<alert>(new performance_alert(*this)); }
+
+                virtual char const* what() const { return "performance warning"; }
+                virtual std::string message() const
+                {
+                        static char const* warning_str[] =
+                        {
+                                "max outstanding disk writes reached",
+                                "max outstanding piece requests reached",
+                        };
+
+                        return torrent_alert::message() + ": performance warning: "
+                                + warning_str[warning_code];
+                }
+
+                const static int static_category = alert::performance_warning;
+                virtual int category() const { return static_category; }
+
+                performance_warning_t warning_code;
+        };
+
         struct TORRENT_EXPORT state_changed_alert: torrent_alert
         {

branches/1.0.0_RC/libtorrent/include/libtorrent/bencode.hpp

@@ -106 +106 @@
                 int write_string(OutIt& out, const std::string& val)
                 {
-                        int ret = val.length();
-                        std::string::const_iterator end = val.begin() + ret;
                         for (std::string::const_iterator i = val.begin()
-                                , end(val.begin() + ret); i != end; ++i)
+                                , end(val.end()); i != end; ++i)
                                 *out++ = *i;
-                        return ret;
+                        return val.length();
                 }
 

branches/1.0.0_RC/libtorrent/include/libtorrent/pe_crypto.hpp

@@ -59 +59 @@
                 int compute_secret(const char* remote_pubkey);
 
-                const char* get_secret() const;
+                char const* get_secret() const { return m_dh_secret; }
+
+                sha1_hash const& get_hash_xor_mask() const { return m_xor_mask; }
                 
         private:
@@ -72 +74 @@
                 char m_dh_local_key[96];
                 char m_dh_secret[96];
+                sha1_hash m_xor_mask;
         };
         

branches/1.0.0_RC/libtorrent/include/libtorrent/torrent.hpp

@@ -132 +132 @@
 
                 void parse_resume_data(std::vector<char>* resume_data);
+
+#ifndef TORRENT_DISABLE_ENCRYPTION
+                sha1_hash const& obfuscated_hash() const
+                { return m_obfuscated_hash; }
+#endif
+
+                sha1_hash const& info_hash() const
+                { return m_torrent_file->info_hash(); }
 
                 // starts the announce timer
@@ -822 +830 @@
                 boost::scoped_ptr<std::string> m_name;
 
+#ifndef TORRENT_DISABLE_ENCRYPTION
+                // this is SHA1("req2" + info-hash), used for
+                // encrypted hand shakes
+                sha1_hash m_obfuscated_hash;
+#endif
                 session_settings const& m_settings;
 

branches/1.0.0_RC/libtorrent/src/bt_peer_connection.cpp

@@ -1842 +1842 @@
                                 }
 
-                                cut_receive_buffer(bytes_processed, (std::min)(packet_size(), (512+20) - m_sync_bytes_read));
+                                cut_receive_buffer(bytes_processed, (std::min)(packet_size()
+                                        , (512+20) - m_sync_bytes_read));
 
                                 TORRENT_ASSERT(!packet_finished());
@@ -1873 +1874 @@
                         recv_buffer = receive_buffer();
 
-                        // only calls info_hash() on the torrent_handle's, which
-                        // never throws.
-                        session_impl::mutex_t::scoped_lock l(m_ses.m_mutex);
-                        
-                        std::vector<torrent_handle> active_torrents = m_ses.get_torrents();
-                        std::vector<torrent_handle>::const_iterator i;
-                        hasher h;
-                        sha1_hash skey_hash, obfs_hash;
-
-                        for (i = active_torrents.begin(); i != active_torrents.end(); ++i)
-                        {
-                                torrent_handle const& t_h = *i; // TODO possible errors
-                                sha1_hash const& info_hash = t_h.info_hash();
-                                // TODO Does info_hash need to be checked for validity?
-                                
-                                h.reset();
-                                h.update("req2", 4);
-                                h.update((char*)info_hash.begin(), 20);
-
-                            skey_hash = h.final();
-                                
-                                h.reset();
-                                h.update("req3", 4);
-                                h.update(m_dh_key_exchange->get_secret(), dh_key_len);
-
-                                obfs_hash = h.final();
+                        aux::session_impl::torrent_map::const_iterator i;
+
+                        for (i = m_ses.m_torrents.begin(); i != m_ses.m_torrents.end(); ++i)
+                        {
+                                torrent const& ti = *i->second;
+                                sha1_hash const& skey_hash = ti.obfuscated_hash();
+                                sha1_hash obfs_hash = m_dh_key_exchange->get_hash_xor_mask();
                                 obfs_hash ^= skey_hash;
 
-                                if (std::equal (recv_buffer.begin, recv_buffer.begin + 20,
-                                        (char*)obfs_hash.begin()))
+                                if (std::equal(recv_buffer.begin, recv_buffer.begin + 20,
+                                        (char*)&obfs_hash[0]))
                                 {
                                         if (!t)
                                         {
-                                                attach_to_torrent(info_hash);
+                                                attach_to_torrent(ti.info_hash());
                                                 if (is_disconnecting()) return;
 
@@ -1913 +1895 @@
                                         }
 
-                                        init_pe_RC4_handler(m_dh_key_exchange->get_secret(), info_hash);
+                                        init_pe_RC4_handler(m_dh_key_exchange->get_secret(), ti.info_hash());
 #ifdef TORRENT_VERBOSE_LOGGING
                                         (*m_logger) << " stream key found, torrent located.\n";
 #endif
-                                        continue; // TODO Check flow control with multiple torrents
+                                        break;
                                 }
                         }

branches/1.0.0_RC/libtorrent/src/identify_client.cpp

@@ -60 +60 @@
         }
 
+        bool isprint(char c)
+        {
+                return c >= 32 && c < 127;
+        }
+
         // takes a peer id and returns a valid boost::optional
         // object if the peer id matched the azureus style encoding
@@ -68 +73 @@
                 fingerprint ret("..", 0, 0, 0, 0);
 
-                if (id[0] != '-' || !std::isprint(id[1]) || (id[2] < '0')
+                if (id[0] != '-' || !isprint(id[1]) || (id[2] < '0')
                         || (id[3] < '0') || (id[4] < '0')
                         || (id[5] < '0') || (id[6] < '0')
@@ -130 +135 @@
                 if (sscanf(ids, "%c%d-%d-%d--", &ret.name[0], &ret.major_version, &ret.minor_version
                         , &ret.revision_version) != 4
-                        || !std::isprint(ret.name[0]))
+                        || !isprint(ret.name[0]))
                         return boost::optional<fingerprint>();
 
@@ -374 +379 @@
                 for (peer_id::const_iterator i = p.begin(); i != p.end(); ++i)
                 {
-                        unknown += std::isprint(*i)?*i:'.';
+                        unknown += isprint(*i)?*i:'.';
                 }
                 unknown += "]";

branches/1.0.0_RC/libtorrent/src/kademlia/dht_tracker.cpp

@@ -449 +449 @@
 #ifdef TORRENT_DHT_VERBOSE_LOGGING
                                 std::string msg(buf, buf + bytes_transferred);
-                                TORRENT_LOG(dht_tracker) << "invalid incoming packet: "
-                                        << e.what() << "\n" << msg << "\n";
+                                TORRENT_LOG(dht_tracker) << "invalid incoming packet\n";
 #endif
                                 return;

branches/1.0.0_RC/libtorrent/src/lazy_bdecode.cpp

@@ -377 +377 @@
                                 {
                                         using namespace std;
-                                        if (isprint(str[i])) continue;
+                                        if (isprint((unsigned char)str[i])) continue;
                                         printable = false;
                                         break;

branches/1.0.0_RC/libtorrent/src/natpmp.cpp

@@ -106 +106 @@
         }
 
+        m_socket.async_receive_from(asio::buffer(&m_response_buffer, 16)
+                , m_remote, bind(&natpmp::on_reply, self(), _1, _2));
+
         for (std::vector<mapping_t>::iterator i = m_mappings.begin()
                 , end(m_mappings.end()); i != end; ++i)
@@ -238 +241 @@
                 m_retry_count = 0;
                 send_map_request(i);
-                m_socket.async_receive_from(asio::buffer(&m_response_buffer, 16)
-                        , m_remote, bind(&natpmp::on_reply, self(), _1, _2));
         }
 }
@@ -282 +283 @@
 {
         if (e) return;
-        if (m_abort) return;
-
         mutex_t::scoped_lock l(m_mutex);
         if (m_currently_mapping != i) return;
-        if (m_retry_count >= 9)
+
+        // if we're shutting down, don't retry, just move on
+        // to the next mapping
+        if (m_retry_count >= 9 || m_abort)
         {
                 m_currently_mapping = -1;
@@ -302 +304 @@
 {
         using namespace libtorrent::detail;
-        if (e) return;
+        if (e)
+        {
+#if defined(TORRENT_LOGGING) || defined(TORRENT_VERBOSE_LOGGING)
+                m_log << time_now_string()
+                        << " <== on_receive ["
+                        " error: " << e.message() << " ]" << std::endl;
+#endif
+                return;
+        }
+
+        m_socket.async_receive_from(asio::buffer(&m_response_buffer, 16)
+                , m_remote, bind(&natpmp::on_reply, self(), _1, _2));
 
         if (m_remote != m_nat_endpoint)
         {
-                m_socket.async_receive_from(asio::buffer(&m_response_buffer, 16)
-                        , m_remote, bind(&natpmp::on_reply, self(), _1, _2));
+#if defined(TORRENT_LOGGING) || defined(TORRENT_VERBOSE_LOGGING)
+                m_log << time_now_string()
+                        << " <== received packet from the wrong IP ["
+                        " ip: " << m_remote << " ]" << std::endl;
+#endif
                 return;
         }

branches/1.0.0_RC/libtorrent/src/pe_crypto.cpp

@@ -39 +39 @@
 
 #include "libtorrent/pe_crypto.hpp"
+#include "libtorrent/hasher.hpp"
 #include "libtorrent/assert.hpp"
 
@@ -145 +146 @@
                 std::copy(dh_secret, dh_secret + secret_size, m_dh_secret + 96 - secret_size);
                 BN_free(bn_remote_pubkey);
+
+                // calculate the xor mask for the obfuscated hash
+                hasher h;
+                h.update("req3", 4);
+                h.update(m_dh_secret, 96);
+                m_xor_mask = h.final();
+
                 return 0;
-        }
-
-        char const* dh_key_exchange::get_secret() const
-        {
-                return m_dh_secret;
         }
 

branches/1.0.0_RC/libtorrent/src/peer_connection.cpp

@@ -1644 +1644 @@
                 m_download_queue.erase(b);
 
+                if (m_outstanding_writing_bytes >= m_ses.settings().max_outstanding_disk_bytes_per_connection
+                        && t->alerts().should_post<performance_alert>())
+                {
+                        t->alerts().post_alert(performance_alert(t->get_handle()
+                                , performance_alert::outstanding_disk_buffer_limit_reached));
+                }
+
                 if (!m_download_queue.empty())
                 {
@@ -2766 +2773 @@
                         if (m_desired_queue_size < min_request_queue)
                                 m_desired_queue_size = min_request_queue;
+
+                        if (m_desired_queue_size == m_max_out_request_queue 
+                                && t->alerts().should_post<performance_alert>())
+                        {
+                                t->alerts().post_alert(performance_alert(t->get_handle()
+                                        , performance_alert::outstanding_request_limit_reached));
+                        }
                 }
 
@@ -3633 +3647 @@
                 }
 
+/*
+                // this assertion correct most of the time, but sometimes right when the
+                // limit is changed it might break
                 for (int i = 0; i < 2; ++i)
                 {
@@ -3640 +3657 @@
                                 || m_bandwidth_limit[i].throttle() == bandwidth_limit::inf);
                 }
+*/
 
                 if (m_channel_state[download_channel] == peer_info::bw_torrent

branches/1.0.0_RC/libtorrent/src/storage.cpp

@@ -529 +529 @@
                         // don't allocate files with priority 0
                         int file_index = file_iter - files().begin();
-                        if (allocate_files && (m_file_priority.size() <= file_index
+                        if (allocate_files && (int(m_file_priority.size()) <= file_index
                                 || m_file_priority[file_index] > 0))
                         {
@@ -2170 +2170 @@
                                 (file_offset - current_offset + m_files.piece_length() - 1)
                                 / m_files.piece_length());
+                        TORRENT_ASSERT(skip_blocks >= 1);
 
                         if (m_storage_mode == storage_mode_compact)

branches/1.0.0_RC/libtorrent/src/torrent.cpp

@@ -207 +207 @@
         {
                 parse_resume_data(resume_data);
+
+#ifndef TORRENT_DISABLE_ENCRYPTION
+                hasher h;
+                h.update("req2", 4);
+                h.update((char*)&tf->info_hash()[0], 20);
+                m_obfuscated_hash = h.final();
+#endif
         }
 
@@ -281 +288 @@
         {
                 parse_resume_data(resume_data);
+
+#ifndef TORRENT_DISABLE_ENCRYPTION
+                hasher h;
+                h.update("req2", 4);
+                h.update((char*)&info_hash[0], 20);
+                m_obfuscated_hash = h.final();
+#endif
+
 #ifndef NDEBUG
                 m_files_checked = false;
@@ -1472 +1487 @@
                                 if (m_ses.m_alerts.should_post<peer_ban_alert>())
                                 {
-                                        peer_id pid;
+                                        peer_id pid(0);
                                         if (p->connection) pid = p->connection->pid();
                                         m_ses.m_alerts.post_alert(peer_ban_alert(
@@ -2262 +2277 @@
         
                 bool ret = instantiate_connection(m_ses.m_io_service, m_ses.web_seed_proxy(), *s);
+                (void)ret;
                 TORRENT_ASSERT(ret);
 
@@ -2776 +2792 @@
 
                 bool ret = instantiate_connection(m_ses.m_io_service, m_ses.peer_proxy(), *s);
+                (void)ret;
                 TORRENT_ASSERT(ret);
                 std::pair<int, int> const& out_ports = m_ses.settings().outgoing_ports;
@@ -3524 +3541 @@
         void torrent::set_sequential_download(bool sd)
         {
+                m_sequential_download = sd;
                 if (has_picker())
                 {
                         picker().sequential_download(sd);
-                }
-                else
-                {
-                        m_sequential_download = sd;
                 }
         }

branches/1.0.0_RC/libtorrent/src/torrent_handle.cpp

@@ -251 +251 @@
         {
                 INVARIANT_CHECK;
-                TORRENT_FORWARD_RETURN(is_paused(), false);
+                TORRENT_FORWARD_RETURN(is_torrent_paused(), false);
         }