src/bt_peer_connection.cpp

   1 /*
   2
   3 Copyright (c) 2003 - 2006, Arvid Norberg
   4 Copyright (c) 2007, Arvid Norberg, Un Shyam
   5 All rights reserved.
   6
   7 Redistribution and use in source and binary forms, with or without
   8 modification, are permitted provided that the following conditions
   9 are met:
  10
  11     * Redistributions of source code must retain the above copyright
  12       notice, this list of conditions and the following disclaimer.
  13     * Redistributions in binary form must reproduce the above copyright
  14       notice, this list of conditions and the following disclaimer in
  15       the documentation and/or other materials provided with the distribution.
  16     * Neither the name of the author nor the names of its
  17       contributors may be used to endorse or promote products derived
  18       from this software without specific prior written permission.
  19
  20 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  24 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30 POSSIBILITY OF SUCH DAMAGE.
  31
  32 */
  33
  34 #include "libtorrent/pch.hpp"
  35
  36 #include <vector>
  37 #include <iostream>
  38 #include <iomanip>
  39 #include <limits>
  40 #include <boost/bind.hpp>
  41
  42 #include "libtorrent/bt_peer_connection.hpp"
  43 #include "libtorrent/session.hpp"
  44 #include "libtorrent/identify_client.hpp"
  45 #include "libtorrent/entry.hpp"
  46 #include "libtorrent/bencode.hpp"
  47 #include "libtorrent/alert_types.hpp"
  48 #include "libtorrent/invariant_check.hpp"
  49 #include "libtorrent/io.hpp"
  50 #include "libtorrent/version.hpp"
  51 #include "libtorrent/extensions.hpp"
  52 #include "libtorrent/aux_/session_impl.hpp"
  53
  54 #ifndef TORRENT_DISABLE_ENCRYPTION
  55 #include "libtorrent/pe_crypto.hpp"
  56 #include "libtorrent/hasher.hpp"
  57 #endif
  58
  59 using boost::bind;
  60 using boost::shared_ptr;
  61 using libtorrent::aux::session_impl;
  62
  63 namespace libtorrent
  64 {
  65         const bt_peer_connection::message_handler
  66         bt_peer_connection::m_message_handler[] =
  67         {
  68                 &bt_peer_connection::on_choke,
  69                 &bt_peer_connection::on_unchoke,
  70                 &bt_peer_connection::on_interested,
  71                 &bt_peer_connection::on_not_interested,
  72                 &bt_peer_connection::on_have,
  73                 &bt_peer_connection::on_bitfield,
  74                 &bt_peer_connection::on_request,
  75                 &bt_peer_connection::on_piece,
  76                 &bt_peer_connection::on_cancel,
  77                 &bt_peer_connection::on_dht_port,
  78                 0, 0, 0,
  79                 // FAST extension messages
  80                 &bt_peer_connection::on_suggest_piece,
  81                 &bt_peer_connection::on_have_all,
  82                 &bt_peer_connection::on_have_none,
  83                 &bt_peer_connection::on_reject_request,
  84                 &bt_peer_connection::on_allowed_fast,
  85                 0, 0,
  86                 &bt_peer_connection::on_extended
  87         };
  88
  89
  90         bt_peer_connection::bt_peer_connection(
  91                 session_impl& ses
  92                 , boost::weak_ptr<torrent> tor
  93                 , shared_ptr<socket_type> s
  94                 , tcp::endpoint const& remote
  95                 , policy::peer* peerinfo)
  96                 : peer_connection(ses, tor, s, remote
  97                         , peerinfo)
  98                 , m_state(read_protocol_identifier)
  99 #ifndef TORRENT_DISABLE_EXTENSIONS
 100                 , m_supports_extensions(false)
 101 #endif
 102                 , m_supports_dht_port(false)
 103                 , m_supports_fast(false)
 104 #ifndef TORRENT_DISABLE_ENCRYPTION
 105                 , m_encrypted(false)
 106                 , m_rc4_encrypted(false)
 107                 , m_sync_bytes_read(0)
 108                 , m_enc_send_buffer(0, 0)
 109 #endif
 110 #ifndef NDEBUG
 111                 , m_sent_bitfield(false)
 112                 , m_in_constructor(true)
 113                 , m_sent_handshake(false)
 114 #endif
 115         {
 116 #ifdef TORRENT_VERBOSE_LOGGING
 117                 (*m_logger) << "*** bt_peer_connection\n";
 118 #endif
 119
 120 #ifndef NDEBUG
 121                 m_in_constructor = false;
 122 #endif
 123         }
 124
 125         bt_peer_connection::bt_peer_connection(
 126                 session_impl& ses
 127                 , boost::shared_ptr<socket_type> s
 128                 , tcp::endpoint const& remote
 129                 , policy::peer* peerinfo)
 130                 : peer_connection(ses, s, remote, peerinfo)
 131                 , m_state(read_protocol_identifier)
 132 #ifndef TORRENT_DISABLE_EXTENSIONS
 133                 , m_supports_extensions(false)
 134 #endif
 135                 , m_supports_dht_port(false)
 136                 , m_supports_fast(false)
 137 #ifndef TORRENT_DISABLE_ENCRYPTION
 138                 , m_encrypted(false)
 139                 , m_rc4_encrypted(false)
 140                 , m_sync_bytes_read(0)
 141                 , m_enc_send_buffer(0, 0)
 142 #endif
 143 #ifndef NDEBUG
 144                 , m_sent_bitfield(false)
 145                 , m_in_constructor(true)
 146                 , m_sent_handshake(false)
 147 #endif
 148         {
 149
 150                 // we are not attached to any torrent yet.
 151                 // we have to wait for the handshake to see
 152                 // which torrent the connector want's to connect to
 153
 154
 155                 // upload bandwidth will only be given to connections
 156                 // that are part of a torrent. Since this is an incoming
 157                 // connection, we have to give it some initial bandwidth
 158                 // to send the handshake.
 159 #ifndef TORRENT_DISABLE_ENCRYPTION
 160                 m_bandwidth_limit[download_channel].assign(2048);
 161                 m_bandwidth_limit[upload_channel].assign(2048);
 162 #else
 163                 m_bandwidth_limit[download_channel].assign(80);
 164                 m_bandwidth_limit[upload_channel].assign(80);
 165 #endif
 166
 167 #ifndef NDEBUG
 168                 m_in_constructor = false;
 169 #endif
 170         }
 171
 172         void bt_peer_connection::start()
 173         {
 174                 peer_connection::start();
 175
 176                 // start in the state where we are trying to read the
 177                 // handshake from the other side
 178                 reset_recv_buffer(20);
 179                 setup_receive();
 180         }
 181
 182         bt_peer_connection::~bt_peer_connection()
 183         {
 184         }
 185
 186         void bt_peer_connection::on_connected()
 187         {
 188 #ifndef TORRENT_DISABLE_ENCRYPTION
 189
 190                 pe_settings::enc_policy const& out_enc_policy = m_ses.get_pe_settings().out_enc_policy;
 191
 192                 if (out_enc_policy == pe_settings::forced)
 193                 {
 194                         write_pe1_2_dhkey();
 195                         if (is_disconnecting()) return;
 196
 197                         m_state = read_pe_dhkey;
 198                         reset_recv_buffer(dh_key_len);
 199                         setup_receive();
 200                 }
 201                 else if (out_enc_policy == pe_settings::enabled)
 202                 {
 203                         TORRENT_ASSERT(peer_info_struct());
 204
 205                         policy::peer* pi = peer_info_struct();
 206                         if (pi->pe_support == true)
 207                         {
 208                                 // toggle encryption support flag, toggled back to
 209                                 // true if encrypted portion of the handshake
 210                                 // completes correctly
 211                                 pi->pe_support = false;
 212
 213                                 // if this fails, we need to reconnect
 214                                 // fast.
 215                                 fast_reconnect(true);
 216
 217                                 write_pe1_2_dhkey();
 218                                 if (is_disconnecting()) return;
 219                                 m_state = read_pe_dhkey;
 220                                 reset_recv_buffer(dh_key_len);
 221                                 setup_receive();
 222                         }
 223                         else // pi->pe_support == false
 224                         {
 225                                 // toggled back to false if standard handshake
 226                                 // completes correctly (without encryption)
 227                                 pi->pe_support = true;
 228
 229                                 write_handshake();
 230                                 reset_recv_buffer(20);
 231                                 setup_receive();
 232                         }
 233                 }
 234                 else if (out_enc_policy == pe_settings::disabled)
 235 #endif
 236                 {
 237                         write_handshake();
 238
 239                         // start in the state where we are trying to read the
 240                         // handshake from the other side
 241                         reset_recv_buffer(20);
 242                         setup_receive();
 243                 }
 244         }
 245
 246         void bt_peer_connection::on_metadata()
 247         {
 248                 boost::shared_ptr<torrent> t = associated_torrent().lock();
 249                 TORRENT_ASSERT(t);
 250                 write_bitfield();
 251 #ifndef TORRENT_DISABLE_DHT
 252                 if (m_supports_dht_port && m_ses.m_dht)
 253                         write_dht_port(m_ses.get_dht_settings().service_port);
 254 #endif
 255         }
 256
 257         void bt_peer_connection::write_dht_port(int listen_port)
 258         {
 259                 INVARIANT_CHECK;
 260
 261                 TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield);
 262
 263 #ifdef TORRENT_VERBOSE_LOGGING
 264                 (*m_logger) << time_now_string()
 265                         << " ==> DHT_PORT [ " << listen_port << " ]\n";
 266 #endif
 267                 char msg[] = {0,0,0,3, msg_dht_port, 0, 0};
 268                 char* ptr = msg + 5;
 269                 detail::write_uint16(listen_port, ptr);
 270                 send_buffer(msg, sizeof(msg));
 271         }
 272
 273         void bt_peer_connection::write_have_all()
 274         {
 275                 INVARIANT_CHECK;
 276                 TORRENT_ASSERT(m_sent_handshake && !m_sent_bitfield);
 277 #ifndef NDEBUG
 278                 m_sent_bitfield = true;
 279 #endif
 280 #ifdef TORRENT_VERBOSE_LOGGING
 281                 (*m_logger) << time_now_string()
 282                         << " ==> HAVE_ALL\n";
 283 #endif
 284                 char msg[] = {0,0,0,1, msg_have_all};
 285                 send_buffer(msg, sizeof(msg));
 286         }
 287
 288         void bt_peer_connection::write_have_none()
 289         {
 290                 INVARIANT_CHECK;
 291                 TORRENT_ASSERT(m_sent_handshake && !m_sent_bitfield);
 292 #ifndef NDEBUG
 293                 m_sent_bitfield = true;
 294 #endif
 295 #ifdef TORRENT_VERBOSE_LOGGING
 296                 (*m_logger) << time_now_string()
 297                         << " ==> HAVE_NONE\n";
 298 #endif
 299                 char msg[] = {0,0,0,1, msg_have_none};
 300                 send_buffer(msg, sizeof(msg));
 301         }
 302
 303         void bt_peer_connection::write_reject_request(peer_request const& r)
 304         {
 305                 INVARIANT_CHECK;
 306
 307                 if (!m_supports_fast) return;
 308
 309                 TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield);
 310                 TORRENT_ASSERT(associated_torrent().lock()->valid_metadata());
 311
 312                 char msg[] = {0,0,0,13, msg_reject_request,0,0,0,0, 0,0,0,0, 0,0,0,0};
 313                 char* ptr = msg + 5;
 314                 detail::write_int32(r.piece, ptr); // index
 315                 detail::write_int32(r.start, ptr); // begin
 316                 detail::write_int32(r.length, ptr); // length
 317                 send_buffer(msg, sizeof(msg));
 318         }
 319
 320         void bt_peer_connection::write_allow_fast(int piece)
 321         {
 322                 INVARIANT_CHECK;
 323
 324                 TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield);
 325                 TORRENT_ASSERT(associated_torrent().lock()->valid_metadata());
 326                 TORRENT_ASSERT(m_supports_fast);
 327
 328                 char msg[] = {0,0,0,5, msg_allowed_fast, 0, 0, 0, 0};
 329                 char* ptr = msg + 5;
 330                 detail::write_int32(piece, ptr);
 331                 send_buffer(msg, sizeof(msg));
 332         }
 333
 334         void bt_peer_connection::get_specific_peer_info(peer_info& p) const
 335         {
 336                 TORRENT_ASSERT(!associated_torrent().expired());
 337
 338                 if (is_interesting()) p.flags |= peer_info::interesting;
 339                 if (is_choked()) p.flags |= peer_info::choked;
 340                 if (is_peer_interested()) p.flags |= peer_info::remote_interested;
 341                 if (has_peer_choked()) p.flags |= peer_info::remote_choked;
 342                 if (support_extensions()) p.flags |= peer_info::supports_extensions;
 343                 if (is_local()) p.flags |= peer_info::local_connection;
 344
 345 #ifndef TORRENT_DISABLE_ENCRYPTION
 346                 if (m_encrypted)
 347                 {
 348                         m_rc4_encrypted ?
 349                                 p.flags |= peer_info::rc4_encrypted :
 350                                 p.flags |= peer_info::plaintext_encrypted;
 351                 }
 352 #endif
 353
 354                 if (!is_connecting() && in_handshake())
 355                         p.flags |= peer_info::handshake;
 356                 if (is_connecting() && !is_queued()) p.flags |= peer_info::connecting;
 357                 if (is_queued()) p.flags |= peer_info::queued;
 358
 359                 p.client = m_client_version;
 360                 p.connection_type = peer_info::standard_bittorrent;
 361
 362         }
 363
 364         bool bt_peer_connection::in_handshake() const
 365         {
 366                 return m_state < read_packet_size;
 367         }
 368
 369 #ifndef TORRENT_DISABLE_ENCRYPTION
 370
 371         void bt_peer_connection::write_pe1_2_dhkey()
 372         {
 373                 INVARIANT_CHECK;
 374
 375                 TORRENT_ASSERT(!m_encrypted);
 376                 TORRENT_ASSERT(!m_rc4_encrypted);
 377                 TORRENT_ASSERT(!m_dh_key_exchange.get());
 378                 TORRENT_ASSERT(!m_sent_handshake);
 379
 380 #ifdef TORRENT_VERBOSE_LOGGING
 381                 if (is_local())
 382                         (*m_logger) << " initiating encrypted handshake\n";
 383 #endif
 384
 385                 m_dh_key_exchange.reset(new (std::nothrow) dh_key_exchange);
 386                 if (!m_dh_key_exchange || !m_dh_key_exchange->good())
 387                 {
 388                         disconnect("out of memory");
 389                         return;
 390                 }
 391
 392                 int pad_size = std::rand() % 512;
 393
 394 #ifdef TORRENT_VERBOSE_LOGGING
 395                 (*m_logger) << " pad size: " << pad_size << "\n";
 396 #endif
 397
 398                 buffer::interval send_buf = allocate_send_buffer(dh_key_len + pad_size);
 399                 if (send_buf.begin == 0)
 400                 {
 401                         disconnect("out of memory");
 402                         return;
 403                 }
 404
 405                 std::copy(m_dh_key_exchange->get_local_key(),
 406                         m_dh_key_exchange->get_local_key() + dh_key_len,
 407                         send_buf.begin);
 408
 409                 std::generate(send_buf.begin + dh_key_len, send_buf.end, std::rand);
 410                 setup_send();
 411
 412 #ifdef TORRENT_VERBOSE_LOGGING
 413                 (*m_logger) << " sent DH key\n";
 414 #endif
 415         }
 416
 417         void bt_peer_connection::write_pe3_sync()
 418         {
 419                 INVARIANT_CHECK;
 420
 421                 TORRENT_ASSERT(!m_encrypted);
 422                 TORRENT_ASSERT(!m_rc4_encrypted);
 423                 TORRENT_ASSERT(is_local());
 424                 TORRENT_ASSERT(!m_sent_handshake);
 425
 426                 boost::shared_ptr<torrent> t = associated_torrent().lock();
 427                 TORRENT_ASSERT(t);
 428
 429                 hasher h;
 430                 sha1_hash const& info_hash = t->torrent_file().info_hash();
 431                 char const* const secret = m_dh_key_exchange->get_secret();
 432
 433                 int pad_size = rand() % 512;
 434
 435                 // synchash,skeyhash,vc,crypto_provide,len(pad),pad,len(ia)
 436                 buffer::interval send_buf =
 437                         allocate_send_buffer(20 + 20 + 8 + 4 + 2 + pad_size + 2);
 438                 if (send_buf.begin == 0) return; // out of memory
 439
 440                 // sync hash (hash('req1',S))
 441                 h.reset();
 442                 h.update("req1",4);
 443                 h.update(secret, dh_key_len);
 444                 sha1_hash sync_hash = h.final();
 445
 446                 std::copy(sync_hash.begin(), sync_hash.end(), send_buf.begin);
 447                 send_buf.begin += 20;
 448
 449                 // stream key obfuscated hash [ hash('req2',SKEY) xor hash('req3',S) ]
 450                 h.reset();
 451                 h.update("req2",4);
 452                 h.update((const char*)info_hash.begin(), 20);
 453                 sha1_hash streamkey_hash = h.final();
 454
 455                 h.reset();
 456                 h.update("req3",4);
 457                 h.update(secret, dh_key_len);
 458                 sha1_hash obfsc_hash = h.final();
 459                 obfsc_hash ^= streamkey_hash;
 460
 461                 std::copy(obfsc_hash.begin(), obfsc_hash.end(), send_buf.begin);
 462                 send_buf.begin += 20;
 463
 464                 // Discard DH key exchange data, setup RC4 keys
 465                 init_pe_RC4_handler(secret, info_hash);
 466                 m_dh_key_exchange.reset(); // secret should be invalid at this point
 467
 468                 // write the verification constant and crypto field
 469                 TORRENT_ASSERT(send_buf.left() == 8 + 4 + 2 + pad_size + 2);
 470                 int encrypt_size = send_buf.left();
 471
 472                 int crypto_provide = 0;
 473                 pe_settings::enc_level const& allowed_enc_level = m_ses.get_pe_settings().allowed_enc_level;
 474
 475                 if (allowed_enc_level == pe_settings::both)
 476                         crypto_provide = 0x03;
 477                 else if (allowed_enc_level == pe_settings::rc4)
 478                         crypto_provide = 0x02;
 479                 else if (allowed_enc_level == pe_settings::plaintext)
 480                         crypto_provide = 0x01;
 481
 482 #ifdef TORRENT_VERBOSE_LOGGING
 483                 (*m_logger) << " crypto provide : [ ";
 484                 if (allowed_enc_level == pe_settings::both)
 485                         (*m_logger) << "plaintext rc4 ]\n";
 486                 else if (allowed_enc_level == pe_settings::rc4)
 487                         (*m_logger) << "rc4 ]\n";
 488                 else if (allowed_enc_level == pe_settings::plaintext)
 489                         (*m_logger) << "plaintext ]\n";
 490 #endif
 491
 492                 write_pe_vc_cryptofield(send_buf, crypto_provide, pad_size);
 493                 m_RC4_handler->encrypt(send_buf.end - encrypt_size, encrypt_size);
 494
 495                 TORRENT_ASSERT(send_buf.begin == send_buf.end);
 496                 setup_send();
 497         }
 498
 499         void bt_peer_connection::write_pe4_sync(int crypto_select)
 500         {
 501                 INVARIANT_CHECK;
 502
 503                 TORRENT_ASSERT(!is_local());
 504                 TORRENT_ASSERT(!m_encrypted);
 505                 TORRENT_ASSERT(!m_rc4_encrypted);
 506                 TORRENT_ASSERT(crypto_select == 0x02 || crypto_select == 0x01);
 507                 TORRENT_ASSERT(!m_sent_handshake);
 508
 509                 int pad_size =rand() % 512;
 510
 511                 const int buf_size = 8 + 4 + 2 + pad_size;
 512                 buffer::interval send_buf = allocate_send_buffer(buf_size);
 513                 if (send_buf.begin == 0) return; // out of memory
 514                 write_pe_vc_cryptofield(send_buf, crypto_select, pad_size);
 515
 516                 m_RC4_handler->encrypt(send_buf.end - buf_size, buf_size);
 517                 setup_send();
 518
 519                 // encryption method has been negotiated
 520                 if (crypto_select == 0x02)
 521                         m_rc4_encrypted = true;
 522                 else // 0x01
 523                         m_rc4_encrypted = false;
 524
 525 #ifdef TORRENT_VERBOSE_LOGGING
 526                 (*m_logger) << " crypto select : [ ";
 527                 if (crypto_select == 0x01)
 528                         (*m_logger) << "plaintext ]\n";
 529                 else
 530                         (*m_logger) << "rc4 ]\n";
 531 #endif
 532         }
 533
 534         void bt_peer_connection::write_pe_vc_cryptofield(buffer::interval& write_buf
 535                 , int crypto_field, int pad_size)
 536         {
 537                 INVARIANT_CHECK;
 538
 539                 TORRENT_ASSERT(crypto_field <= 0x03 && crypto_field > 0);
 540                 // vc,crypto_field,len(pad),pad, (len(ia))
 541                 TORRENT_ASSERT( (write_buf.left() == 8+4+2+pad_size+2 && is_local()) ||
 542                                 (write_buf.left() == 8+4+2+pad_size   && !is_local()) );
 543                 TORRENT_ASSERT(!m_sent_handshake);
 544
 545                 // encrypt(vc, crypto_provide/select, len(Pad), len(IA))
 546                 // len(pad) is zero for now, len(IA) only for outgoing connections
 547
 548                 // vc
 549                 std::fill(write_buf.begin, write_buf.begin + 8, 0);
 550                 write_buf.begin += 8;
 551
 552                 detail::write_uint32(crypto_field, write_buf.begin);
 553                 detail::write_uint16(pad_size, write_buf.begin); // len (pad)
 554
 555                 // fill pad with zeroes
 556                 std::generate(write_buf.begin, write_buf.begin + pad_size, &std::rand);
 557                 write_buf.begin += pad_size;
 558
 559                 // append len(ia) if we are initiating
 560                 if (is_local())
 561                         detail::write_uint16(handshake_len, write_buf.begin); // len(IA)
 562
 563                 TORRENT_ASSERT(write_buf.begin == write_buf.end);
 564         }
 565
 566         void bt_peer_connection::init_pe_RC4_handler(char const* secret, sha1_hash const& stream_key)
 567         {
 568                 INVARIANT_CHECK;
 569
 570                 TORRENT_ASSERT(secret);
 571
 572                 hasher h;
 573                 static const char keyA[] = "keyA";
 574                 static const char keyB[] = "keyB";
 575
 576                 // encryption rc4 longkeys
 577                 // outgoing connection : hash ('keyA',S,SKEY)
 578                 // incoming connection : hash ('keyB',S,SKEY)
 579
 580                 is_local() ? h.update(keyA, 4) : h.update(keyB, 4);
 581                 h.update(secret, dh_key_len);
 582                 h.update((char const*)stream_key.begin(), 20);
 583                 const sha1_hash local_key = h.final();
 584
 585                 h.reset();
 586
 587                 // decryption rc4 longkeys
 588                 // outgoing connection : hash ('keyB',S,SKEY)
 589                 // incoming connection : hash ('keyA',S,SKEY)
 590
 591                 is_local() ? h.update(keyB, 4) : h.update(keyA, 4);
 592                 h.update(secret, dh_key_len);
 593                 h.update((char const*)stream_key.begin(), 20);
 594                 const sha1_hash remote_key = h.final();
 595
 596                 TORRENT_ASSERT(!m_RC4_handler.get());
 597                 m_RC4_handler.reset(new RC4_handler (local_key, remote_key));
 598
 599 #ifdef TORRENT_VERBOSE_LOGGING
 600                 (*m_logger) << " computed RC4 keys\n";
 601 #endif
 602         }
 603
 604         void bt_peer_connection::send_buffer(char* buf, int size, int flags)
 605         {
 606                 TORRENT_ASSERT(buf);
 607                 TORRENT_ASSERT(size > 0);
 608
 609                 if (m_encrypted && m_rc4_encrypted)
 610                         m_RC4_handler->encrypt(buf, size);
 611
 612                 peer_connection::send_buffer(buf, size, flags);
 613         }
 614
 615         buffer::interval bt_peer_connection::allocate_send_buffer(int size)
 616         {
 617                 if (m_encrypted && m_rc4_encrypted)
 618                 {
 619                         TORRENT_ASSERT(m_enc_send_buffer.left() == 0);
 620                         m_enc_send_buffer = peer_connection::allocate_send_buffer(size);
 621                         return m_enc_send_buffer;
 622                 }
 623                 else
 624                 {
 625                         buffer::interval i = peer_connection::allocate_send_buffer(size);
 626                         return i;
 627                 }
 628         }
 629
 630         void bt_peer_connection::setup_send()
 631         {
 632                 if (m_encrypted && m_rc4_encrypted && m_enc_send_buffer.left())
 633                 {
 634                         TORRENT_ASSERT(m_enc_send_buffer.begin);
 635                         TORRENT_ASSERT(m_enc_send_buffer.end);
 636
 637                         m_RC4_handler->encrypt(m_enc_send_buffer.begin, m_enc_send_buffer.left());
 638                         m_enc_send_buffer.end = m_enc_send_buffer.begin;
 639                 }
 640                 peer_connection::setup_send();
 641         }
 642
 643         int bt_peer_connection::get_syncoffset(char const* src, int src_size,
 644                 char const* target, int target_size) const
 645         {
 646                 TORRENT_ASSERT(target_size >= src_size);
 647                 TORRENT_ASSERT(src_size > 0);
 648                 TORRENT_ASSERT(src);
 649                 TORRENT_ASSERT(target);
 650
 651                 int traverse_limit = target_size - src_size;
 652
 653                 // TODO: this could be optimized using knuth morris pratt
 654                 for (int i = 0; i < traverse_limit; ++i)
 655                 {
 656                         char const* target_ptr = target + i;
 657                         if (std::equal(src, src+src_size, target_ptr))
 658                                 return i;
 659                 }
 660
 661 //          // Partial sync
 662 //              for (int i = 0; i < target_size; ++i)
 663 //              {
 664 //                      // first is iterator in src[] at which mismatch occurs
 665 //                      // second is iterator in target[] at which mismatch occurs
 666 //                      std::pair<const char*, const char*> ret;
 667 //                      int src_sync_size;
 668 //                      if (i > traverse_limit) // partial sync test
 669 //                      {
 670 //                              ret = std::mismatch(src, src + src_size - (i - traverse_limit), &target[i]);
 671 //                              src_sync_size = ret.first - src;
 672 //                              if (src_sync_size == (src_size - (i - traverse_limit)))
 673 //                                      return i;
 674 //                      }
 675 //                      else // complete sync test
 676 //                      {
 677 //                              ret = std::mismatch(src, src + src_size, &target[i]);
 678 //                              src_sync_size = ret.first - src;
 679 //                              if (src_sync_size == src_size)
 680 //                                      return i;
 681 //                      }
 682 //              }
 683
 684         // no complete sync
 685                 return -1;
 686         }
 687 #endif // #ifndef TORRENT_DISABLE_ENCRYPTION
 688
 689         void bt_peer_connection::write_handshake()
 690         {
 691                 INVARIANT_CHECK;
 692
 693                 TORRENT_ASSERT(!m_sent_handshake);
 694 #ifndef NDEBUG
 695                 m_sent_handshake = true;
 696 #endif
 697
 698                 boost::shared_ptr<torrent> t = associated_torrent().lock();
 699                 TORRENT_ASSERT(t);
 700
 701                 // add handshake to the send buffer
 702                 const char version_string[] = "BitTorrent protocol";
 703                 const int string_len = sizeof(version_string)-1;
 704
 705                 buffer::interval i = allocate_send_buffer(1 + string_len + 8 + 20 + 20);
 706                 if (i.begin == 0) return; // out of memory
 707                 // length of version string
 708                 *i.begin = string_len;
 709                 ++i.begin;
 710
 711                 // version string itself
 712                 std::copy(
 713                         version_string
 714                         , version_string + string_len
 715                         , i.begin);
 716                 i.begin += string_len;
 717
 718                 // 8 zeroes
 719                 std::fill(i.begin, i.begin + 8, 0);
 720
 721 #ifndef TORRENT_DISABLE_DHT
 722                 // indicate that we support the DHT messages
 723                 *(i.begin + 7) |= 0x01;
 724 #endif
 725
 726 #ifndef TORRENT_DISABLE_EXTENSIONS
 727                 // we support extensions
 728                 *(i.begin + 5) |= 0x10;
 729 #endif
 730
 731                 // we support FAST extension
 732                 *(i.begin + 7) |= 0x04;
 733
 734                 i.begin += 8;
 735
 736                 // info hash
 737                 sha1_hash const& ih = t->torrent_file().info_hash();
 738                 std::copy(ih.begin(), ih.end(), i.begin);
 739                 i.begin += 20;
 740
 741                 // peer id
 742                 std::copy(
 743                         m_ses.get_peer_id().begin()
 744                         , m_ses.get_peer_id().end()
 745                         , i.begin);
 746                 i.begin += 20;
 747                 TORRENT_ASSERT(i.begin == i.end);
 748
 749 #ifdef TORRENT_VERBOSE_LOGGING
 750                 (*m_logger) << time_now_string() << " ==> HANDSHAKE\n";
 751 #endif
 752                 setup_send();
 753         }
 754
 755         boost::optional<piece_block_progress> bt_peer_connection::downloading_piece_progress() const
 756         {
 757                 boost::shared_ptr<torrent> t = associated_torrent().lock();
 758                 TORRENT_ASSERT(t);
 759
 760                 buffer::const_interval recv_buffer = receive_buffer();
 761                 // are we currently receiving a 'piece' message?
 762                 if (m_state != read_packet
 763                         || recv_buffer.left() < 9
 764                         || recv_buffer[0] != msg_piece)
 765                         return boost::optional<piece_block_progress>();
 766
 767                 const char* ptr = recv_buffer.begin + 1;
 768                 peer_request r;
 769                 r.piece = detail::read_int32(ptr);
 770                 r.start = detail::read_int32(ptr);
 771                 r.length = packet_size() - 9;
 772
 773                 // is any of the piece message header data invalid?
 774                 if (!verify_piece(r))
 775                         return boost::optional<piece_block_progress>();
 776
 777                 piece_block_progress p;
 778
 779                 p.piece_index = r.piece;
 780                 p.block_index = r.start / t->block_size();
 781                 p.bytes_downloaded = recv_buffer.left() - 9;
 782                 p.full_block_bytes = r.length;
 783
 784                 return boost::optional<piece_block_progress>(p);
 785         }
 786
 787
 788         // message handlers
 789
 790         // -----------------------------
 791         // --------- KEEPALIVE ---------
 792         // -----------------------------
 793
 794         void bt_peer_connection::on_keepalive()
 795         {
 796                 INVARIANT_CHECK;
 797
 798 #ifdef TORRENT_VERBOSE_LOGGING
 799                 (*m_logger) << time_now_string() << " <== KEEPALIVE\n";
 800 #endif
 801                 incoming_keepalive();
 802         }
 803
 804         // -----------------------------
 805         // ----------- CHOKE -----------
 806         // -----------------------------
 807
 808         void bt_peer_connection::on_choke(int received)
 809         {
 810                 INVARIANT_CHECK;
 811
 812                 TORRENT_ASSERT(received > 0);
 813                 if (packet_size() != 1)
 814                 {
 815                         disconnect("'choke' message size != 1", 2);
 816                         return;
 817                 }
 818                 m_statistics.received_bytes(0, received);
 819                 if (!packet_finished()) return;
 820
 821                 incoming_choke();
 822                 if (is_disconnecting()) return;
 823                 if (!m_supports_fast)
 824                 {
 825                         boost::shared_ptr<torrent> t = associated_torrent().lock();
 826                         TORRENT_ASSERT(t);
 827                         while (!download_queue().empty())
 828                         {
 829                                 piece_block const& b = download_queue().front().block;
 830                                 peer_request r;
 831                                 r.piece = b.piece_index;
 832                                 r.start = b.block_index * t->block_size();
 833                                 r.length = t->block_size();
 834                                 incoming_reject_request(r);
 835                         }
 836                 }
 837         }
 838
 839         // -----------------------------
 840         // ---------- UNCHOKE ----------
 841         // -----------------------------
 842
 843         void bt_peer_connection::on_unchoke(int received)
 844         {
 845                 INVARIANT_CHECK;
 846
 847                 TORRENT_ASSERT(received > 0);
 848                 if (packet_size() != 1)
 849                 {
 850                         disconnect("'unchoke' message size != 1", 2);
 851                         return;
 852                 }
 853                 m_statistics.received_bytes(0, received);
 854                 if (!packet_finished()) return;
 855
 856                 incoming_unchoke();
 857         }
 858
 859         // -----------------------------
 860         // -------- INTERESTED ---------
 861         // -----------------------------
 862
 863         void bt_peer_connection::on_interested(int received)
 864         {
 865                 INVARIANT_CHECK;
 866
 867                 TORRENT_ASSERT(received > 0);
 868                 if (packet_size() != 1)
 869                 {
 870                         disconnect("'interested' message size != 1", 2);
 871                         return;
 872                 }
 873                 m_statistics.received_bytes(0, received);
 874                 if (!packet_finished()) return;
 875
 876                 incoming_interested();
 877         }
 878
 879         // -----------------------------
 880         // ------ NOT INTERESTED -------
 881         // -----------------------------
 882
 883         void bt_peer_connection::on_not_interested(int received)
 884         {
 885                 INVARIANT_CHECK;
 886
 887                 TORRENT_ASSERT(received > 0);
 888                 if (packet_size() != 1)
 889                 {
 890                         disconnect("'not interested' message size != 1", 2);
 891                         return;
 892                 }
 893                 m_statistics.received_bytes(0, received);
 894                 if (!packet_finished()) return;
 895
 896                 incoming_not_interested();
 897         }
 898
 899         // -----------------------------
 900         // ----------- HAVE ------------
 901         // -----------------------------
 902
 903         void bt_peer_connection::on_have(int received)
 904         {
 905                 INVARIANT_CHECK;
 906
 907                 TORRENT_ASSERT(received > 0);
 908                 if (packet_size() != 5)
 909                 {
 910                         disconnect("'have' message size != 5", 2);
 911                         return;
 912                 }
 913                 m_statistics.received_bytes(0, received);
 914                 if (!packet_finished()) return;
 915
 916                 buffer::const_interval recv_buffer = receive_buffer();
 917
 918                 const char* ptr = recv_buffer.begin + 1;
 919                 int index = detail::read_int32(ptr);
 920
 921                 incoming_have(index);
 922         }
 923
 924         // -----------------------------
 925         // --------- BITFIELD ----------
 926         // -----------------------------
 927
 928         void bt_peer_connection::on_bitfield(int received)
 929         {
 930                 INVARIANT_CHECK;
 931
 932                 TORRENT_ASSERT(received > 0);
 933
 934                 boost::shared_ptr<torrent> t = associated_torrent().lock();
 935                 TORRENT_ASSERT(t);
 936
 937                 // if we don't have the metedata, we cannot
 938                 // verify the bitfield size
 939                 if (t->valid_metadata()
 940                         && packet_size() - 1 != ((int)get_bitfield().size() + 7) / 8)
 941                 {
 942                         disconnect("bitfield with invalid size", 2);
 943                         return;
 944                 }
 945
 946                 m_statistics.received_bytes(0, received);
 947                 if (!packet_finished()) return;
 948
 949                 buffer::const_interval recv_buffer = receive_buffer();
 950
 951                 bitfield bits;
 952                 bits.borrow_bytes((char*)recv_buffer.begin + 1
 953                         , t->valid_metadata()?get_bitfield().size():(packet_size()-1)*8);
 954
 955                 incoming_bitfield(bits);
 956         }
 957
 958         // -----------------------------
 959         // ---------- REQUEST ----------
 960         // -----------------------------
 961
 962         void bt_peer_connection::on_request(int received)
 963         {
 964                 INVARIANT_CHECK;
 965
 966                 TORRENT_ASSERT(received > 0);
 967                 if (packet_size() != 13)
 968                 {
 969                         disconnect("'request' message size != 13", 2);
 970                         return;
 971                 }
 972                 m_statistics.received_bytes(0, received);
 973                 if (!packet_finished()) return;
 974
 975                 buffer::const_interval recv_buffer = receive_buffer();
 976
 977                 peer_request r;
 978                 const char* ptr = recv_buffer.begin + 1;
 979                 r.piece = detail::read_int32(ptr);
 980                 r.start = detail::read_int32(ptr);
 981                 r.length = detail::read_int32(ptr);
 982
 983                 incoming_request(r);
 984         }
 985
 986         // -----------------------------
 987         // ----------- PIECE -----------
 988         // -----------------------------
 989
 990         void bt_peer_connection::on_piece(int received)
 991         {
 992                 INVARIANT_CHECK;
 993
 994                 TORRENT_ASSERT(received > 0);
 995
 996                 buffer::const_interval recv_buffer = receive_buffer();
 997                 int recv_pos = recv_buffer.end - recv_buffer.begin;
 998
 999                 if (recv_pos == 1)
1000                 {
1001                         TORRENT_ASSERT(!has_disk_receive_buffer());
1002                         if (!allocate_disk_receive_buffer(packet_size() - 9))
1003                                 return;
1004                 }
1005                 TORRENT_ASSERT(has_disk_receive_buffer());
1006
1007                 // classify the received data as protocol chatter
1008                 // or data payload for the statistics
1009                 if (recv_pos <= 9)
1010                         // only received protocol data
1011                         m_statistics.received_bytes(0, received);
1012                 else if (recv_pos - received >= 9)
1013                         // only received payload data
1014                         m_statistics.received_bytes(received, 0);
1015                 else
1016                 {
1017                         // received a bit of both
1018                         TORRENT_ASSERT(recv_pos - received < 9);
1019                         TORRENT_ASSERT(recv_pos > 9);
1020                         TORRENT_ASSERT(9 - (recv_pos - received) <= 9);
1021                         m_statistics.received_bytes(
1022                                 recv_pos - 9
1023                                 , 9 - (recv_pos - received));
1024                 }
1025
1026                 incoming_piece_fragment();
1027                 if (is_disconnecting()) return;
1028                 if (!packet_finished()) return;
1029
1030                 const char* ptr = recv_buffer.begin + 1;
1031                 peer_request p;
1032                 p.piece = detail::read_int32(ptr);
1033                 p.start = detail::read_int32(ptr);
1034                 p.length = packet_size() - 9;
1035
1036                 disk_buffer_holder holder(m_ses, release_disk_receive_buffer());
1037                 incoming_piece(p, holder);
1038         }
1039
1040         // -----------------------------
1041         // ---------- CANCEL -----------
1042         // -----------------------------
1043
1044         void bt_peer_connection::on_cancel(int received)
1045         {
1046                 INVARIANT_CHECK;
1047
1048                 TORRENT_ASSERT(received > 0);
1049                 if (packet_size() != 13)
1050                 {
1051                         disconnect("'cancel' message size != 13", 2);
1052                         return;
1053                 }
1054                 m_statistics.received_bytes(0, received);
1055                 if (!packet_finished()) return;
1056
1057                 buffer::const_interval recv_buffer = receive_buffer();
1058
1059                 peer_request r;
1060                 const char* ptr = recv_buffer.begin + 1;
1061                 r.piece = detail::read_int32(ptr);
1062                 r.start = detail::read_int32(ptr);
1063                 r.length = detail::read_int32(ptr);
1064
1065                 incoming_cancel(r);
1066         }
1067
1068         // -----------------------------
1069         // --------- DHT PORT ----------
1070         // -----------------------------
1071
1072         void bt_peer_connection::on_dht_port(int received)
1073         {
1074                 INVARIANT_CHECK;
1075
1076                 if (!m_supports_dht_port)
1077                 {
1078                         disconnect("got 'dht_port' message from peer that doesn't support it", 2);
1079                         return;
1080                 }
1081
1082                 TORRENT_ASSERT(received > 0);
1083                 if (packet_size() != 3)
1084                 {
1085                         disconnect("'dht_port' message size != 3", 2);
1086                         return;
1087                 }
1088                 m_statistics.received_bytes(0, received);
1089                 if (!packet_finished()) return;
1090
1091                 buffer::const_interval recv_buffer = receive_buffer();
1092
1093                 const char* ptr = recv_buffer.begin + 1;
1094                 int listen_port = detail::read_uint16(ptr);
1095
1096                 incoming_dht_port(listen_port);
1097         }
1098
1099         void bt_peer_connection::on_suggest_piece(int received)
1100         {
1101                 INVARIANT_CHECK;
1102
1103                 if (!m_supports_fast)
1104                 {
1105                         disconnect("got 'suggest_piece' without FAST excension support", 2);
1106                         return;
1107                 }
1108
1109                 m_statistics.received_bytes(0, received);
1110                 if (!packet_finished()) return;
1111
1112                 buffer::const_interval recv_buffer = receive_buffer();
1113
1114                 const char* ptr = recv_buffer.begin + 1;
1115                 int piece = detail::read_uint32(ptr);
1116                 incoming_suggest(piece);
1117         }
1118
1119         void bt_peer_connection::on_have_all(int received)
1120         {
1121                 INVARIANT_CHECK;
1122
1123                 if (!m_supports_fast)
1124                 {
1125                         disconnect("got 'have_all' without FAST extension support", 2);
1126                         return;
1127                 }
1128                 m_statistics.received_bytes(0, received);
1129                 incoming_have_all();
1130         }
1131
1132         void bt_peer_connection::on_have_none(int received)
1133         {
1134                 INVARIANT_CHECK;
1135
1136                 if (!m_supports_fast)
1137                 {
1138                         disconnect("got 'have_none' without FAST extension support", 2);
1139                         return;
1140                 }
1141                 m_statistics.received_bytes(0, received);
1142                 incoming_have_none();
1143         }
1144
1145         void bt_peer_connection::on_reject_request(int received)
1146         {
1147                 INVARIANT_CHECK;
1148
1149                 if (!m_supports_fast)
1150                 {
1151                         disconnect("got 'reject_request' without FAST extension support", 2);
1152                         return;
1153                 }
1154
1155                 m_statistics.received_bytes(0, received);
1156                 if (!packet_finished()) return;
1157
1158                 buffer::const_interval recv_buffer = receive_buffer();
1159
1160                 peer_request r;
1161                 const char* ptr = recv_buffer.begin + 1;
1162                 r.piece = detail::read_int32(ptr);
1163                 r.start = detail::read_int32(ptr);
1164                 r.length = detail::read_int32(ptr);
1165
1166                 incoming_reject_request(r);
1167         }
1168
1169         void bt_peer_connection::on_allowed_fast(int received)
1170         {
1171                 INVARIANT_CHECK;
1172
1173                 if (!m_supports_fast)
1174                 {
1175                         disconnect("got 'allowed_fast' without FAST extension support", 2);
1176                         return;
1177                 }
1178
1179                 m_statistics.received_bytes(0, received);
1180                 if (!packet_finished()) return;
1181                 buffer::const_interval recv_buffer = receive_buffer();
1182                 const char* ptr = recv_buffer.begin + 1;
1183                 int index = detail::read_int32(ptr);
1184
1185                 incoming_allowed_fast(index);
1186         }
1187
1188         // -----------------------------
1189         // --------- EXTENDED ----------
1190         // -----------------------------
1191
1192         void bt_peer_connection::on_extended(int received)
1193         {
1194                 INVARIANT_CHECK;
1195
1196                 TORRENT_ASSERT(received > 0);
1197                 m_statistics.received_bytes(0, received);
1198                 if (packet_size() < 2)
1199                 {
1200                         disconnect("'extended' message smaller than 2 bytes", 2);
1201                         return;
1202                 }
1203
1204                 if (associated_torrent().expired())
1205                 {
1206                         disconnect("'extended' message sent before proper handshake", 2);
1207                         return;
1208                 }
1209
1210                 buffer::const_interval recv_buffer = receive_buffer();
1211                 if (recv_buffer.left() < 2) return;
1212
1213                 TORRENT_ASSERT(*recv_buffer.begin == msg_extended);
1214                 ++recv_buffer.begin;
1215
1216                 int extended_id = detail::read_uint8(recv_buffer.begin);
1217
1218                 if (extended_id == 0)
1219                 {
1220                         on_extended_handshake();
1221                         return;
1222                 }
1223
1224 #ifndef TORRENT_DISABLE_EXTENSIONS
1225                 for (extension_list_t::iterator i = m_extensions.begin()
1226                         , end(m_extensions.end()); i != end; ++i)
1227                 {
1228                         if ((*i)->on_extended(packet_size() - 2, extended_id
1229                                 , recv_buffer))
1230                                 return;
1231                 }
1232 #endif
1233
1234                 std::stringstream msg;
1235                 msg << "unknown extended message id: " << extended_id;
1236                 disconnect(msg.str().c_str(), 2);
1237                 return;
1238         }
1239
1240         void bt_peer_connection::on_extended_handshake()
1241         {
1242                 if (!packet_finished()) return;
1243
1244                 boost::shared_ptr<torrent> t = associated_torrent().lock();
1245                 TORRENT_ASSERT(t);
1246
1247                 buffer::const_interval recv_buffer = receive_buffer();
1248
1249                 lazy_entry root;
1250                 lazy_bdecode(recv_buffer.begin + 2, recv_buffer.end, root);
1251                 if (root.type() != lazy_entry::dict_t)
1252                 {
1253 #ifdef TORRENT_VERBOSE_LOGGING
1254                         (*m_logger) << "invalid extended handshake\n";
1255 #endif
1256                         return;
1257                 }
1258
1259 #ifdef TORRENT_VERBOSE_LOGGING
1260                 (*m_logger) << "<== EXTENDED HANDSHAKE: \n" << root;
1261 #endif
1262
1263 #ifndef TORRENT_DISABLE_EXTENSIONS
1264                 for (extension_list_t::iterator i = m_extensions.begin();
1265                         !m_extensions.empty() && i != m_extensions.end();)
1266                 {
1267                         // a false return value means that the extension
1268                         // isn't supported by the other end. So, it is removed.
1269                         if (!(*i)->on_extension_handshake(root))
1270                                 i = m_extensions.erase(i);
1271                         else
1272                                 ++i;
1273                 }
1274 #endif
1275
1276                 // there is supposed to be a remote listen port
1277                 int listen_port = root.dict_find_int_value("p");
1278                 if (listen_port > 0 && peer_info_struct() != 0)
1279                 {
1280                         t->get_policy().update_peer_port(listen_port
1281                                 , peer_info_struct(), peer_info::incoming);
1282                 }
1283                 // there should be a version too
1284                 // but where do we put that info?
1285
1286                 std::string client_info = root.dict_find_string_value("v");
1287                 if (!client_info.empty()) m_client_version = client_info;
1288
1289                 int reqq = root.dict_find_int_value("reqq");
1290                 if (reqq > 0) m_max_out_request_queue = reqq;
1291
1292                 if (root.dict_find_int_value("upload_only"))
1293                         set_upload_only(true);
1294
1295                 std::string myip = root.dict_find_string_value("yourip");
1296                 if (!myip.empty())
1297                 {
1298                         // TODO: don't trust this blindly
1299                         if (myip.size() == address_v4::bytes_type::static_size)
1300                         {
1301                                 address_v4::bytes_type bytes;
1302                                 std::copy(myip.begin(), myip.end(), bytes.begin());
1303                                 m_ses.set_external_address(address_v4(bytes));
1304                         }
1305                         else if (myip.size() == address_v6::bytes_type::static_size)
1306                         {
1307                                 address_v6::bytes_type bytes;
1308                                 std::copy(myip.begin(), myip.end(), bytes.begin());
1309                                 m_ses.set_external_address(address_v6(bytes));
1310                         }
1311                 }
1312
1313                 // if we're finished and this peer is uploading only
1314                 // disconnect it
1315                 if (t->is_finished() && upload_only())
1316                         disconnect("upload to upload connection, closing");
1317         }
1318
1319         bool bt_peer_connection::dispatch_message(int received)
1320         {
1321                 INVARIANT_CHECK;
1322
1323                 TORRENT_ASSERT(received > 0);
1324
1325                 // this means the connection has been closed already
1326                 if (associated_torrent().expired()) return false;
1327
1328                 buffer::const_interval recv_buffer = receive_buffer();
1329
1330                 TORRENT_ASSERT(recv_buffer.left() >= 1);
1331                 int packet_type = recv_buffer[0];
1332                 if (packet_type < 0
1333                         || packet_type >= num_supported_messages
1334                         || m_message_handler[packet_type] == 0)
1335                 {
1336 #ifndef TORRENT_DISABLE_EXTENSIONS
1337                         for (extension_list_t::iterator i = m_extensions.begin()
1338                                 , end(m_extensions.end()); i != end; ++i)
1339                         {
1340                                 if ((*i)->on_unknown_message(packet_size(), packet_type
1341                                         , buffer::const_interval(recv_buffer.begin+1
1342                                         , recv_buffer.end)))
1343                                         return packet_finished();
1344                         }
1345 #endif
1346
1347                         std::stringstream msg;
1348                         msg << "unkown message id: " << packet_type << " size: " << packet_size();
1349                         disconnect(msg.str().c_str(), 2);
1350                         return packet_finished();
1351                 }
1352
1353                 TORRENT_ASSERT(m_message_handler[packet_type] != 0);
1354
1355                 // call the correct handler for this packet type
1356                 (this->*m_message_handler[packet_type])(received);
1357
1358                 return packet_finished();
1359         }
1360
1361         void bt_peer_connection::write_keepalive()
1362         {
1363                 INVARIANT_CHECK;
1364
1365                 // Don't require the bitfield to have been sent at this point
1366                 // the case where m_sent_bitfield may not be true is if the
1367                 // torrent doesn't have any metadata, and a peer is timimg out.
1368                 // then the keep-alive message will be sent before the bitfield
1369                 // this is a violation to the original protocol, but necessary
1370                 // for the metadata extension.
1371                 TORRENT_ASSERT(m_sent_handshake);
1372
1373                 char msg[] = {0,0,0,0};
1374                 send_buffer(msg, sizeof(msg));
1375         }
1376
1377         void bt_peer_connection::write_cancel(peer_request const& r)
1378         {
1379                 INVARIANT_CHECK;
1380
1381                 TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield);
1382                 TORRENT_ASSERT(associated_torrent().lock()->valid_metadata());
1383
1384                 char msg[17] = {0,0,0,13, msg_cancel};
1385                 char* ptr = msg + 5;
1386                 detail::write_int32(r.piece, ptr); // index
1387                 detail::write_int32(r.start, ptr); // begin
1388                 detail::write_int32(r.length, ptr); // length
1389                 send_buffer(msg, sizeof(msg));
1390
1391                 if (!m_supports_fast)
1392                         incoming_reject_request(r);
1393         }
1394
1395         void bt_peer_connection::write_request(peer_request const& r)
1396         {
1397                 INVARIANT_CHECK;
1398
1399                 TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield);
1400                 TORRENT_ASSERT(associated_torrent().lock()->valid_metadata());
1401
1402                 char msg[17] = {0,0,0,13, msg_request};
1403                 char* ptr = msg + 5;
1404
1405                 detail::write_int32(r.piece, ptr); // index
1406                 detail::write_int32(r.start, ptr); // begin
1407                 detail::write_int32(r.length, ptr); // length
1408                 send_buffer(msg, sizeof(msg), message_type_request);
1409         }
1410
1411         void bt_peer_connection::write_bitfield()
1412         {
1413                 INVARIANT_CHECK;
1414
1415                 boost::shared_ptr<torrent> t = associated_torrent().lock();
1416                 TORRENT_ASSERT(t);
1417                 TORRENT_ASSERT(m_sent_handshake && !m_sent_bitfield);
1418                 TORRENT_ASSERT(t->valid_metadata());
1419
1420                 // in this case, have_all or have_none should be sent instead
1421                 TORRENT_ASSERT(!m_supports_fast || !t->is_seed() || t->num_have() != 0);
1422
1423                 if (m_supports_fast && t->is_seed())
1424                 {
1425                         write_have_all();
1426                         send_allowed_set();
1427                         return;
1428                 }
1429                 else if (m_supports_fast && t->num_have() == 0)
1430                 {
1431                         write_have_none();
1432                         send_allowed_set();
1433                         return;
1434                 }
1435                 else if (t->num_have() == 0)
1436                 {
1437                         // don't send a bitfield if we don't have any pieces
1438 #ifndef NDEBUG
1439                         m_sent_bitfield = true;
1440 #endif
1441                         return;
1442                 }
1443
1444                 int num_pieces = t->torrent_file().num_pieces();
1445                 int lazy_pieces[50];
1446                 int num_lazy_pieces = 0;
1447                 int lazy_piece = 0;
1448
1449                 if (t->is_seed() && m_ses.settings().lazy_bitfields)
1450                 {
1451                         num_lazy_pieces = (std::min)(50, num_pieces / 10);
1452                         if (num_lazy_pieces < 1) num_lazy_pieces = 1;
1453                         for (int i = 0; i < num_pieces; ++i)
1454                         {
1455                                 if (rand() % (num_pieces - i) >= num_lazy_pieces - lazy_piece) continue;
1456                                 lazy_pieces[lazy_piece++] = i;
1457                         }
1458                         TORRENT_ASSERT(lazy_piece == num_lazy_pieces);
1459                         lazy_piece = 0;
1460                 }
1461
1462                 const int packet_size = (num_pieces + 7) / 8 + 5;
1463
1464                 buffer::interval i = allocate_send_buffer(packet_size);
1465                 if (i.begin == 0) return; // out of memory
1466
1467                 detail::write_int32(packet_size - 4, i.begin);
1468                 detail::write_uint8(msg_bitfield, i.begin);
1469
1470                 if (t->is_seed())
1471                 {
1472                         memset(i.begin, 0xff, packet_size - 5);
1473                 }
1474                 else
1475                 {
1476                         memset(i.begin, 0, packet_size - 5);
1477                         piece_picker const& p = t->picker();
1478                         int mask = 0x80;
1479                         unsigned char* byte = (unsigned char*)i.begin;
1480                         for (int i = 0; i < num_pieces; ++i)
1481                         {
1482                                 if (p.have_piece(i)) *byte |= mask;
1483                                 mask >>= 1;
1484                                 if (mask == 0)
1485                                 {
1486                                         mask = 0x80;
1487                                         ++byte;
1488                                 }
1489                         }
1490                 }
1491                 for (int c = 0; c < num_lazy_pieces; ++c)
1492                         i.begin[lazy_pieces[c] / 8] &= ~(0x80 >> (lazy_pieces[c] & 7));
1493                 TORRENT_ASSERT(i.end - i.begin == (num_pieces + 7) / 8);
1494
1495 #ifdef TORRENT_VERBOSE_LOGGING
1496                 (*m_logger) << time_now_string() << " ==> BITFIELD ";
1497
1498                 std::stringstream bitfield_string;
1499                 for (int k = 0; k < num_pieces; ++k)
1500                 {
1501                         if (i.begin[k / 8] & (0x80 >> (k % 8))) bitfield_string << "1";
1502                         else bitfield_string << "0";
1503                 }
1504                 bitfield_string << "\n";
1505                 (*m_logger) << bitfield_string.str();
1506 #endif
1507 #ifndef NDEBUG
1508                 m_sent_bitfield = true;
1509 #endif
1510
1511                 if (num_lazy_pieces > 0)
1512                 {
1513                         for (int i = 0; i < num_lazy_pieces; ++i)
1514                         {
1515                                 write_have(lazy_pieces[i]);
1516 #ifdef TORRENT_VERBOSE_LOGGING
1517                                 (*m_logger) << time_now_string()
1518                                         << " ==> HAVE    [ piece: " << lazy_pieces[i] << "]\n";
1519 #endif
1520                         }
1521                 }
1522
1523                 if (m_supports_fast)
1524                         send_allowed_set();
1525                 setup_send();
1526         }
1527
1528 #ifndef TORRENT_DISABLE_EXTENSIONS
1529         void bt_peer_connection::write_extensions()
1530         {
1531                 INVARIANT_CHECK;
1532
1533 #ifdef TORRENT_VERBOSE_LOGGING
1534                 (*m_logger) << time_now_string() << " ==> EXTENSIONS\n";
1535 #endif
1536                 TORRENT_ASSERT(m_supports_extensions);
1537                 TORRENT_ASSERT(m_sent_handshake);
1538
1539                 entry handshake(entry::dictionary_t);
1540                 entry extension_list(entry::dictionary_t);
1541
1542                 handshake["m"] = extension_list;
1543
1544                 // only send the port in case we bade the connection
1545                 // on incoming connections the other end already knows
1546                 // our listen port
1547                 if (is_local()) handshake["p"] = m_ses.listen_port();
1548                 handshake["v"] = m_ses.settings().user_agent;
1549                 std::string remote_address;
1550                 std::back_insert_iterator<std::string> out(remote_address);
1551                 detail::write_address(remote().address(), out);
1552                 handshake["yourip"] = remote_address;
1553                 handshake["reqq"] = m_ses.settings().max_allowed_in_request_queue;
1554                 boost::shared_ptr<torrent> t = associated_torrent().lock();
1555                 TORRENT_ASSERT(t);
1556                 if (t->is_finished()) handshake["upload_only"] = 1;
1557
1558                 tcp::endpoint ep = m_ses.get_ipv6_interface();
1559                 if (ep != tcp::endpoint())
1560                 {
1561                         std::string ipv6_address;
1562                         std::back_insert_iterator<std::string> out(ipv6_address);
1563                         detail::write_address(ep.address(), out);
1564                         handshake["ipv6"] = ipv6_address;
1565                 }
1566
1567                 // loop backwards, to make the first extension be the last
1568                 // to fill in the handshake (i.e. give the first extensions priority)
1569                 for (extension_list_t::reverse_iterator i = m_extensions.rbegin()
1570                         , end(m_extensions.rend()); i != end; ++i)
1571                 {
1572                         (*i)->add_handshake(handshake);
1573                 }
1574
1575                 std::vector<char> msg;
1576                 bencode(std::back_inserter(msg), handshake);
1577
1578                 // make room for message
1579                 buffer::interval i = allocate_send_buffer(6 + msg.size());
1580                 if (i.begin == 0) return; // out of memory
1581
1582                 // write the length of the message
1583                 detail::write_int32((int)msg.size() + 2, i.begin);
1584                 detail::write_uint8(msg_extended, i.begin);
1585                 // signal handshake message
1586                 detail::write_uint8(0, i.begin);
1587
1588                 std::copy(msg.begin(), msg.end(), i.begin);
1589                 i.begin += msg.size();
1590                 TORRENT_ASSERT(i.begin == i.end);
1591
1592 #ifdef TORRENT_VERBOSE_LOGGING
1593                 std::stringstream ext;
1594                 handshake.print(ext);
1595                 (*m_logger) << "==> EXTENDED HANDSHAKE: \n" << ext.str();
1596 #endif
1597
1598                 setup_send();
1599         }
1600 #endif
1601
1602         void bt_peer_connection::write_choke()
1603         {
1604                 INVARIANT_CHECK;
1605
1606                 TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield);
1607
1608                 if (is_choked()) return;
1609                 char msg[] = {0,0,0,1,msg_choke};
1610                 send_buffer(msg, sizeof(msg));
1611         }
1612
1613         void bt_peer_connection::write_unchoke()
1614         {
1615                 INVARIANT_CHECK;
1616
1617                 TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield);
1618
1619                 char msg[] = {0,0,0,1,msg_unchoke};
1620                 send_buffer(msg, sizeof(msg));
1621         }
1622
1623         void bt_peer_connection::write_interested()
1624         {
1625                 INVARIANT_CHECK;
1626
1627                 TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield);
1628
1629                 char msg[] = {0,0,0,1,msg_interested};
1630                 send_buffer(msg, sizeof(msg));
1631         }
1632
1633         void bt_peer_connection::write_not_interested()
1634         {
1635                 INVARIANT_CHECK;
1636
1637                 TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield);
1638
1639                 char msg[] = {0,0,0,1,msg_not_interested};
1640                 send_buffer(msg, sizeof(msg));
1641         }
1642
1643         void bt_peer_connection::write_have(int index)
1644         {
1645                 INVARIANT_CHECK;
1646                 TORRENT_ASSERT(associated_torrent().lock()->valid_metadata());
1647                 TORRENT_ASSERT(index >= 0);
1648                 TORRENT_ASSERT(index < associated_torrent().lock()->torrent_file().num_pieces());
1649                 TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield);
1650
1651                 char msg[] = {0,0,0,5,msg_have,0,0,0,0};
1652                 char* ptr = msg + 5;
1653                 detail::write_int32(index, ptr);
1654                 send_buffer(msg, sizeof(msg));
1655         }
1656
1657         void bt_peer_connection::write_piece(peer_request const& r, disk_buffer_holder& buffer)
1658         {
1659                 INVARIANT_CHECK;
1660
1661                 TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield);
1662
1663                 boost::shared_ptr<torrent> t = associated_torrent().lock();
1664                 TORRENT_ASSERT(t);
1665
1666                 char msg[4 + 1 + 4 + 4];
1667                 char* ptr = msg;
1668                 TORRENT_ASSERT(r.length <= 16 * 1024);
1669                 detail::write_int32(r.length + 1 + 4 + 4, ptr);
1670                 detail::write_uint8(msg_piece, ptr);
1671                 detail::write_int32(r.piece, ptr);
1672                 detail::write_int32(r.start, ptr);
1673                 send_buffer(msg, sizeof(msg));
1674
1675                 append_send_buffer(buffer.get(), r.length
1676                         , boost::bind(&session_impl::free_disk_buffer
1677                         , boost::ref(m_ses), _1));
1678                 buffer.release();
1679
1680                 m_payloads.push_back(range(send_buffer_size() - r.length, r.length));
1681                 setup_send();
1682         }
1683
1684         namespace
1685         {
1686                 struct match_peer_id
1687                 {
1688                         match_peer_id(peer_id const& id, peer_connection const* pc)
1689                                 : m_id(id), m_pc(pc)
1690                         { TORRENT_ASSERT(pc); }
1691
1692                         bool operator()(std::pair<const address, policy::peer> const& p) const
1693                         {
1694                                 return p.second.connection != m_pc
1695                                         && p.second.connection
1696                                         && p.second.connection->pid() == m_id
1697                                         && !p.second.connection->pid().is_all_zeros()
1698                                         && p.second.addr == m_pc->remote().address();
1699                         }
1700
1701                         peer_id const& m_id;
1702                         peer_connection const* m_pc;
1703                 };
1704         }
1705
1706         // --------------------------
1707         // RECEIVE DATA
1708         // --------------------------
1709
1710         // throws exception when the client should be disconnected
1711         void bt_peer_connection::on_receive(error_code const& error
1712                 , std::size_t bytes_transferred)
1713         {
1714                 INVARIANT_CHECK;
1715
1716                 if (error) return;
1717                 boost::shared_ptr<torrent> t = associated_torrent().lock();
1718
1719                 if (in_handshake())
1720                         m_statistics.received_bytes(0, bytes_transferred);
1721
1722 #ifndef TORRENT_DISABLE_ENCRYPTION
1723                 TORRENT_ASSERT(in_handshake() || !m_rc4_encrypted || m_encrypted);
1724                 if (m_rc4_encrypted && m_encrypted)
1725                 {
1726                         std::pair<buffer::interval, buffer::interval> wr_buf = wr_recv_buffers(bytes_transferred);
1727                         m_RC4_handler->decrypt(wr_buf.first.begin, wr_buf.first.left());
1728                         if (wr_buf.second.left()) m_RC4_handler->decrypt(wr_buf.second.begin, wr_buf.second.left());
1729                 }
1730 #endif
1731
1732                 buffer::const_interval recv_buffer = receive_buffer();
1733
1734 #ifndef TORRENT_DISABLE_ENCRYPTION
1735                 // m_state is set to read_pe_dhkey in initial state
1736                 // (read_protocol_identifier) for incoming, or in constructor
1737                 // for outgoing
1738                 if (m_state == read_pe_dhkey)
1739                 {
1740                         TORRENT_ASSERT(!m_encrypted);
1741                         TORRENT_ASSERT(!m_rc4_encrypted);
1742                         TORRENT_ASSERT(packet_size() == dh_key_len);
1743                         TORRENT_ASSERT(recv_buffer == receive_buffer());
1744
1745                         if (!packet_finished()) return;
1746
1747                         // write our dh public key. m_dh_key_exchange is
1748                         // initialized in write_pe1_2_dhkey()
1749                         if (!is_local()) write_pe1_2_dhkey();
1750                         if (is_disconnecting()) return;
1751
1752                         // read dh key, generate shared secret
1753                         if (m_dh_key_exchange->compute_secret(recv_buffer.begin) == -1)
1754                         {
1755                                 disconnect("out of memory");
1756                                 return;
1757                         }
1758
1759 #ifdef TORRENT_VERBOSE_LOGGING
1760                         (*m_logger) << " received DH key\n";
1761 #endif
1762
1763                         // PadA/B can be a max of 512 bytes, and 20 bytes more for
1764                         // the sync hash (if incoming), or 8 bytes more for the
1765                         // encrypted verification constant (if outgoing). Instead
1766                         // of requesting the maximum possible, request the maximum
1767                         // possible to ensure we do not overshoot the standard
1768                         // handshake.
1769
1770                         if (is_local())
1771                         {
1772                                 m_state = read_pe_syncvc;
1773                                 write_pe3_sync();
1774
1775                                 // initial payload is the standard handshake, this is
1776                                 // always rc4 if sent here. m_rc4_encrypted is flagged
1777                                 // again according to peer selection.
1778                                 m_rc4_encrypted = true;
1779                                 m_encrypted = true;
1780                                 write_handshake();
1781                                 m_rc4_encrypted = false;
1782                                 m_encrypted = false;
1783
1784                                 // vc,crypto_select,len(pad),pad, encrypt(handshake)
1785                                 // 8+4+2+0+handshake_len
1786                                 reset_recv_buffer(8+4+2+0+handshake_len);
1787                         }
1788                         else
1789                         {
1790                                 // already written dh key
1791                                 m_state = read_pe_synchash;
1792                                 // synchash,skeyhash,vc,crypto_provide,len(pad),pad,encrypt(handshake)
1793                                 reset_recv_buffer(20+20+8+4+2+0+handshake_len);
1794                         }
1795                         TORRENT_ASSERT(!packet_finished());
1796                         return;
1797                 }
1798
1799                 // cannot fall through into
1800                 if (m_state == read_pe_synchash)
1801                 {
1802                         TORRENT_ASSERT(!m_encrypted);
1803                         TORRENT_ASSERT(!m_rc4_encrypted);
1804                         TORRENT_ASSERT(!is_local());
1805                         TORRENT_ASSERT(recv_buffer == receive_buffer());
1806
1807                         if (recv_buffer.left() < 20)
1808                         {
1809                                 if (packet_finished())
1810                                         disconnect("sync hash not found", 2);
1811                                 return;
1812                         }
1813
1814                         if (!m_sync_hash.get())
1815                         {
1816                                 TORRENT_ASSERT(m_sync_bytes_read == 0);
1817                                 hasher h;
1818
1819                                 // compute synchash (hash('req1',S))
1820                                 h.update("req1", 4);
1821                                 h.update(m_dh_key_exchange->get_secret(), dh_key_len);
1822
1823                                 m_sync_hash.reset(new sha1_hash(h.final()));
1824                         }
1825
1826                         int syncoffset = get_syncoffset((char*)m_sync_hash->begin(), 20
1827                                 , recv_buffer.begin, recv_buffer.left());
1828
1829                         // No sync
1830                         if (syncoffset == -1)
1831                         {
1832                                 std::size_t bytes_processed = recv_buffer.left() - 20;
1833                                 m_sync_bytes_read += bytes_processed;
1834                                 if (m_sync_bytes_read >= 512)
1835                                 {
1836                                         disconnect("sync hash not found within 532 bytes", 2);
1837                                         return;
1838                                 }
1839
1840                                 cut_receive_buffer(bytes_processed, (std::min)(packet_size(), (512+20) - m_sync_bytes_read));
1841
1842                                 TORRENT_ASSERT(!packet_finished());
1843                                 return;
1844                         }
1845                         // found complete sync
1846                         else
1847                         {
1848                                 std::size_t bytes_processed = syncoffset + 20;
1849 #ifdef TORRENT_VERBOSE_LOGGING
1850                                 (*m_logger) << " sync point (hash) found at offset "
1851                                         << m_sync_bytes_read + bytes_processed - 20 << "\n";
1852 #endif
1853                                 m_state = read_pe_skey_vc;
1854                                 // skey,vc - 28 bytes
1855                                 m_sync_hash.reset();
1856                                 cut_receive_buffer(bytes_processed, 28);
1857                         }
1858                 }
1859
1860                 if (m_state == read_pe_skey_vc)
1861                 {
1862                         TORRENT_ASSERT(!m_encrypted);
1863                         TORRENT_ASSERT(!m_rc4_encrypted);
1864                         TORRENT_ASSERT(!is_local());
1865                         TORRENT_ASSERT(packet_size() == 28);
1866
1867                         if (!packet_finished()) return;
1868
1869                         recv_buffer = receive_buffer();
1870
1871                         // only calls info_hash() on the torrent_handle's, which
1872                         // never throws.
1873                         session_impl::mutex_t::scoped_lock l(m_ses.m_mutex);
1874
1875                         std::vector<torrent_handle> active_torrents = m_ses.get_torrents();
1876                         std::vector<torrent_handle>::const_iterator i;
1877                         hasher h;
1878                         sha1_hash skey_hash, obfs_hash;
1879
1880                         for (i = active_torrents.begin(); i != active_torrents.end(); ++i)
1881                         {
1882                                 torrent_handle const& t_h = *i; // TODO possible errors
1883                                 sha1_hash const& info_hash = t_h.info_hash();
1884                                 // TODO Does info_hash need to be checked for validity?
1885
1886                                 h.reset();
1887                                 h.update("req2", 4);
1888                                 h.update((char*)info_hash.begin(), 20);
1889
1890                             skey_hash = h.final();
1891
1892                                 h.reset();
1893                                 h.update("req3", 4);
1894                                 h.update(m_dh_key_exchange->get_secret(), dh_key_len);
1895
1896                                 obfs_hash = h.final();
1897                                 obfs_hash ^= skey_hash;
1898
1899                                 if (std::equal (recv_buffer.begin, recv_buffer.begin + 20,
1900                                         (char*)obfs_hash.begin()))
1901                                 {
1902                                         if (!t)
1903                                         {
1904                                                 attach_to_torrent(info_hash);
1905                                                 if (is_disconnecting()) return;
1906
1907                                                 t = associated_torrent().lock();
1908                                                 TORRENT_ASSERT(t);
1909                                         }
1910
1911                                         init_pe_RC4_handler(m_dh_key_exchange->get_secret(), info_hash);
1912 #ifdef TORRENT_VERBOSE_LOGGING
1913                                         (*m_logger) << " stream key found, torrent located.\n";
1914 #endif
1915                                         continue; // TODO Check flow control with multiple torrents
1916                                 }
1917                         }
1918
1919                         if (!m_RC4_handler.get())
1920                         {
1921                                 disconnect("invalid streamkey identifier (info hash) in encrypted handshake", 2);
1922                                 return;
1923                         }
1924
1925                         // verify constant
1926                         buffer::interval wr_recv_buf = wr_recv_buffer();
1927                         m_RC4_handler->decrypt(wr_recv_buf.begin + 20, 8);
1928                         wr_recv_buf.begin += 28;
1929
1930                         const char sh_vc[] = {0,0,0,0, 0,0,0,0};
1931                         if (!std::equal(sh_vc, sh_vc+8, recv_buffer.begin + 20))
1932                         {
1933                                 disconnect("unable to verify constant", 2);
1934                                 return;
1935                         }
1936
1937 #ifdef TORRENT_VERBOSE_LOGGING
1938                         (*m_logger) << " verification constant found\n";
1939 #endif
1940                         m_state = read_pe_cryptofield;
1941                         reset_recv_buffer(4 + 2);
1942                 }
1943
1944                 // cannot fall through into
1945                 if (m_state == read_pe_syncvc)
1946                 {
1947                         TORRENT_ASSERT(is_local());
1948                         TORRENT_ASSERT(!m_encrypted);
1949                         TORRENT_ASSERT(!m_rc4_encrypted);
1950                         TORRENT_ASSERT(recv_buffer == receive_buffer());
1951
1952                         if (recv_buffer.left() < 8)
1953                         {
1954                                 if (packet_finished())
1955                                         disconnect("sync verification constant not found", 2);
1956                                 return;
1957                         }
1958
1959                         // generate the verification constant
1960                         if (!m_sync_vc.get())
1961                         {
1962                                 TORRENT_ASSERT(m_sync_bytes_read == 0);
1963
1964                                 m_sync_vc.reset (new char[8]);
1965                                 std::fill(m_sync_vc.get(), m_sync_vc.get() + 8, 0);
1966                                 m_RC4_handler->decrypt(m_sync_vc.get(), 8);
1967                         }
1968
1969                         TORRENT_ASSERT(m_sync_vc.get());
1970                         int syncoffset = get_syncoffset(m_sync_vc.get(), 8
1971                                 , recv_buffer.begin, recv_buffer.left());
1972
1973                         // No sync
1974                         if (syncoffset == -1)
1975                         {
1976                                 std::size_t bytes_processed = recv_buffer.left() - 8;
1977                                 m_sync_bytes_read += bytes_processed;
1978                                 if (m_sync_bytes_read >= 512)
1979                                 {
1980                                         disconnect("sync verification constant not found within 520 bytes", 2);
1981                                         return;
1982                                 }
1983
1984                                 cut_receive_buffer(bytes_processed, (std::min)(packet_size(), (512+8) - m_sync_bytes_read));
1985
1986                                 TORRENT_ASSERT(!packet_finished());
1987                                 return;
1988                         }
1989                         // found complete sync
1990                         else
1991                         {
1992                                 std::size_t bytes_processed = syncoffset + 8;
1993 #ifdef TORRENT_VERBOSE_LOGGING
1994                                 (*m_logger) << " sync point (verification constant) found at offset "
1995                                                         << m_sync_bytes_read + bytes_processed - 8 << "\n";
1996 #endif
1997                                 cut_receive_buffer (bytes_processed, 4 + 2);
1998
1999                                 // delete verification constant
2000                                 m_sync_vc.reset();
2001                                 m_state = read_pe_cryptofield;
2002                                 // fall through
2003                         }
2004                 }
2005
2006                 if (m_state == read_pe_cryptofield) // local/remote
2007                 {
2008                         TORRENT_ASSERT(!m_encrypted);
2009                         TORRENT_ASSERT(!m_rc4_encrypted);
2010                         TORRENT_ASSERT(packet_size() == 4+2);
2011
2012                         if (!packet_finished()) return;
2013
2014                         buffer::interval wr_buf = wr_recv_buffer();
2015                         m_RC4_handler->decrypt(wr_buf.begin, packet_size());
2016
2017                         recv_buffer = receive_buffer();
2018
2019                         int crypto_field = detail::read_int32(recv_buffer.begin);
2020
2021 #ifdef TORRENT_VERBOSE_LOGGING
2022                         if (!is_local())
2023                                 (*m_logger) << " crypto provide : [ ";
2024                         else
2025                                 (*m_logger) << " crypto select : [ ";
2026
2027                         if (crypto_field & 0x01)
2028                                 (*m_logger) << "plaintext ";
2029                         if (crypto_field & 0x02)
2030                                 (*m_logger) << "rc4 ";
2031                         (*m_logger) << "]\n";
2032 #endif
2033
2034                         if (!is_local())
2035                         {
2036                                 int crypto_select = 0;
2037                                 // select a crypto method
2038                                 switch (m_ses.get_pe_settings().allowed_enc_level)
2039                                 {
2040                                 case pe_settings::plaintext:
2041                                         if (!(crypto_field & 0x01))
2042                                         {
2043                                                 disconnect("plaintext not provided", 1);
2044                                                 return;
2045                                         }
2046                                         crypto_select = 0x01;
2047                                         break;
2048                                 case pe_settings::rc4:
2049                                         if (!(crypto_field & 0x02))
2050                                         {
2051                                                 disconnect("rc4 not provided", 1);
2052                                                 return;
2053                                         }
2054                                         crypto_select = 0x02;
2055                                         break;
2056                                 case pe_settings::both:
2057                                         if (m_ses.get_pe_settings().prefer_rc4)
2058                                         {
2059                                                 if (crypto_field & 0x02)
2060                                                         crypto_select = 0x02;
2061                                                 else if (crypto_field & 0x01)
2062                                                         crypto_select = 0x01;
2063                                         }
2064                                         else
2065                                         {
2066                                                 if (crypto_field & 0x01)
2067                                                         crypto_select = 0x01;
2068                                                 else if (crypto_field & 0x02)
2069                                                         crypto_select = 0x02;
2070                                         }
2071                                         if (!crypto_select)
2072                                         {
2073                                                 disconnect("rc4/plaintext not provided", 1);
2074                                                 return;
2075                                         }
2076                                         break;
2077                                 } // switch
2078
2079                                 // write the pe4 step
2080                                 write_pe4_sync(crypto_select);
2081                         }
2082                         else // is_local()
2083                         {
2084                                 // check if crypto select is valid
2085                                 pe_settings::enc_level const& allowed_enc_level = m_ses.get_pe_settings().allowed_enc_level;
2086
2087                                 if (crypto_field == 0x02)
2088                                 {
2089                                         if (allowed_enc_level == pe_settings::plaintext)
2090                                         {
2091                                                 disconnect("rc4 selected by peer when not provided", 2);
2092                                                 return;
2093                                         }
2094                                         m_rc4_encrypted = true;
2095                                 }
2096                                 else if (crypto_field == 0x01)
2097                                 {
2098                                         if (allowed_enc_level == pe_settings::rc4)
2099                                         {
2100                                                 disconnect("plaintext selected by peer when not provided", 2);
2101                                                 return;
2102                                         }
2103                                         m_rc4_encrypted = false;
2104                                 }
2105                                 else
2106                                 {
2107                                         disconnect("unsupported crypto method selected by peer", 2);
2108                                         return;
2109                                 }
2110                         }
2111
2112                         int len_pad = detail::read_int16(recv_buffer.begin);
2113                         if (len_pad < 0 || len_pad > 512)
2114                         {
2115                                 disconnect("invalid pad length", 2);
2116                                 return;
2117                         }
2118
2119                         m_state = read_pe_pad;
2120                         if (!is_local())
2121                                 reset_recv_buffer(len_pad + 2); // len(IA) at the end of pad
2122                         else
2123                         {
2124                                 if (len_pad == 0)
2125                                 {
2126                                         m_encrypted = true;
2127                                         m_state = init_bt_handshake;
2128                                 }
2129                                 else
2130                                         reset_recv_buffer(len_pad);
2131                         }
2132                 }
2133
2134                 if (m_state == read_pe_pad)
2135                 {
2136                         TORRENT_ASSERT(!m_encrypted);
2137                         if (!packet_finished()) return;
2138
2139                         int pad_size = is_local() ? packet_size() : packet_size() - 2;
2140
2141                         buffer::interval wr_buf = wr_recv_buffer();
2142                         m_RC4_handler->decrypt(wr_buf.begin, packet_size());
2143
2144                         recv_buffer = receive_buffer();
2145
2146                         if (!is_local())
2147                         {
2148                                 recv_buffer.begin += pad_size;
2149                                 int len_ia = detail::read_int16(recv_buffer.begin);
2150
2151                                 if (len_ia < 0)
2152                                 {
2153                                         disconnect("invalid len_ia in handshake", 2);
2154                                         return;
2155                                 }
2156
2157 #ifdef TORRENT_VERBOSE_LOGGING
2158                                 (*m_logger) << " len(IA) : " << len_ia << "\n";
2159 #endif
2160                                 if (len_ia == 0)
2161                                 {
2162                                         // everything after this is Encrypt2
2163                                         m_encrypted = true;
2164                                         m_state = init_bt_handshake;
2165                                 }
2166                                 else
2167                                 {
2168                                         m_state = read_pe_ia;
2169                                         reset_recv_buffer(len_ia);
2170                                 }
2171                         }
2172                         else // is_local()
2173                         {
2174                                 // everything that arrives after this is Encrypt2
2175                                 m_encrypted = true;
2176                                 m_state = init_bt_handshake;
2177                         }
2178                 }
2179
2180                 if (m_state == read_pe_ia)
2181                 {
2182                         TORRENT_ASSERT(!is_local());
2183                         TORRENT_ASSERT(!m_encrypted);
2184
2185                         if (!packet_finished()) return;
2186
2187                         // ia is always rc4, so decrypt it
2188                         buffer::interval wr_buf = wr_recv_buffer();
2189                         m_RC4_handler->decrypt(wr_buf.begin, packet_size());
2190
2191 #ifdef TORRENT_VERBOSE_LOGGING
2192                         (*m_logger) << " decrypted ia : " << packet_size() << " bytes\n";
2193 #endif
2194
2195                         if (!m_rc4_encrypted)
2196                         {
2197                                 m_RC4_handler.reset();
2198 #ifdef TORRENT_VERBOSE_LOGGING
2199                                 (*m_logger) << " destroyed rc4 keys\n";
2200 #endif
2201                         }
2202
2203                         // everything that arrives after this is Encrypt2
2204                         m_encrypted = true;
2205
2206                         m_state = read_protocol_identifier;
2207                         cut_receive_buffer(0, 20);
2208                 }
2209
2210                 if (m_state == init_bt_handshake)
2211                 {
2212                         TORRENT_ASSERT(m_encrypted);
2213
2214                         // decrypt remaining received bytes
2215                         if (m_rc4_encrypted)
2216                         {
2217                                 buffer::interval wr_buf = wr_recv_buffer();
2218                                 wr_buf.begin += packet_size();
2219                                 m_RC4_handler->decrypt(wr_buf.begin, wr_buf.left());
2220 #ifdef TORRENT_VERBOSE_LOGGING
2221                                 (*m_logger) << " decrypted remaining " << wr_buf.left() << " bytes\n";
2222 #endif
2223                         }
2224                         else // !m_rc4_encrypted
2225                         {
2226                                 m_RC4_handler.reset();
2227 #ifdef TORRENT_VERBOSE_LOGGING
2228                                 (*m_logger) << " destroyed rc4 keys\n";
2229 #endif
2230                         }
2231
2232                         // payload stream, start with 20 handshake bytes
2233                         m_state = read_protocol_identifier;
2234                         reset_recv_buffer(20);
2235
2236                         // encrypted portion of handshake completed, toggle
2237                         // peer_info pe_support flag back to true
2238                         if (is_local() &&
2239                                 m_ses.get_pe_settings().out_enc_policy == pe_settings::enabled)
2240                         {
2241                                 policy::peer* pi = peer_info_struct();
2242                                 TORRENT_ASSERT(pi);
2243
2244                                 pi->pe_support = true;
2245                         }
2246                 }
2247
2248 #endif // #ifndef TORRENT_DISABLE_ENCRYPTION
2249
2250                 if (m_state == read_protocol_identifier)
2251                 {
2252                         TORRENT_ASSERT(packet_size() == 20);
2253
2254                         if (!packet_finished()) return;
2255                         recv_buffer = receive_buffer();
2256
2257                         int packet_size = recv_buffer[0];
2258                         const char protocol_string[] = "BitTorrent protocol";
2259
2260                         if (packet_size != 19 ||
2261                                 !std::equal(recv_buffer.begin + 1, recv_buffer.begin + 19, protocol_string))
2262                         {
2263 #ifndef TORRENT_DISABLE_ENCRYPTION
2264                                 if (!is_local() && m_ses.get_pe_settings().in_enc_policy == pe_settings::disabled)
2265                                 {
2266                                         disconnect("encrypted incoming connections disabled");
2267                                         return;
2268                                 }
2269
2270                                 // Don't attempt to perform an encrypted handshake
2271                                 // within an encrypted connection
2272                                 if (!m_encrypted && !is_local())
2273                                 {
2274 #ifdef TORRENT_VERBOSE_LOGGING
2275                                         (*m_logger) << " attempting encrypted connection\n";
2276 #endif
2277                                         m_state = read_pe_dhkey;
2278                                         cut_receive_buffer(0, dh_key_len);
2279                                         TORRENT_ASSERT(!packet_finished());
2280                                         return;
2281                                 }
2282
2283                                 TORRENT_ASSERT((!is_local() && m_encrypted) || is_local());
2284 #endif // #ifndef TORRENT_DISABLE_ENCRYPTION
2285                                 disconnect("incorrect protocol identifier", 2);
2286                                 return;
2287                         }
2288
2289 #ifndef TORRENT_DISABLE_ENCRYPTION
2290                         TORRENT_ASSERT(m_state != read_pe_dhkey);
2291
2292                         if (!is_local() &&
2293                                 (m_ses.get_pe_settings().in_enc_policy == pe_settings::forced) &&
2294                                 !m_encrypted)
2295                         {
2296                                 disconnect("non encrypted incoming connections disabled");
2297                                 return;
2298                         }
2299 #endif
2300
2301 #ifdef TORRENT_VERBOSE_LOGGING
2302                         (*m_logger) << " BitTorrent protocol\n";
2303 #endif
2304
2305                         m_state = read_info_hash;
2306                         reset_recv_buffer(28);
2307                 }
2308
2309                 // fall through
2310                 if (m_state == read_info_hash)
2311                 {
2312                         TORRENT_ASSERT(packet_size() == 28);
2313
2314                         if (!packet_finished()) return;
2315                         recv_buffer = receive_buffer();
2316
2317
2318 #ifdef TORRENT_VERBOSE_LOGGING
2319                         for (int i=0; i < 8; ++i)
2320                         {
2321                                 for (int j=0; j < 8; ++j)
2322                                 {
2323                                         if (recv_buffer[i] & (0x80 >> j)) (*m_logger) << "1";
2324                                         else (*m_logger) << "0";
2325                                 }
2326                         }
2327                         (*m_logger) << "\n";
2328                         if (recv_buffer[7] & 0x01)
2329                                 (*m_logger) << "supports DHT port message\n";
2330                         if (recv_buffer[7] & 0x04)
2331                                 (*m_logger) << "supports FAST extensions\n";
2332                         if (recv_buffer[5] & 0x10)
2333                                 (*m_logger) << "supports extensions protocol\n";
2334 #endif
2335
2336 #ifndef DISABLE_EXTENSIONS
2337                         std::memcpy(m_reserved_bits, recv_buffer.begin, 20);
2338                         if ((recv_buffer[5] & 0x10))
2339                                 m_supports_extensions = true;
2340 #endif
2341                         if (recv_buffer[7] & 0x01)
2342                                 m_supports_dht_port = true;
2343
2344                         if (recv_buffer[7] & 0x04)
2345                                 m_supports_fast = true;
2346
2347                         // ok, now we have got enough of the handshake. Is this connection
2348                         // attached to a torrent?
2349                         if (!t)
2350                         {
2351                                 // now, we have to see if there's a torrent with the
2352                                 // info_hash we got from the peer
2353                                 sha1_hash info_hash;
2354                                 std::copy(recv_buffer.begin + 8, recv_buffer.begin + 28
2355                                         , (char*)info_hash.begin());
2356
2357                                 attach_to_torrent(info_hash);
2358                                 if (is_disconnecting()) return;
2359                         }
2360                         else
2361                         {
2362                                 // verify info hash
2363                                 if (!std::equal(recv_buffer.begin + 8, recv_buffer.begin + 28
2364                                         , (const char*)t->torrent_file().info_hash().begin()))
2365                                 {
2366 #ifdef TORRENT_VERBOSE_LOGGING
2367                                         (*m_logger) << " received invalid info_hash\n";
2368 #endif
2369                                         disconnect("invalid info-hash in handshake", 2);
2370                                         return;
2371                                 }
2372
2373 #ifdef TORRENT_VERBOSE_LOGGING
2374                                 (*m_logger) << " info_hash received\n";
2375 #endif
2376                         }
2377
2378                         t = associated_torrent().lock();
2379                         TORRENT_ASSERT(t);
2380
2381                         // if this is a local connection, we have already
2382                         // sent the handshake
2383                         if (!is_local()) write_handshake();
2384 //                      if (t->valid_metadata())
2385 //                              write_bitfield();
2386
2387                         if (is_disconnecting()) return;
2388
2389                         TORRENT_ASSERT(t->get_policy().has_connection(this));
2390
2391                         m_state = read_peer_id;
2392                         reset_recv_buffer(20);
2393                 }
2394
2395                 // fall through
2396                 if (m_state == read_peer_id)
2397                 {
2398                         if (!t)
2399                         {
2400                                 TORRENT_ASSERT(!packet_finished()); // TODO
2401                                 return;
2402                         }
2403                         TORRENT_ASSERT(packet_size() == 20);
2404
2405                         if (!packet_finished()) return;
2406                         recv_buffer = receive_buffer();
2407
2408 #ifdef TORRENT_VERBOSE_LOGGING
2409                         {
2410                                 peer_id tmp;
2411                                 std::copy(recv_buffer.begin, recv_buffer.begin + 20, (char*)tmp.begin());
2412                                 std::stringstream s;
2413                                 s << "received peer_id: " << tmp << " client: " << identify_client(tmp) << "\n";
2414                                 s << "as ascii: ";
2415                                 for (peer_id::iterator i = tmp.begin(); i != tmp.end(); ++i)
2416                                 {
2417                                         if (std::isprint(*i)) s << *i;
2418                                         else s << ".";
2419                                 }
2420                                 s << "\n";
2421                                 (*m_logger) << s.str();
2422                         }
2423 #endif
2424                         peer_id pid;
2425                         std::copy(recv_buffer.begin, recv_buffer.begin + 20, (char*)pid.begin());
2426                         set_pid(pid);
2427
2428                         if (t->settings().allow_multiple_connections_per_ip)
2429                         {
2430                                 // now, let's see if this connection should be closed
2431                                 policy& p = t->get_policy();
2432                                 policy::iterator i = std::find_if(p.begin_peer(), p.end_peer()
2433                                         , match_peer_id(pid, this));
2434                                 if (i != p.end_peer())
2435                                 {
2436                                         TORRENT_ASSERT(i->second.connection->pid() == pid);
2437                                         // we found another connection with the same peer-id
2438                                         // which connection should be closed in order to be
2439                                         // sure that the other end closes the same connection?
2440                                         // the peer with greatest peer-id is the one allowed to
2441                                         // initiate connections. So, if our peer-id is greater than
2442                                         // the others, we should close the incoming connection,
2443                                         // if not, we should close the outgoing one.
2444                                         if (pid < m_ses.get_peer_id() && is_local())
2445                                         {
2446                                                 i->second.connection->disconnect("duplicate peer-id, connection closed");
2447                                         }
2448                                         else
2449                                         {
2450                                                 disconnect("duplicate peer-id, connection closed");
2451                                                 return;
2452                                         }
2453                                 }
2454                         }
2455
2456                         if (pid == m_ses.get_peer_id())
2457                         {
2458                                 disconnect("closing connection to ourself", 1);
2459                                 return;
2460                         }
2461
2462                         m_client_version = identify_client(pid);
2463                         boost::optional<fingerprint> f = client_fingerprint(pid);
2464                         if (f && std::equal(f->name, f->name + 2, "BC"))
2465                         {
2466                                 // if this is a bitcomet client, lower the request queue size limit
2467                                 if (m_max_out_request_queue > 50) m_max_out_request_queue = 50;
2468                         }
2469
2470                         // disconnect if the peer has the same peer-id as ourself
2471                         // since it most likely is ourself then
2472                         if (pid == m_ses.get_peer_id())
2473                         {
2474                                 disconnect("closing connection to ourself", 1);
2475                                 return;
2476                         }
2477
2478 #ifndef TORRENT_DISABLE_EXTENSIONS
2479                         for (extension_list_t::iterator i = m_extensions.begin()
2480                                 , end(m_extensions.end()); i != end;)
2481                         {
2482                                 if (!(*i)->on_handshake(m_reserved_bits))
2483                                 {
2484                                         i = m_extensions.erase(i);
2485                                 }
2486                                 else
2487                                 {
2488                                         ++i;
2489                                 }
2490                         }
2491                         if (is_disconnecting()) return;
2492
2493                         if (m_supports_extensions) write_extensions();
2494 #endif
2495
2496 #ifdef TORRENT_VERBOSE_LOGGING
2497                         (*m_logger) << time_now_string() << " <== HANDSHAKE\n";
2498 #endif
2499                         // consider this a successful connection, reset the failcount
2500                         if (peer_info_struct()) peer_info_struct()->failcount = 0;
2501
2502 #ifndef TORRENT_DISABLE_ENCRYPTION
2503                         // Toggle pe_support back to false if this is a
2504                         // standard successful connection
2505                         if (is_local() && !m_encrypted &&
2506                                 m_ses.get_pe_settings().out_enc_policy == pe_settings::enabled)
2507                         {
2508                                 policy::peer* pi = peer_info_struct();
2509                                 TORRENT_ASSERT(pi);
2510
2511                                 pi->pe_support = false;
2512                         }
2513 #endif
2514
2515                         m_state = read_packet_size;
2516                         reset_recv_buffer(5);
2517                         if (t->valid_metadata())
2518                         {
2519                                 write_bitfield();
2520 #ifndef TORRENT_DISABLE_DHT
2521                                 if (m_supports_dht_port && m_ses.m_dht)
2522                                         write_dht_port(m_ses.get_dht_settings().service_port);
2523 #endif
2524                         }
2525
2526                         TORRENT_ASSERT(!packet_finished());
2527                         return;
2528                 }
2529
2530                 // cannot fall through into
2531                 if (m_state == read_packet_size)
2532                 {
2533                         // Make sure this is not fallen though into
2534                         TORRENT_ASSERT(recv_buffer == receive_buffer());
2535
2536                         if (!t) return;
2537                         m_statistics.received_bytes(0, bytes_transferred);
2538
2539                         if (recv_buffer.left() < 4) return;
2540
2541                         const char* ptr = recv_buffer.begin;
2542                         int packet_size = detail::read_int32(ptr);
2543
2544                         // don't accept packets larger than 1 MB
2545                         if (packet_size > 1024*1024 || packet_size < 0)
2546                         {
2547                                 // packet too large
2548                                 std::stringstream msg;
2549                                 msg << "packet > 1 MB (" << (unsigned int)packet_size << " bytes)";
2550                                 disconnect(msg.str().c_str(), 2);
2551                                 return;
2552                         }
2553
2554                         if (packet_size == 0)
2555                         {
2556                                 incoming_keepalive();
2557                                 if (is_disconnecting()) return;
2558                                 // keepalive message
2559                                 m_state = read_packet_size;
2560                                 cut_receive_buffer(4, 4);
2561                                 return;
2562                         }
2563                         else
2564                         {
2565                                 if (recv_buffer.left() < 5) return;
2566
2567                                 m_state = read_packet;
2568                                 cut_receive_buffer(4, packet_size);
2569                                 bytes_transferred = 1;
2570                                 recv_buffer = receive_buffer();
2571                                 TORRENT_ASSERT(recv_buffer.left() == 1);
2572                         }
2573                 }
2574
2575                 if (m_state == read_packet)
2576                 {
2577                         TORRENT_ASSERT(recv_buffer == receive_buffer());
2578                         if (!t) return;
2579                         if (dispatch_message(bytes_transferred))
2580                         {
2581                                 m_state = read_packet_size;
2582                                 reset_recv_buffer(5);
2583                         }
2584                         TORRENT_ASSERT(!packet_finished());
2585                         return;
2586                 }
2587
2588                 TORRENT_ASSERT(!packet_finished());
2589         }
2590
2591         // --------------------------
2592         // SEND DATA
2593         // --------------------------
2594
2595         void bt_peer_connection::on_sent(error_code const& error
2596                 , std::size_t bytes_transferred)
2597         {
2598                 INVARIANT_CHECK;
2599
2600                 if (error) return;
2601
2602                 // manage the payload markers
2603                 int amount_payload = 0;
2604                 if (!m_payloads.empty())
2605                 {
2606                         for (std::deque<range>::iterator i = m_payloads.begin();
2607                                 i != m_payloads.end(); ++i)
2608                         {
2609                                 i->start -= bytes_transferred;
2610                                 if (i->start < 0)
2611                                 {
2612                                         if (i->start + i->length <= 0)
2613                                         {
2614                                                 amount_payload += i->length;
2615                                         }
2616                                         else
2617                                         {
2618                                                 amount_payload += -i->start;
2619                                                 i->length -= -i->start;
2620                                                 i->start = 0;
2621                                         }
2622                                 }
2623                         }
2624                 }
2625
2626                 // TODO: move the erasing into the loop above
2627                 // remove all payload ranges that has been sent
2628                 m_payloads.erase(
2629                         std::remove_if(m_payloads.begin(), m_payloads.end(), range_below_zero)
2630                         , m_payloads.end());
2631
2632                 TORRENT_ASSERT(amount_payload <= (int)bytes_transferred);
2633                 m_statistics.sent_bytes(amount_payload, bytes_transferred - amount_payload);
2634         }
2635
2636 #ifndef NDEBUG
2637         void bt_peer_connection::check_invariant() const
2638         {
2639 #ifndef TORRENT_DISABLE_ENCRYPTION
2640                 TORRENT_ASSERT( (bool(m_state != read_pe_dhkey) || m_dh_key_exchange.get())
2641                                 || !is_local());
2642
2643                 TORRENT_ASSERT(!m_rc4_encrypted || m_RC4_handler.get());
2644 #endif
2645                 if (!in_handshake())
2646                 {
2647                         TORRENT_ASSERT(m_sent_handshake);
2648                 }
2649
2650                 if (!m_in_constructor)
2651                         peer_connection::check_invariant();
2652
2653                 if (!m_payloads.empty())
2654                 {
2655                         for (std::deque<range>::const_iterator i = m_payloads.begin();
2656                                 i != m_payloads.end() - 1; ++i)
2657                         {
2658                                 TORRENT_ASSERT(i->start + i->length <= (i+1)->start);
2659                         }
2660                 }
2661         }
2662 #endif
2663
2664 }
2665