← Back to branch summary

~ubuntu-branches/debian/experimental/libtorrent/experimental

« back to all changes in this revision

Viewing changes to src/protocol/handshake.cc

  • Committer: Bazaar Package Importer
  • Author(s): Jose Luis Rivas
  • Date: 2007-03-31 10:31:05 UTC
  • mto: (4.1.4 gutsy) (6.2.1 squeeze) (1.3.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 6.
  • Revision ID: james.westby@ubuntu.com-20070331103105-jzpp1rml6ud0ff75
Tags: upstream-0.11.4
Import upstream version 0.11.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/protocol/handshake.cc
36
36
 
37
37
#include "config.h"
38
38
 
39
 
#include "data/content.h"
40
39
#include "download/download_info.h"
41
40
#include "download/download_main.h"
42
41
#include "torrent/exceptions.h"
43
 
#include "torrent/connection_manager.h"
 
42
#include "torrent/error.h"
44
43
#include "torrent/poll.h"
 
44
#include "utils/diffie_hellman.h"
45
45
 
46
46
#include "globals.h"
47
47
#include "manager.h"
53
53
 
54
54
const char* Handshake::m_protocol = "BitTorrent protocol";
55
55
 
56
 
Handshake::Handshake(SocketFd fd, HandshakeManager* m) :
 
56
class handshake_error : public network_error {
 
57
public:
 
58
  handshake_error(int type, int error) : m_type(type), m_error(error) {}
 
59
 
 
60
  virtual const char* what() const throw()  { return "Handshake error"; }
 
61
  virtual int         type() const throw()  { return m_type; }
 
62
  virtual int         error() const throw() { return m_error; }
 
63
 
 
64
private:
 
65
  int     m_type;
 
66
  int     m_error;
 
67
};
 
68
 
 
69
class handshake_succeeded : public network_error {
 
70
public:
 
71
  handshake_succeeded() {}
 
72
};
 
73
 
 
74
Handshake::Handshake(SocketFd fd, HandshakeManager* m, int encryptionOptions) :
57
75
  m_state(INACTIVE),
58
76
 
59
77
  m_manager(m),
60
78
  m_peerInfo(NULL),
61
79
  m_download(NULL),
62
80
 
 
81
  m_initializedTime(cachedTime),
 
82
 
63
83
  m_readDone(false),
64
 
  m_writeDone(false) {
 
84
  m_writeDone(false),
 
85
 
 
86
  m_encryption(encryptionOptions) {
65
87
 
66
88
  set_fd(fd);
67
89
 
69
91
  m_writeBuffer.reset();      
70
92
 
71
93
  m_taskTimeout.clear_time();
72
 
  m_taskTimeout.set_slot(rak::bind_mem_fn(m, &HandshakeManager::receive_failed, this));
 
94
  m_taskTimeout.set_slot(rak::bind_mem_fn(m, &HandshakeManager::receive_timeout, this));
73
95
}
74
96
 
75
97
Handshake::~Handshake() {
79
101
  if (get_fd().is_valid())
80
102
    throw internal_error("Handshake dtor called but m_fd is still open.");
81
103
 
82
 
  if (m_peerInfo != NULL) {
83
 
    m_download->peer_list()->disconnected(m_peerInfo, 0);
84
 
 
85
 
    m_peerInfo->unset_flags(PeerInfo::flag_handshake);
86
 
    m_peerInfo = NULL;
87
 
  }
 
104
  m_encryption.cleanup();
 
105
}
 
106
 
 
107
void
 
108
Handshake::initialize_incoming(const rak::socket_address& sa) {
 
109
  m_incoming = true;
 
110
  m_address = sa;
 
111
 
 
112
  if (m_encryption.options() & (ConnectionManager::encryption_allow_incoming | ConnectionManager::encryption_require)) 
 
113
    m_state = READ_ENC_KEY;
 
114
  else
 
115
    m_state = READ_INFO;
 
116
 
 
117
  manager->poll()->open(this);
 
118
  manager->poll()->insert_read(this);
 
119
  manager->poll()->insert_error(this);
 
120
 
 
121
  // Use lower timeout here.
 
122
  priority_queue_insert(&taskScheduler, &m_taskTimeout, (cachedTime + rak::timer::from_seconds(60)).round_seconds());
88
123
}
89
124
 
90
125
void
107
142
}
108
143
 
109
144
void
110
 
Handshake::initialize_incoming(const rak::socket_address& sa) {
111
 
  m_incoming = true;
112
 
  m_address = sa;
113
 
 
114
 
  m_state = READ_INFO;
115
 
 
116
 
  manager->poll()->open(this);
117
 
  manager->poll()->insert_read(this);
118
 
  manager->poll()->insert_error(this);
119
 
 
120
 
  // Use lower timeout here.
121
 
  priority_queue_insert(&taskScheduler, &m_taskTimeout, (cachedTime + rak::timer::from_seconds(60)).round_seconds());
122
 
}
123
 
 
124
 
void
125
 
Handshake::clear() {
 
145
Handshake::deactivate_connection() {
126
146
  m_state = INACTIVE;
127
147
 
128
148
  priority_queue_erase(&taskScheduler, &m_taskTimeout);
134
154
}
135
155
 
136
156
void
 
157
Handshake::release_connection() {
 
158
  m_peerInfo->unset_flags(PeerInfo::flag_handshake);
 
159
  m_peerInfo = NULL;
 
160
 
 
161
  get_fd().clear();
 
162
}
 
163
 
 
164
void
 
165
Handshake::destroy_connection() {
 
166
  manager->connection_manager()->dec_socket_count();
 
167
 
 
168
  get_fd().close();
 
169
  get_fd().clear();
 
170
 
 
171
  if (m_peerInfo == NULL)
 
172
    return;
 
173
 
 
174
  m_download->peer_list()->disconnected(m_peerInfo, 0);
 
175
 
 
176
  m_peerInfo->unset_flags(PeerInfo::flag_handshake);
 
177
  m_peerInfo = NULL;
 
178
}
 
179
 
 
180
int
 
181
Handshake::retry_options() {
 
182
  uint32_t options = m_encryption.options() & ~ConnectionManager::encryption_enable_retry;
 
183
 
 
184
  if (m_encryption.retry() == HandshakeEncryption::RETRY_PLAIN)
 
185
    options &= ~ConnectionManager::encryption_try_outgoing;
 
186
  else if (m_encryption.retry() == HandshakeEncryption::RETRY_ENCRYPTED)
 
187
    options |= ConnectionManager::encryption_try_outgoing;
 
188
  else
 
189
    throw internal_error("Invalid retry type.");
 
190
 
 
191
  return options;
 
192
}
 
193
 
 
194
// Handshake::read_proxy_connect()
 
195
// Entry: 0, 0
 
196
// * 0, [0, 508>
 
197
bool
 
198
Handshake::read_proxy_connect() {
 
199
  // Being greedy for now.
 
200
  m_readBuffer.move_end(read_stream_throws(m_readBuffer.end(), 512));
 
201
  
 
202
  const char* pattern = "\r\n\r\n";
 
203
  const unsigned int patternLength = 4;
 
204
 
 
205
  if (m_readBuffer.remaining() < patternLength)
 
206
    return false;
 
207
 
 
208
  Buffer::iterator itr = std::search(m_readBuffer.begin(), m_readBuffer.end(),
 
209
                                     (uint8_t*)pattern, (uint8_t*)pattern + patternLength);
 
210
 
 
211
  m_readBuffer.set_position_itr(itr != m_readBuffer.end() ? (itr + patternLength) : (itr - patternLength));
 
212
  m_readBuffer.move_unused();
 
213
 
 
214
  return itr != m_readBuffer.end();
 
215
}
 
216
 
 
217
// Handshake::read_encryption_key()
 
218
// Entry: * 0, [0, 508>
 
219
// IU 20, [20, enc_pad_read_size>
 
220
// *E 96, [96, enc_pad_read_size>
 
221
bool
 
222
Handshake::read_encryption_key() {
 
223
  if (m_incoming) {
 
224
    if (m_readBuffer.remaining() < 20)
 
225
      m_readBuffer.move_end(read_stream_throws(m_readBuffer.end(), 20 - m_readBuffer.remaining()));
 
226
  
 
227
    if (m_readBuffer.remaining() < 20)
 
228
      return false;
 
229
 
 
230
    if (m_readBuffer.peek_8() == 19 && std::memcmp(m_readBuffer.position() + 1, m_protocol, 19) == 0) {
 
231
      // got unencrypted BT handshake
 
232
      if (m_encryption.options() & ConnectionManager::encryption_require)
 
233
        throw handshake_error(ConnectionManager::handshake_dropped, e_handshake_unencrypted_rejected);
 
234
 
 
235
      m_state = READ_INFO;
 
236
      return true;
 
237
    }
 
238
  }
 
239
 
 
240
  // Read as much of key, pad and sync string as we can; this is safe
 
241
  // because peer can't send anything beyond the initial BT handshake
 
242
  // because it doesn't know our encryption choice yet.
 
243
  if (m_readBuffer.remaining() < enc_pad_read_size)
 
244
    m_readBuffer.move_end(read_stream_throws(m_readBuffer.end(), enc_pad_read_size - m_readBuffer.remaining()));
 
245
 
 
246
  // but we need at least the key at this point
 
247
  if (m_readBuffer.size_end() < 96)
 
248
    return false;
 
249
 
 
250
  // If the handshake fails after this, it wasn't because the peer
 
251
  // doesn't like encrypted connections, so don't retry unencrypted.
 
252
  m_encryption.set_retry(HandshakeEncryption::RETRY_NONE);
 
253
 
 
254
  if (m_incoming)
 
255
    prepare_key_plus_pad();
 
256
 
 
257
  m_encryption.key()->compute_secret(m_readBuffer.position(), 96);
 
258
  m_readBuffer.consume(96);
 
259
 
 
260
  // Determine the synchronisation string.
 
261
  if (m_incoming)
 
262
    m_encryption.hash_req1_to_sync();
 
263
  else
 
264
    m_encryption.encrypt_vc_to_sync(m_download->info()->hash().c_str());
 
265
 
 
266
  // also put as much as we can write so far in the buffer
 
267
  if (!m_incoming)
 
268
    prepare_enc_negotiation();
 
269
 
 
270
  m_state = READ_ENC_SYNC;
 
271
  return true;
 
272
}
 
273
 
 
274
// Handshake::read_encryption_sync()
 
275
// *E 96, [96, enc_pad_read_size>
 
276
bool
 
277
Handshake::read_encryption_sync() {
 
278
  // Check if we've read the sync string already in the previous
 
279
  // state. This is very likely and avoids an unneeded read.
 
280
  Buffer::iterator itr = std::search(m_readBuffer.position(), m_readBuffer.end(),
 
281
                                     (uint8_t*)m_encryption.sync(), (uint8_t*)m_encryption.sync() + m_encryption.sync_length());
 
282
 
 
283
  if (itr == m_readBuffer.end()) {
 
284
    // Otherwise read as many bytes as possible until we find the sync
 
285
    // string.
 
286
    int toRead = enc_pad_size + m_encryption.sync_length() - m_readBuffer.remaining();
 
287
 
 
288
    if (toRead <= 0)
 
289
      throw handshake_error(ConnectionManager::handshake_failed, e_handshake_encryption_sync_failed);
 
290
 
 
291
    m_readBuffer.move_end(read_stream_throws(m_readBuffer.end(), toRead));
 
292
 
 
293
    itr = std::search(m_readBuffer.position(), m_readBuffer.end(),
 
294
                      (uint8_t*)m_encryption.sync(), (uint8_t*)m_encryption.sync() + m_encryption.sync_length());
 
295
 
 
296
    if (itr == m_readBuffer.end())
 
297
      return false;
 
298
  }
 
299
 
 
300
  if (m_incoming) {
 
301
    // We've found HASH('req1' + S), skip that and go on reading the
 
302
    // SKEY hash.
 
303
    m_readBuffer.consume(std::distance(m_readBuffer.position(), itr) + 20);
 
304
    m_state = READ_ENC_SKEY;
 
305
 
 
306
  } else {
 
307
    m_readBuffer.consume(std::distance(m_readBuffer.position(), itr));
 
308
    m_state = READ_ENC_NEGOT;
 
309
  }
 
310
 
 
311
  return true;
 
312
}
 
313
 
 
314
bool
 
315
Handshake::read_encryption_skey() {
 
316
  if (!fill_read_buffer(20))
 
317
    return false;
 
318
 
 
319
  m_encryption.deobfuscate_hash((char*)m_readBuffer.position());
 
320
  m_download = m_manager->download_info_obfuscated((char*)m_readBuffer.position());
 
321
  m_readBuffer.consume(20);
 
322
 
 
323
  validate_download();
 
324
 
 
325
  m_encryption.initialize_encrypt(m_download->info()->hash().c_str(), m_incoming);
 
326
  m_encryption.initialize_decrypt(m_download->info()->hash().c_str(), m_incoming);
 
327
 
 
328
  m_encryption.info()->decrypt(m_readBuffer.position(), m_readBuffer.remaining());
 
329
 
 
330
  HandshakeEncryption::copy_vc(m_writeBuffer.end());
 
331
  m_encryption.info()->encrypt(m_writeBuffer.end(), HandshakeEncryption::vc_length);
 
332
  m_writeBuffer.move_end(HandshakeEncryption::vc_length);
 
333
 
 
334
  m_state = READ_ENC_NEGOT;
 
335
  return true;
 
336
}
 
337
 
 
338
bool
 
339
Handshake::read_encryption_negotiation() {
 
340
  if (!fill_read_buffer(enc_negotiation_size))
 
341
    return false;
 
342
 
 
343
  if (!m_incoming) {
 
344
    // Start decrypting, but don't decrypt beyond the initial
 
345
    // encrypted handshake and later the pad because we may have read
 
346
    // too much data which may be unencrypted if the peer chose that
 
347
    // option.
 
348
    m_encryption.initialize_decrypt(m_download->info()->hash().c_str(), m_incoming);
 
349
    m_encryption.info()->decrypt(m_readBuffer.position(), enc_negotiation_size);
 
350
  }
 
351
 
 
352
  if (!HandshakeEncryption::compare_vc(m_readBuffer.position()))
 
353
    throw handshake_error(ConnectionManager::handshake_failed, e_handshake_invalid_value);
 
354
 
 
355
  m_readBuffer.consume(HandshakeEncryption::vc_length);
 
356
 
 
357
  m_encryption.set_crypto(m_readBuffer.read_32());
 
358
  m_readPos = m_readBuffer.read_16();       // length of padC/padD
 
359
 
 
360
  if (m_readPos > enc_pad_size)
 
361
    throw handshake_error(ConnectionManager::handshake_failed, e_handshake_invalid_value);
 
362
 
 
363
  // choose one of the offered encryptions, or check the chosen one is valid
 
364
  if (m_incoming) {
 
365
    if ((m_encryption.options() & ConnectionManager::encryption_prefer_plaintext) && m_encryption.has_crypto_plain()) {
 
366
      m_encryption.set_crypto(HandshakeEncryption::crypto_plain);
 
367
 
 
368
    } else if ((m_encryption.options() & ConnectionManager::encryption_require_RC4) && !m_encryption.has_crypto_rc4()) {
 
369
      throw handshake_error(ConnectionManager::handshake_dropped, e_handshake_unencrypted_rejected);
 
370
 
 
371
    } else if (m_encryption.has_crypto_rc4()) {
 
372
      m_encryption.set_crypto(HandshakeEncryption::crypto_rc4);
 
373
 
 
374
    } else if (m_encryption.has_crypto_plain()) {
 
375
      m_encryption.set_crypto(HandshakeEncryption::crypto_plain);
 
376
 
 
377
    } else {
 
378
      throw handshake_error(ConnectionManager::handshake_failed, e_handshake_invalid_encryption);
 
379
    }
 
380
 
 
381
    // at this point we can also write the rest of our negotiation reply
 
382
    m_writeBuffer.write_32(m_encryption.crypto());
 
383
    m_writeBuffer.write_16(0);
 
384
    m_encryption.info()->encrypt(m_writeBuffer.end() - 4 - 2, 4 + 2);
 
385
 
 
386
  } else {
 
387
    if (m_encryption.crypto() != HandshakeEncryption::crypto_rc4 && m_encryption.crypto() != HandshakeEncryption::crypto_plain)
 
388
      throw handshake_error(ConnectionManager::handshake_failed, e_handshake_invalid_encryption);
 
389
 
 
390
    if ((m_encryption.options() & ConnectionManager::encryption_require_RC4) && (m_encryption.crypto() != HandshakeEncryption::crypto_rc4))
 
391
      throw handshake_error(ConnectionManager::handshake_failed, e_handshake_invalid_encryption);
 
392
  }
 
393
 
 
394
  if (!m_incoming) {
 
395
    // decrypt appropriate part of buffer: only pad or all
 
396
    if (m_encryption.crypto() == HandshakeEncryption::crypto_plain)
 
397
      m_encryption.info()->decrypt(m_readBuffer.position(), std::min<uint32_t>(m_readPos, m_readBuffer.remaining()));
 
398
    else
 
399
      m_encryption.info()->decrypt(m_readBuffer.position(), m_readBuffer.remaining());
 
400
  }
 
401
 
 
402
  // next, skip padC/padD
 
403
  m_state = READ_ENC_PAD;
 
404
  return true;
 
405
}
 
406
 
 
407
bool
 
408
Handshake::read_negotiation_reply() {
 
409
  if (!m_incoming) {
 
410
    if (m_encryption.crypto() != HandshakeEncryption::crypto_rc4)
 
411
      m_encryption.info()->set_obfuscated();
 
412
 
 
413
    m_state = READ_INFO;
 
414
    return true;
 
415
  }
 
416
 
 
417
  if (!fill_read_buffer(2))
 
418
    return false;
 
419
 
 
420
  // The peer may send initial payload that is RC4 encrypted even if
 
421
  // we have selected plaintext encryption, so read it ahead of BT
 
422
  // handshake.
 
423
  m_encryption.set_length_ia(m_readBuffer.read_16());
 
424
 
 
425
  if (m_encryption.length_ia() > handshake_size)
 
426
    throw handshake_error(ConnectionManager::handshake_failed, e_handshake_invalid_value);
 
427
 
 
428
  m_state = READ_ENC_IA;
 
429
 
 
430
  return true;
 
431
}
 
432
 
 
433
bool
 
434
Handshake::read_info() {
 
435
  fill_read_buffer(handshake_size);
 
436
 
 
437
  // Check the first byte as early as possible so we can
 
438
  // disconnect non-BT connections if they send less than 20 bytes.
 
439
  if ((m_readBuffer.remaining() >= 1 && m_readBuffer.peek_8() != 19) ||
 
440
      m_readBuffer.remaining() >= 20 &&
 
441
      (std::memcmp(m_readBuffer.position() + 1, m_protocol, 19) != 0))
 
442
    throw handshake_error(ConnectionManager::handshake_failed, e_handshake_not_bittorrent);
 
443
 
 
444
  if (m_readBuffer.remaining() < part1_size)
 
445
    return false;
 
446
 
 
447
  // If the handshake fails after this, it isn't being rejected because
 
448
  // it is unencrypted, so don't retry.
 
449
  m_encryption.set_retry(HandshakeEncryption::RETRY_NONE);
 
450
 
 
451
  m_readBuffer.consume(20);
 
452
 
 
453
  // Should do some option field stuff here, for now just copy.
 
454
  m_readBuffer.read_range(m_options, m_options + 8);
 
455
 
 
456
  // Check the info hash.
 
457
  if (m_incoming) {
 
458
    if (m_download != NULL) {
 
459
      // Have the download from the encrypted handshake, make sure it
 
460
      // matches the BT handshake.
 
461
      if (m_download->info()->hash().not_equal_to((char*)m_readBuffer.position()))
 
462
        throw handshake_error(ConnectionManager::handshake_failed, e_handshake_invalid_value);
 
463
 
 
464
    } else {
 
465
      m_download = m_manager->download_info((char*)m_readBuffer.position());
 
466
    }
 
467
 
 
468
    validate_download();
 
469
    prepare_handshake();
 
470
 
 
471
  } else {
 
472
    if (m_download->info()->hash().not_equal_to((char*)m_readBuffer.position()))
 
473
      throw handshake_error(ConnectionManager::handshake_failed, e_handshake_invalid_value);
 
474
  }
 
475
 
 
476
  m_readBuffer.consume(20);
 
477
  m_state = READ_PEER;
 
478
 
 
479
  return true;
 
480
}
 
481
 
 
482
bool
 
483
Handshake::read_peer() {
 
484
  if (!fill_read_buffer(20))
 
485
    return false;
 
486
 
 
487
  prepare_peer_info();
 
488
 
 
489
  // The download is just starting so we're not sending any
 
490
  // bitfield.
 
491
  if (m_download->file_list()->bitfield()->is_all_unset())
 
492
    prepare_keepalive();
 
493
  else
 
494
    prepare_bitfield();
 
495
 
 
496
  m_state = BITFIELD;
 
497
  manager->poll()->insert_write(this);
 
498
 
 
499
  // Give some extra time for reading/writing the bitfield.
 
500
  priority_queue_erase(&taskScheduler, &m_taskTimeout);
 
501
  priority_queue_insert(&taskScheduler, &m_taskTimeout, (cachedTime + rak::timer::from_seconds(120)).round_seconds());
 
502
 
 
503
  // Trigger event_write() directly and then skip straight to read
 
504
  // BITFIELD. This avoids going through polling for the first
 
505
  // write.
 
506
  write_bitfield();
 
507
 
 
508
  return false;
 
509
}
 
510
 
 
511
bool
 
512
Handshake::read_bitfield() {
 
513
  Bitfield* bitfield = m_download->file_list()->mutable_bitfield();
 
514
 
 
515
  if (m_bitfield.empty()) {
 
516
    fill_read_buffer(5);
 
517
 
 
518
    // Received a keep-alive message which means we won't be
 
519
    // getting any bitfield.
 
520
    if (m_readBuffer.remaining() >= 4 && m_readBuffer.peek_32() == 0) {
 
521
      m_readBuffer.read_32();
 
522
      read_done();
 
523
      return false;
 
524
    }
 
525
 
 
526
    if (m_readBuffer.remaining() < 5)
 
527
      return false;
 
528
 
 
529
    // Received a non-bitfield command.
 
530
    if (m_readBuffer.peek_8_at(4) != protocol_bitfield) {
 
531
      read_done();
 
532
      return false;
 
533
    }
 
534
 
 
535
    if (m_readBuffer.read_32() != bitfield->size_bytes() + 1)
 
536
      throw handshake_error(ConnectionManager::handshake_failed, e_handshake_invalid_value);
 
537
 
 
538
    m_readBuffer.read_8();
 
539
    m_readPos = 0;
 
540
 
 
541
    m_bitfield.set_size_bits(bitfield->size_bits());
 
542
    m_bitfield.allocate();
 
543
 
 
544
    if (m_readBuffer.remaining() != 0) {
 
545
      m_readPos = std::min<uint32_t>(m_bitfield.size_bytes(), m_readBuffer.remaining());
 
546
      std::memcpy(m_bitfield.begin(), m_readBuffer.position(), m_readPos);
 
547
      m_readBuffer.consume(m_readPos);
 
548
    }
 
549
  }
 
550
 
 
551
  if (m_readPos < m_bitfield.size_bytes()) {
 
552
    uint32_t length = read_stream_throws(m_bitfield.begin() + m_readPos, m_bitfield.size_bytes() - m_readPos);
 
553
 
 
554
    if (m_encryption.info()->decrypt_valid())
 
555
      m_encryption.info()->decrypt(m_bitfield.begin() + m_readPos, length);
 
556
 
 
557
    m_readPos += length;
 
558
  }
 
559
 
 
560
  if (m_readPos == m_bitfield.size_bytes())
 
561
    read_done();
 
562
 
 
563
  return true;
 
564
}
 
565
 
 
566
void
137
567
Handshake::event_read() {
138
568
  try {
139
569
 
 
570
restart:
140
571
    switch (m_state) {
 
572
    case PROXY_CONNECT:
 
573
      if (!read_proxy_connect())
 
574
        break;
 
575
 
 
576
      m_state = PROXY_DONE;
 
577
 
 
578
      manager->poll()->insert_write(this);
 
579
      return event_write();
 
580
 
 
581
    case READ_ENC_KEY:
 
582
      if (!read_encryption_key())
 
583
        break;
 
584
 
 
585
      if (m_state != READ_ENC_SYNC)
 
586
        goto restart;
 
587
 
 
588
    case READ_ENC_SYNC:
 
589
      if (!read_encryption_sync())
 
590
        break;
 
591
 
 
592
      if (m_state != READ_ENC_SKEY)
 
593
        goto restart;
 
594
 
 
595
    case READ_ENC_SKEY:
 
596
      if (!read_encryption_skey())
 
597
        break;
 
598
 
 
599
    case READ_ENC_NEGOT:
 
600
      if (!read_encryption_negotiation())
 
601
        break;
 
602
 
 
603
      if (m_state != READ_ENC_PAD)
 
604
        goto restart;
 
605
 
 
606
    case READ_ENC_PAD:
 
607
      if (m_readPos) {
 
608
        // Read padC + lenIA or padD; pad length in m_readPos.
 
609
        if (!fill_read_buffer(m_readPos + (m_incoming ? 2 : 0)))
 
610
          // This can be improved (consume as much as was read)
 
611
          break;
 
612
 
 
613
        m_readBuffer.consume(m_readPos);
 
614
        m_readPos = 0;
 
615
      }
 
616
 
 
617
      if (!read_negotiation_reply())
 
618
        break;
 
619
 
 
620
      if (m_state != READ_ENC_IA)
 
621
        goto restart;
 
622
 
 
623
    case READ_ENC_IA:
 
624
      // Just read (and automatically decrypt) the initial payload
 
625
      // and leave it in the buffer for READ_INFO later.
 
626
      if (m_encryption.length_ia() > 0 && !fill_read_buffer(m_encryption.length_ia()))
 
627
        break;
 
628
 
 
629
      if (m_readBuffer.remaining() > m_encryption.length_ia())
 
630
        throw internal_error("Read past initial payload after incoming encrypted handshake.");
 
631
 
 
632
      if (m_encryption.crypto() != HandshakeEncryption::crypto_rc4)
 
633
        m_encryption.info()->set_obfuscated();
 
634
 
 
635
      m_state = READ_INFO;
 
636
 
141
637
    case READ_INFO:
142
 
      m_readBuffer.move_end(read_stream_throws(m_readBuffer.end(), handshake_size - m_readBuffer.size_end()));
143
 
 
144
 
      // Check the first byte as early as possible so we can
145
 
      // disconnect non-BT connections if they send less than 20 bytes.
146
 
      if (m_readBuffer.size_end() >= 1 && m_readBuffer.peek_8() != 19)
147
 
        return m_manager->receive_failed(this);
148
 
      
149
 
      if (m_readBuffer.size_end() < part1_size)
150
 
        return;
151
 
 
152
 
      if (std::memcmp(m_readBuffer.position() + 1, m_protocol, 19) != 0)
153
 
        return m_manager->receive_failed(this);
154
 
 
155
 
      m_readBuffer.move_position(20);
156
 
 
157
 
      // Should do some option field stuff here, for now just copy.
158
 
      m_readBuffer.read_range(m_options, m_options + 8);
159
 
 
160
 
      // Check the info hash.
161
 
      if (m_incoming) {
162
 
        m_download = m_manager->download_info(std::string(m_readBuffer.position(), m_readBuffer.position() + 20));
163
 
        m_readBuffer.move_position(20);
164
 
 
165
 
        if (m_download == NULL || !m_download->info()->is_accepting_new_peers())
166
 
          return m_manager->receive_failed(this);
167
 
 
168
 
        m_state = WRITE_FILL;
169
 
 
170
 
        manager->poll()->remove_read(this);
171
 
        manager->poll()->insert_write(this);
172
 
 
173
 
        return;
174
 
 
175
 
      } else {
176
 
        if (std::memcmp(m_download->info()->hash().c_str(), m_readBuffer.position(), 20) != 0)
177
 
          return m_manager->receive_failed(this);
178
 
 
179
 
        m_state = READ_PEER;
180
 
        m_readBuffer.move_position(20);
181
 
      }
 
638
      if (!read_info())
 
639
        break;
 
640
 
 
641
      if (m_state != READ_PEER)
 
642
        goto restart;
182
643
 
183
644
    case READ_PEER:
184
 
      if (m_readBuffer.size_end() < handshake_size)
185
 
        m_readBuffer.move_end(read_stream_throws(m_readBuffer.end(), handshake_size - m_readBuffer.size_end()));
186
 
 
187
 
      if (m_readBuffer.size_end() < handshake_size)
188
 
        return;
189
 
 
190
 
      prepare_peer_info();
191
 
      
192
 
      m_readBuffer.reset();
 
645
      if (!read_peer())
 
646
        break;
 
647
 
 
648
      if (m_state != BITFIELD)
 
649
        goto restart;
 
650
 
 
651
    case BITFIELD:
 
652
      read_bitfield();
 
653
      break;
 
654
 
 
655
    default:
 
656
      throw internal_error("Handshake::event_read() called in invalid state.");
 
657
    }
 
658
 
 
659
    // if we have more data to write, do so
 
660
    if (m_writeBuffer.remaining()) {
 
661
      manager->poll()->insert_write(this);
 
662
      return event_write();
 
663
    }
 
664
 
 
665
  } catch (handshake_succeeded& e) {
 
666
    m_manager->receive_succeeded(this);
 
667
 
 
668
  } catch (handshake_error& e) {
 
669
    m_manager->receive_failed(this, e.type(), e.error());
 
670
 
 
671
  } catch (network_error& e) {
 
672
    m_manager->receive_failed(this, ConnectionManager::handshake_failed, e_handshake_network_error);
 
673
 
 
674
  }
 
675
}
 
676
 
 
677
bool
 
678
Handshake::fill_read_buffer(int size) {
 
679
  if (m_readBuffer.remaining() < size) {
 
680
    if (size - m_readBuffer.remaining() > m_readBuffer.reserved_left())
 
681
      throw internal_error("Handshake::fill_read_buffer(...) Buffer overflow.");
 
682
 
 
683
    int read = m_readBuffer.move_end(read_stream_throws(m_readBuffer.end(), size - m_readBuffer.remaining()));
 
684
 
 
685
    if (m_encryption.info()->decrypt_valid())
 
686
      m_encryption.info()->decrypt(m_readBuffer.end() - read, read);
 
687
  }
 
688
 
 
689
  return m_readBuffer.remaining() >= size;
 
690
}
 
691
 
 
692
inline void
 
693
Handshake::validate_download() {
 
694
  if (m_download == NULL)
 
695
    throw handshake_error(ConnectionManager::handshake_dropped, e_handshake_unknown_download);
 
696
  if (!m_download->info()->is_active())
 
697
    throw handshake_error(ConnectionManager::handshake_dropped, e_handshake_inactive_download);
 
698
  if (!m_download->info()->is_accepting_new_peers())
 
699
    throw handshake_error(ConnectionManager::handshake_dropped, e_handshake_not_accepting_connections);
 
700
}
 
701
 
 
702
void
 
703
Handshake::read_done() {
 
704
  if (m_readDone != false)
 
705
    throw internal_error("Handshake::read_done() m_readDone != false.");
 
706
 
 
707
  m_readDone = true;
 
708
  manager->poll()->remove_read(this);
 
709
 
 
710
  if (m_bitfield.empty()) {
 
711
    m_bitfield.set_size_bits(m_download->file_list()->bitfield()->size_bits());
 
712
    m_bitfield.allocate();
 
713
    m_bitfield.unset_all();
 
714
 
 
715
  } else {
 
716
    m_bitfield.update();
 
717
  }
 
718
 
 
719
  if (m_writeDone)
 
720
    throw handshake_succeeded();
 
721
}
 
722
 
 
723
void
 
724
Handshake::event_write() {
 
725
  try {
 
726
 
 
727
    switch (m_state) {
 
728
    case CONNECTING:
 
729
      if (get_fd().get_error())
 
730
        throw handshake_error(ConnectionManager::handshake_failed, e_handshake_network_error);
 
731
 
 
732
      manager->poll()->insert_read(this);
 
733
 
 
734
      if (m_encryption.options() & ConnectionManager::encryption_use_proxy) {
 
735
        prepare_proxy_connect();
 
736
        
 
737
        m_state = PROXY_CONNECT;
 
738
        break;
 
739
      }
 
740
 
 
741
    case PROXY_DONE:
 
742
      // If there's any bytes remaining, it means we got a reply from
 
743
      // the other side before our proxy connect command was finished
 
744
      // written. This probably means the other side isn't a proxy.
 
745
      if (m_writeBuffer.remaining())
 
746
        throw handshake_error(ConnectionManager::handshake_failed, e_handshake_not_bittorrent);
 
747
 
193
748
      m_writeBuffer.reset();
194
749
 
195
 
      // The download is just starting so we're not sending any
196
 
      // bitfield.
197
 
      if (m_download->content()->bitfield()->is_all_unset())
198
 
        prepare_write_keepalive();
199
 
      else
200
 
        prepare_write_bitfield();
201
 
 
202
 
      m_state = BITFIELD;
203
 
      manager->poll()->insert_write(this);
204
 
 
205
 
      // Give some extra time for reading/writing the bitfield.
206
 
      priority_queue_erase(&taskScheduler, &m_taskTimeout);
207
 
      priority_queue_insert(&taskScheduler, &m_taskTimeout, (cachedTime + rak::timer::from_seconds(120)).round_seconds());
208
 
 
209
 
      // Trigger event_write() directly and then skip straight to read
210
 
      // BITFIELD. This avoids going through polling for the first
211
 
      // write.
 
750
      if (m_encryption.options() & (ConnectionManager::encryption_try_outgoing | ConnectionManager::encryption_require)) {
 
751
        prepare_key_plus_pad();
 
752
 
 
753
        // if connection fails, peer probably closed it because it was encrypted, so retry encrypted if enabled
 
754
        if (!(m_encryption.options() & ConnectionManager::encryption_require))
 
755
          m_encryption.set_retry(HandshakeEncryption::RETRY_PLAIN);
 
756
 
 
757
        m_state = READ_ENC_KEY;
 
758
 
 
759
      } else {
 
760
        // if connection is closed before we read the handshake, it might
 
761
        // be rejected because it is unencrypted, in that case retry encrypted
 
762
        m_encryption.set_retry(HandshakeEncryption::RETRY_ENCRYPTED);
 
763
 
 
764
        prepare_handshake();
 
765
 
 
766
        if (m_incoming)
 
767
          m_state = READ_PEER;
 
768
        else
 
769
          m_state = READ_INFO;
 
770
      }
 
771
 
 
772
      break;
 
773
 
 
774
    case BITFIELD:
212
775
      write_bitfield();
213
 
 
214
 
    case BITFIELD:
215
 
      if (m_bitfield.empty()) {
216
 
        m_readBuffer.move_end(read_stream_throws(m_readBuffer.end(), 5 - m_readBuffer.size_end()));
217
 
 
218
 
        // Received a keep-alive message which means we won't be
219
 
        // getting any bitfield.
220
 
        if (m_readBuffer.size_end() >= 4 && m_readBuffer.peek_32() == 0) {
221
 
          m_readBuffer.read_32();
222
 
          return read_done();
223
 
        }
224
 
 
225
 
        if (m_readBuffer.size_end() < 5)
226
 
          return;
227
 
 
228
 
        // Received a non-bitfield command.
229
 
        if (m_readBuffer.peek_8_at(4) != protocol_bitfield)
230
 
          return read_done();
231
 
 
232
 
        if (m_readBuffer.read_32() != m_download->content()->bitfield()->size_bytes() + 1)
233
 
          return m_manager->receive_failed(this);
234
 
 
235
 
        m_readBuffer.read_8();
236
 
        m_readPos = 0;
237
 
 
238
 
        m_bitfield.set_size_bits(m_download->content()->bitfield()->size_bits());
239
 
        m_bitfield.allocate();
240
 
 
241
 
        if (m_readBuffer.remaining() != 0)
242
 
          throw internal_error("Handshake::event_read() m_readBuffer.remaining() != 0.");
243
 
 
244
 
        // Copy any unread data to bitfield here.
245
 
      }
246
 
 
247
 
      // We're guaranteed that we still got bytes remaining to be
248
 
      // read of the bitfield.
249
 
      m_readPos += read_stream_throws(m_bitfield.begin() + m_readPos, m_bitfield.size_bytes() - m_readPos);
250
 
      
251
 
      if (m_readPos == m_bitfield.size_bytes())
252
 
        read_done();
253
 
 
254
776
      return;
255
777
 
256
778
    default:
257
 
      throw internal_error("Handshake::event_read() called in invalid state.");
 
779
      break;
258
780
    }
259
781
 
 
782
    if (!m_writeBuffer.remaining())
 
783
      throw internal_error("event_write called with empty write buffer.");
 
784
 
 
785
    if (m_writeBuffer.consume(write_stream_throws(m_writeBuffer.position(), m_writeBuffer.remaining())))
 
786
      manager->poll()->remove_write(this);
 
787
 
 
788
  } catch (handshake_succeeded& e) {
 
789
    m_manager->receive_succeeded(this);
 
790
 
 
791
  } catch (handshake_error& e) {
 
792
    m_manager->receive_failed(this, e.type(), e.error());
 
793
 
260
794
  } catch (network_error& e) {
261
 
    m_manager->receive_failed(this);
 
795
    m_manager->receive_failed(this, ConnectionManager::handshake_failed, e_handshake_network_error);
 
796
 
262
797
  }
263
798
}
264
799
 
265
 
inline void
 
800
void
 
801
Handshake::prepare_proxy_connect() {
 
802
  char buf[256];
 
803
  m_address.address_c_str(buf, 256);  
 
804
 
 
805
  int advance = snprintf((char*)m_writeBuffer.position(), m_writeBuffer.reserved_left(),
 
806
                         "CONNECT %s:%hu HTTP/1.0\r\n\r\n", buf, m_address.port());
 
807
 
 
808
  if (advance == -1)
 
809
    throw internal_error("Handshake::prepare_proxy_connect() snprintf failed.");
 
810
 
 
811
  m_writeBuffer.move_end(advance);
 
812
}
 
813
 
 
814
void
 
815
Handshake::prepare_key_plus_pad() {
 
816
  m_encryption.initialize();
 
817
 
 
818
  m_encryption.key()->store_pub_key(m_writeBuffer.end(), 96);
 
819
  m_writeBuffer.move_end(96);
 
820
 
 
821
  int length = random() % enc_pad_size;
 
822
  char pad[length];
 
823
 
 
824
  std::generate_n(pad, length, &::random);
 
825
  m_writeBuffer.write_len(pad, length);
 
826
}
 
827
 
 
828
void
 
829
Handshake::prepare_enc_negotiation() {
 
830
  char hash[20];
 
831
 
 
832
  // first piece, HASH('req1' + S)
 
833
  sha1_salt("req1", 4, m_encryption.key()->c_str(), m_encryption.key()->size(), m_writeBuffer.end());
 
834
  m_writeBuffer.move_end(20);
 
835
 
 
836
  // second piece, HASH('req2' + SKEY) ^ HASH('req3' + S)
 
837
  m_writeBuffer.write_len(m_download->info()->hash_obfuscated().c_str(), 20);
 
838
  sha1_salt("req3", 4, m_encryption.key()->c_str(), m_encryption.key()->size(), hash);
 
839
 
 
840
  for (int i = 0; i < 20; i++)
 
841
    m_writeBuffer.end()[i - 20] ^= hash[i];
 
842
 
 
843
  // last piece, ENCRYPT(VC, crypto_provide, len(PadC), PadC, len(IA))
 
844
  m_encryption.initialize_encrypt(m_download->info()->hash().c_str(), m_incoming);
 
845
 
 
846
  Buffer::iterator old_end = m_writeBuffer.end();
 
847
 
 
848
  HandshakeEncryption::copy_vc(m_writeBuffer.end());
 
849
  m_writeBuffer.move_end(HandshakeEncryption::vc_length);
 
850
 
 
851
  if (m_encryption.options() & ConnectionManager::encryption_require_RC4)
 
852
    m_writeBuffer.write_32(HandshakeEncryption::crypto_rc4);
 
853
  else
 
854
    m_writeBuffer.write_32(HandshakeEncryption::crypto_plain | HandshakeEncryption::crypto_rc4);
 
855
 
 
856
  m_writeBuffer.write_16(0);
 
857
  m_writeBuffer.write_16(handshake_size);
 
858
  m_encryption.info()->encrypt(old_end, m_writeBuffer.end() - old_end);
 
859
 
 
860
  // write and encrypt BT handshake as initial payload IA
 
861
  prepare_handshake();
 
862
}
 
863
 
 
864
void
 
865
Handshake::prepare_handshake() {
 
866
  m_writeBuffer.write_8(19);
 
867
  m_writeBuffer.write_range(m_protocol, m_protocol + 19);
 
868
 
 
869
  std::memset(m_writeBuffer.end(), 0, 8);
 
870
  m_writeBuffer.move_end(8);
 
871
 
 
872
  m_writeBuffer.write_range(m_download->info()->hash().c_str(), m_download->info()->hash().c_str() + 20);
 
873
  m_writeBuffer.write_range(m_download->info()->local_id().c_str(), m_download->info()->local_id().c_str() + 20);
 
874
 
 
875
  if (m_encryption.info()->is_encrypted())
 
876
    m_encryption.info()->encrypt(m_writeBuffer.end() - handshake_size, handshake_size);
 
877
}
 
878
 
 
879
void
266
880
Handshake::prepare_peer_info() {
267
881
  if (std::memcmp(m_readBuffer.position(), m_download->info()->local_id().c_str(), 20) == 0)
268
 
    throw close_connection();
 
882
    throw handshake_error(ConnectionManager::handshake_failed, e_handshake_is_self);
269
883
 
270
884
  // PeerInfo handling for outgoing connections needs to be moved to
271
885
  // HandshakeManager.
276
890
    m_peerInfo = m_download->peer_list()->connected(m_address.c_sockaddr(), PeerList::connect_incoming);
277
891
 
278
892
    if (m_peerInfo == NULL)
279
 
      throw close_connection();
 
893
      throw handshake_error(ConnectionManager::handshake_failed, e_handshake_network_error);
280
894
 
281
895
    m_peerInfo->set_flags(PeerInfo::flag_handshake);
282
896
  }
283
897
 
284
898
  std::memcpy(m_peerInfo->set_options(), m_options, 8);
285
 
  m_peerInfo->set_id(std::string(m_readBuffer.position(), m_readBuffer.position() + 20));
 
899
  m_peerInfo->mutable_id().assign((const char*)m_readBuffer.position());
 
900
  m_readBuffer.consume(20);
286
901
}
287
902
 
288
 
inline void
289
 
Handshake::prepare_write_bitfield() {
290
 
  m_writeBuffer.write_32(m_download->content()->bitfield()->size_bytes() + 1);
 
903
void
 
904
Handshake::prepare_bitfield() {
 
905
  m_writeBuffer.write_32(m_download->file_list()->bitfield()->size_bytes() + 1);
291
906
  m_writeBuffer.write_8(protocol_bitfield);
292
 
  m_writeBuffer.prepare_end();
 
907
 
 
908
  if (m_encryption.info()->is_encrypted())
 
909
    m_encryption.info()->encrypt(m_writeBuffer.end() - 5, 5);
293
910
 
294
911
  m_writePos = 0;
295
912
}
296
913
 
297
 
inline void
298
 
Handshake::prepare_write_keepalive() {
299
 
  // Write a keep-alive message.
 
914
void
 
915
Handshake::prepare_keepalive() {
300
916
  m_writeBuffer.write_32(0);
301
 
  m_writeBuffer.prepare_end();
 
917
 
 
918
  if (m_encryption.info()->is_encrypted())
 
919
    m_encryption.info()->encrypt(m_writeBuffer.end() - 4, 4);
302
920
 
303
921
  // Skip writting the bitfield.
304
 
  m_writePos = m_download->content()->bitfield()->size_bytes();
305
 
}
306
 
 
307
 
void
308
 
Handshake::read_done() {
309
 
  if (m_readDone != false)
310
 
    throw internal_error("Handshake::read_done() m_readDone != false.");
311
 
 
312
 
  m_readDone = true;
313
 
  manager->poll()->remove_read(this);
314
 
 
315
 
  if (m_bitfield.empty()) {
316
 
    m_bitfield.set_size_bits(m_download->content()->bitfield()->size_bits());
317
 
    m_bitfield.allocate();
318
 
    m_bitfield.unset_all();
319
 
 
320
 
  } else {
321
 
    m_bitfield.update();
322
 
  }
323
 
 
324
 
  // Disconnect if both are seeders.
325
 
 
326
 
  if (m_writeDone)
327
 
    m_manager->receive_succeeded(this);
328
 
}
329
 
 
330
 
void
331
 
Handshake::event_write() {
332
 
  try {
333
 
 
334
 
    switch (m_state) {
335
 
    case CONNECTING:
336
 
      if (get_fd().get_error())
337
 
        return m_manager->receive_failed(this);
338
 
 
339
 
    case WRITE_FILL:
340
 
      m_writeBuffer.write_8(19);
341
 
      m_writeBuffer.write_range(m_protocol, m_protocol + 19);
342
 
 
343
 
      //       m_writeBuffer.write_range(m_peerInfo->get_options(), m_peerInfo->get_options() + 8);
344
 
      std::memset(m_writeBuffer.position(), 0, 8);
345
 
      m_writeBuffer.move_position(8);
346
 
 
347
 
      m_writeBuffer.write_range(m_download->info()->hash().c_str(), m_download->info()->hash().c_str() + 20);
348
 
      m_writeBuffer.write_range(m_download->info()->local_id().c_str(), m_download->info()->local_id().c_str() + 20);
349
 
 
350
 
      m_writeBuffer.prepare_end();
351
 
 
352
 
      if (m_writeBuffer.size_end() != handshake_size)
353
 
        throw internal_error("Handshake::event_write() wrong fill size.");
354
 
 
355
 
      m_state = WRITE_SEND;
356
 
 
357
 
    case WRITE_SEND:
358
 
      m_writeBuffer.move_position(write_stream_throws(m_writeBuffer.position(), m_writeBuffer.remaining()));
359
 
 
360
 
      if (m_writeBuffer.remaining())
361
 
        return;
362
 
 
363
 
      if (m_incoming)
364
 
        m_state = READ_PEER;
365
 
      else
366
 
        m_state = READ_INFO;
367
 
 
368
 
      manager->poll()->remove_write(this);
369
 
      manager->poll()->insert_read(this);
370
 
 
371
 
      return;
372
 
 
373
 
    case BITFIELD:
374
 
      write_bitfield();
375
 
 
376
 
      return;
377
 
 
378
 
    default:
379
 
      throw internal_error("Handshake::event_write() called in invalid state.");
380
 
    }
381
 
 
382
 
  } catch (network_error& e) {
383
 
    m_manager->receive_failed(this);
384
 
  }
 
922
  m_writePos = m_download->file_list()->bitfield()->size_bytes();
385
923
}
386
924
 
387
925
void
388
926
Handshake::write_bitfield() {
 
927
  const Bitfield* bitfield = m_download->file_list()->bitfield();
 
928
 
389
929
  if (m_writeDone != false)
390
930
    throw internal_error("Handshake::event_write() m_writeDone != false.");
391
931
 
392
932
  if (m_writeBuffer.remaining())
393
 
    m_writeBuffer.move_position(write_stream_throws(m_writeBuffer.position(), m_writeBuffer.remaining()));
394
 
      
395
 
  if (m_writeBuffer.remaining())
396
 
    return;
397
 
 
398
 
  if (m_writePos != m_download->content()->bitfield()->size_bytes())
399
 
    m_writePos += write_stream_throws(m_download->content()->bitfield()->begin() + m_writePos,
400
 
                                      m_download->content()->bitfield()->size_bytes() - m_writePos);
401
 
 
402
 
  if (m_writePos == m_download->content()->bitfield()->size_bytes()) {
 
933
    if (!m_writeBuffer.consume(write_stream_throws(m_writeBuffer.position(), m_writeBuffer.remaining())))
 
934
      return;
 
935
 
 
936
  if (m_writePos != bitfield->size_bytes()) {
 
937
    if (m_encryption.info()->is_encrypted()) {
 
938
      if (m_writePos == 0)
 
939
        m_writeBuffer.reset();  // this should be unnecessary now
 
940
 
 
941
      uint32_t length = std::min<uint32_t>(bitfield->size_bytes() - m_writePos, m_writeBuffer.reserved()) - m_writeBuffer.size_end();
 
942
 
 
943
      if (length > 0) {
 
944
        std::memcpy(m_writeBuffer.end(), bitfield->begin() + m_writePos + m_writeBuffer.size_end(), length);
 
945
        m_encryption.info()->encrypt(m_writeBuffer.end(), length);
 
946
        m_writeBuffer.move_end(length);
 
947
      }
 
948
 
 
949
      length = write_stream_throws(m_writeBuffer.begin(), m_writeBuffer.size_end());
 
950
      m_writePos += length;
 
951
 
 
952
      if (length != m_writeBuffer.size_end() && length > 0)
 
953
        std::memmove(m_writeBuffer.begin(), m_writeBuffer.begin() + length, m_writeBuffer.size_end() - length);
 
954
 
 
955
      m_writeBuffer.move_end(-length);
 
956
 
 
957
    } else {
 
958
      m_writePos += write_stream_throws(bitfield->begin() + m_writePos,
 
959
                                        bitfield->size_bytes() - m_writePos);
 
960
    }
 
961
  }
 
962
 
 
963
  if (m_writePos == bitfield->size_bytes()) {
403
964
    m_writeDone = true;
404
965
    manager->poll()->remove_write(this);
405
966
 
406
967
    // Ok to just check m_readDone as the call in event_read() won't
407
968
    // set it before the call.
408
969
    if (m_readDone)
409
 
      m_manager->receive_succeeded(this);
 
970
      throw handshake_succeeded();
410
971
  }
411
972
}
412
973
 
415
976
  if (m_state == INACTIVE)
416
977
    throw internal_error("Handshake::event_error() called on an inactive handshake.");
417
978
 
418
 
  m_manager->receive_failed(this);
 
979
  m_manager->receive_failed(this, ConnectionManager::handshake_failed, e_handshake_network_error);
419
980
}
420
981
 
421
982
}