← Back to branch summary

~ubuntu-branches/ubuntu/precise/bittornado/precise

« back to all changes in this revision

Viewing changes to .pc/18_fix_launchmany_encrypter.dpatch/BitTornado/BT1/Encrypter.py

  • Committer: Barry Warsaw
  • Date: 2011-08-10 23:17:46 UTC
  • mfrom: (7.1.1 bittornado)
  • Revision ID: barry@python.org-20110810231746-5buiob6p54m266s8
Tags: 0.3.18-10ubuntu2
https://launchpad.net/bugs/788514
* switch to dh_python2 (LP: #788514)
  - install btmakemetafile.py and btcompletedir.py via pyinstall
  - add build depend on python-all
  - bump debhelper depend to 7 for dh_auto_install

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/18_fix_launchmany_encrypter.dpatch/BitTornado/BT1/Encrypter.py
 
1
# Written by Bram Cohen
 
2
# see LICENSE.txt for license information
 
3
 
 
4
from cStringIO import StringIO
 
5
from binascii import b2a_hex
 
6
from socket import error as socketerror
 
7
from urllib import quote
 
8
from traceback import print_exc
 
9
from BitTornado.BTcrypto import Crypto
 
10
 
 
11
try:
 
12
    True
 
13
except:
 
14
    True = 1
 
15
    False = 0
 
16
    bool = lambda x: not not x
 
17
 
 
18
DEBUG = False
 
19
 
 
20
MAX_INCOMPLETE = 8
 
21
 
 
22
protocol_name = 'BitTorrent protocol'
 
23
option_pattern = chr(0)*8
 
24
 
 
25
def toint(s):
 
26
    return long(b2a_hex(s), 16)
 
27
 
 
28
def tobinary16(i):
 
29
    return chr((i >> 8) & 0xFF) + chr(i & 0xFF)
 
30
 
 
31
def make_readable(s):
 
32
    if not s:
 
33
        return ''
 
34
    if quote(s).find('%') >= 0:
 
35
        return b2a_hex(s).upper()
 
36
    return '"'+s+'"'
 
37
   
 
38
 
 
39
class IncompleteCounter:
 
40
    def __init__(self):
 
41
        self.c = 0
 
42
    def increment(self):
 
43
        self.c += 1
 
44
    def decrement(self):
 
45
        self.c -= 1
 
46
    def toomany(self):
 
47
        return self.c >= MAX_INCOMPLETE
 
48
    
 
49
incompletecounter = IncompleteCounter()
 
50
 
 
51
 
 
52
# header, options, download id, my id, [length, message]
 
53
 
 
54
class Connection:
 
55
    def __init__(self, Encoder, connection, id,
 
56
                 ext_handshake=False, encrypted = None, options = None):
 
57
        self.Encoder = Encoder
 
58
        self.connection = connection
 
59
        self.connecter = Encoder.connecter
 
60
        self.id = id
 
61
        self.locally_initiated = (id != None)
 
62
        self.readable_id = make_readable(id)
 
63
        self.complete = False
 
64
        self.keepalive = lambda: None
 
65
        self.closed = False
 
66
        self.buffer = ''
 
67
        self.bufferlen = None
 
68
        self.log = None
 
69
        self.read = self._read
 
70
        self.write = self._write
 
71
        self.cryptmode = 0
 
72
        self.encrypter = None
 
73
        if self.locally_initiated:
 
74
            incompletecounter.increment()
 
75
            if encrypted:
 
76
                self.encrypted = True
 
77
                self.encrypter = Crypto(True)
 
78
                self.write(self.encrypter.pubkey+self.encrypter.padding())
 
79
            else:
 
80
                self.encrypted = False
 
81
                self.write(chr(len(protocol_name)) + protocol_name + 
 
82
                    option_pattern + self.Encoder.download_id )
 
83
            self.next_len, self.next_func = 1+len(protocol_name), self.read_header
 
84
        elif ext_handshake:
 
85
            self.Encoder.connecter.external_connection_made += 1
 
86
            if encrypted:   # passed an already running encrypter
 
87
                self.encrypter = encrypted
 
88
                self.encrypted = True
 
89
                self._start_crypto()
 
90
                self.next_len, self.next_func = 14, self.read_crypto_block3c
 
91
            else:
 
92
                self.encrypted = False
 
93
                self.options = options
 
94
                self.write(self.Encoder.my_id)
 
95
                self.next_len, self.next_func = 20, self.read_peer_id
 
96
        else:
 
97
            self.encrypted = None       # don't know yet
 
98
            self.next_len, self.next_func = 1+len(protocol_name), self.read_header
 
99
        self.Encoder.raw_server.add_task(self._auto_close, 30)
 
100
 
 
101
 
 
102
    def _log_start(self):   # only called with DEBUG = True
 
103
        self.log = open('peerlog.'+self.get_ip()+'.txt','a')
 
104
        self.log.write('connected - ')
 
105
        if self.locally_initiated:
 
106
            self.log.write('outgoing\n')
 
107
        else:
 
108
            self.log.write('incoming\n')
 
109
        self._logwritefunc = self.write
 
110
        self.write = self._log_write
 
111
 
 
112
    def _log_write(self, s):
 
113
        self.log.write('w:'+b2a_hex(s)+'\n')
 
114
        self._logwritefunc(s)
 
115
        
 
116
 
 
117
    def get_ip(self, real=False):
 
118
        return self.connection.get_ip(real)
 
119
 
 
120
    def get_id(self):
 
121
        return self.id
 
122
 
 
123
    def get_readable_id(self):
 
124
        return self.readable_id
 
125
 
 
126
    def is_locally_initiated(self):
 
127
        return self.locally_initiated
 
128
 
 
129
    def is_encrypted(self):
 
130
        return bool(self.encrypted)
 
131
 
 
132
    def is_flushed(self):
 
133
        return self.connection.is_flushed()
 
134
 
 
135
    def _read_header(self, s):
 
136
        if s == chr(len(protocol_name))+protocol_name:
 
137
            return 8, self.read_options
 
138
        return None
 
139
 
 
140
    def read_header(self, s):
 
141
        if self._read_header(s):
 
142
            if self.encrypted or self.Encoder.config['crypto_stealth']:
 
143
                return None
 
144
            return 8, self.read_options
 
145
        if self.locally_initiated and not self.encrypted:
 
146
            return None
 
147
        elif not self.Encoder.config['crypto_allowed']:
 
148
            return None
 
149
        if not self.encrypted:
 
150
            self.encrypted = True
 
151
            self.encrypter = Crypto(self.locally_initiated)
 
152
        self._write_buffer(s)
 
153
        return self.encrypter.keylength, self.read_crypto_header
 
154
 
 
155
    ################## ENCRYPTION SUPPORT ######################
 
156
 
 
157
    def _start_crypto(self):
 
158
        self.encrypter.setrawaccess(self._read,self._write)
 
159
        self.write = self.encrypter.write
 
160
        self.read = self.encrypter.read
 
161
        if self.buffer:
 
162
            self.buffer = self.encrypter.decrypt(self.buffer)
 
163
 
 
164
    def _end_crypto(self):
 
165
        self.read = self._read
 
166
        self.write = self._write
 
167
        self.encrypter = None
 
168
 
 
169
    def read_crypto_header(self, s):
 
170
        self.encrypter.received_key(s)
 
171
        self.encrypter.set_skey(self.Encoder.download_id)
 
172
        if self.locally_initiated:
 
173
            if self.Encoder.config['crypto_only']:
 
174
                cryptmode = '\x00\x00\x00\x02'    # full stream encryption
 
175
            else:
 
176
                cryptmode = '\x00\x00\x00\x03'    # header or full stream
 
177
            padc = self.encrypter.padding()
 
178
            self.write( self.encrypter.block3a
 
179
                      + self.encrypter.block3b
 
180
                      + self.encrypter.encrypt(
 
181
                            ('\x00'*8)            # VC
 
182
                          + cryptmode             # acceptable crypto modes
 
183
                          + tobinary16(len(padc))
 
184
                          + padc                  # PadC
 
185
                          + '\x00\x00' ) )        # no initial payload data
 
186
            self._max_search = 520
 
187
            return 1, self.read_crypto_block4a
 
188
        self.write(self.encrypter.pubkey+self.encrypter.padding())
 
189
        self._max_search = 520
 
190
        return 0, self.read_crypto_block3a
 
191
 
 
192
    def _search_for_pattern(self, s, pat):
 
193
        p = s.find(pat)
 
194
        if p < 0:
 
195
            if len(s) >= len(pat):
 
196
                self._max_search -= len(s)+1-len(pat)
 
197
            if self._max_search < 0:
 
198
                self.close()
 
199
                return False
 
200
            self._write_buffer(s[1-len(pat):])
 
201
            return False
 
202
        self._write_buffer(s[p+len(pat):])
 
203
        return True
 
204
 
 
205
    ### INCOMING CONNECTION ###
 
206
 
 
207
    def read_crypto_block3a(self, s):
 
208
        if not self._search_for_pattern(s,self.encrypter.block3a):
 
209
            return -1, self.read_crypto_block3a     # wait for more data
 
210
        return len(self.encrypter.block3b), self.read_crypto_block3b
 
211
 
 
212
    def read_crypto_block3b(self, s):
 
213
        if s != self.encrypter.block3b:
 
214
            return None
 
215
        self.Encoder.connecter.external_connection_made += 1
 
216
        self._start_crypto()
 
217
        return 14, self.read_crypto_block3c
 
218
 
 
219
    def read_crypto_block3c(self, s):
 
220
        if s[:8] != ('\x00'*8):             # check VC
 
221
            return None
 
222
        self.cryptmode = toint(s[8:12]) % 4
 
223
        if self.cryptmode == 0:
 
224
            return None                     # no encryption selected
 
225
        if ( self.cryptmode == 1            # only header encryption
 
226
             and self.Encoder.config['crypto_only'] ):
 
227
            return None
 
228
        padlen = (ord(s[12])<<8)+ord(s[13])
 
229
        if padlen > 512:
 
230
            return None
 
231
        return padlen+2, self.read_crypto_pad3
 
232
 
 
233
    def read_crypto_pad3(self, s):
 
234
        s = s[-2:]
 
235
        ialen = (ord(s[0])<<8)+ord(s[1])
 
236
        if ialen > 65535:
 
237
            return None
 
238
        if self.cryptmode == 1:
 
239
            cryptmode = '\x00\x00\x00\x01'    # header only encryption
 
240
        else:
 
241
            cryptmode = '\x00\x00\x00\x02'    # full stream encryption
 
242
        padd = self.encrypter.padding()
 
243
        self.write( ('\x00'*8)            # VC
 
244
                  + cryptmode             # encryption mode
 
245
                  + tobinary16(len(padd))
 
246
                  + padd )                # PadD
 
247
        if ialen:
 
248
            return ialen, self.read_crypto_ia
 
249
        return self.read_crypto_block3done()
 
250
 
 
251
    def read_crypto_ia(self, s):
 
252
        if DEBUG:
 
253
            self._log_start()
 
254
            self.log.write('r:'+b2a_hex(s)+'(ia)\n')
 
255
            if self.buffer:
 
256
                self.log.write('r:'+b2a_hex(self.buffer)+'(buffer)\n')
 
257
        return self.read_crypto_block3done(s)
 
258
 
 
259
    def read_crypto_block3done(self, ia=''):
 
260
        if DEBUG:
 
261
            if not self.log:
 
262
                self._log_start()
 
263
        if self.cryptmode == 1:     # only handshake encryption
 
264
            assert not self.buffer  # oops; check for exceptions to this
 
265
            self._end_crypto()
 
266
        if ia:
 
267
            self._write_buffer(ia)
 
268
        return 1+len(protocol_name), self.read_encrypted_header
 
269
 
 
270
    ### OUTGOING CONNECTION ###
 
271
 
 
272
    def read_crypto_block4a(self, s):
 
273
        if not self._search_for_pattern(s,self.encrypter.VC_pattern()):
 
274
            return -1, self.read_crypto_block4a     # wait for more data
 
275
        self._start_crypto()
 
276
        return 6, self.read_crypto_block4b
 
277
 
 
278
    def read_crypto_block4b(self, s):
 
279
        self.cryptmode = toint(s[:4]) % 4
 
280
        if self.cryptmode == 1:             # only header encryption
 
281
            if self.Encoder.config['crypto_only']:
 
282
                return None
 
283
        elif self.cryptmode != 2:
 
284
            return None                     # unknown encryption
 
285
        padlen = (ord(s[4])<<8)+ord(s[5])
 
286
        if padlen > 512:
 
287
            return None
 
288
        if padlen:
 
289
            return padlen, self.read_crypto_pad4
 
290
        return self.read_crypto_block4done()
 
291
 
 
292
    def read_crypto_pad4(self, s):
 
293
        # discard data
 
294
        return self.read_crypto_block4done()
 
295
 
 
296
    def read_crypto_block4done(self):
 
297
        if DEBUG:
 
298
            self._log_start()
 
299
        if self.cryptmode == 1:     # only handshake encryption
 
300
            if not self.buffer:  # oops; check for exceptions to this
 
301
                return None
 
302
            self._end_crypto()
 
303
        self.write(chr(len(protocol_name)) + protocol_name + 
 
304
            option_pattern + self.Encoder.download_id)
 
305
        return 1+len(protocol_name), self.read_encrypted_header
 
306
 
 
307
    ### START PROTOCOL OVER ENCRYPTED CONNECTION ###
 
308
 
 
309
    def read_encrypted_header(self, s):
 
310
        return self._read_header(s)
 
311
 
 
312
    ################################################
 
313
 
 
314
    def read_options(self, s):
 
315
        self.options = s
 
316
        return 20, self.read_download_id
 
317
 
 
318
    def read_download_id(self, s):
 
319
        if ( s != self.Encoder.download_id
 
320
             or not self.Encoder.check_ip(ip=self.get_ip()) ):
 
321
            return None
 
322
        if not self.locally_initiated:
 
323
            if not self.encrypted:
 
324
                self.Encoder.connecter.external_connection_made += 1
 
325
            self.write(chr(len(protocol_name)) + protocol_name + 
 
326
                option_pattern + self.Encoder.download_id + self.Encoder.my_id)
 
327
        return 20, self.read_peer_id
 
328
 
 
329
    def read_peer_id(self, s):
 
330
        if not self.encrypted and self.Encoder.config['crypto_only']:
 
331
            return None     # allows older trackers to ping,
 
332
                            # but won't proceed w/ connections
 
333
        if not self.id:
 
334
            self.id = s
 
335
            self.readable_id = make_readable(s)
 
336
        else:
 
337
            if s != self.id:
 
338
                return None
 
339
        self.complete = self.Encoder.got_id(self)
 
340
        if not self.complete:
 
341
            return None
 
342
        if self.locally_initiated:
 
343
            self.write(self.Encoder.my_id)
 
344
            incompletecounter.decrement()
 
345
        self._switch_to_read2()
 
346
        c = self.Encoder.connecter.connection_made(self)
 
347
        self.keepalive = c.send_keepalive
 
348
        return 4, self.read_len
 
349
 
 
350
    def read_len(self, s):
 
351
        l = toint(s)
 
352
        if l > self.Encoder.max_len:
 
353
            return None
 
354
        return l, self.read_message
 
355
 
 
356
    def read_message(self, s):
 
357
        if s != '':
 
358
            self.connecter.got_message(self, s)
 
359
        return 4, self.read_len
 
360
 
 
361
    def read_dead(self, s):
 
362
        return None
 
363
 
 
364
    def _auto_close(self):
 
365
        if not self.complete:
 
366
            self.close()
 
367
 
 
368
    def close(self):
 
369
        if not self.closed:
 
370
            self.connection.close()
 
371
            self.sever()
 
372
 
 
373
    def sever(self):
 
374
        if self.log:
 
375
            self.log.write('closed\n')
 
376
            self.log.close()
 
377
        self.closed = True
 
378
        del self.Encoder.connections[self.connection]
 
379
        if self.complete:
 
380
            self.connecter.connection_lost(self)
 
381
        elif self.locally_initiated:
 
382
            incompletecounter.decrement()
 
383
 
 
384
    def send_message_raw(self, message):
 
385
        self.write(message)
 
386
 
 
387
    def _write(self, message):
 
388
        if not self.closed:
 
389
            self.connection.write(message)
 
390
 
 
391
    def data_came_in(self, connection, s):
 
392
        self.read(s)
 
393
 
 
394
    def _write_buffer(self, s):
 
395
        self.buffer = s+self.buffer
 
396
 
 
397
    def _read(self, s):
 
398
        if self.log:
 
399
            self.log.write('r:'+b2a_hex(s)+'\n')
 
400
        self.Encoder.measurefunc(len(s))
 
401
        self.buffer += s
 
402
        while True:
 
403
            if self.closed:
 
404
                return
 
405
            # self.next_len = # of characters function expects
 
406
            # or 0 = all characters in the buffer
 
407
            # or -1 = wait for next read, then all characters in the buffer
 
408
            # not compatible w/ keepalives, switch out after all negotiation complete
 
409
            if self.next_len <= 0:
 
410
                m = self.buffer
 
411
                self.buffer = ''
 
412
            elif len(self.buffer) >= self.next_len:
 
413
                m = self.buffer[:self.next_len]
 
414
                self.buffer = self.buffer[self.next_len:]
 
415
            else:
 
416
                return
 
417
            try:
 
418
                x = self.next_func(m)
 
419
            except:
 
420
                self.next_len, self.next_func = 1, self.read_dead
 
421
                raise
 
422
            if x is None:
 
423
                self.close()
 
424
                return
 
425
            self.next_len, self.next_func = x
 
426
            if self.next_len < 0:  # already checked buffer
 
427
                return             # wait for additional data
 
428
            if self.bufferlen is not None:
 
429
                self._read2('')
 
430
                return
 
431
 
 
432
    def _switch_to_read2(self):
 
433
        self._write_buffer = None
 
434
        if self.encrypter:
 
435
            self.encrypter.setrawaccess(self._read2,self._write)
 
436
        else:
 
437
            self.read = self._read2
 
438
        self.bufferlen = len(self.buffer)
 
439
        self.buffer = [self.buffer]
 
440
 
 
441
    def _read2(self, s):    # more efficient, requires buffer['',''] & bufferlen
 
442
        if self.log:
 
443
            self.log.write('r:'+b2a_hex(s)+'\n')
 
444
        self.Encoder.measurefunc(len(s))
 
445
        while True:
 
446
            if self.closed:
 
447
                return
 
448
            p = self.next_len-self.bufferlen
 
449
            if self.next_len == 0:
 
450
                m = ''
 
451
            elif s:
 
452
                if p > len(s):
 
453
                    self.buffer.append(s)
 
454
                    self.bufferlen += len(s)
 
455
                    return
 
456
                self.bufferlen = len(s)-p
 
457
                self.buffer.append(s[:p])
 
458
                m = ''.join(self.buffer)
 
459
                if p == len(s):
 
460
                    self.buffer = []
 
461
                else:
 
462
                    self.buffer=[s[p:]]
 
463
                s = ''
 
464
            elif p <= 0:
 
465
                # assert len(self.buffer) == 1
 
466
                s = self.buffer[0]
 
467
                self.bufferlen = len(s)-self.next_len
 
468
                m = s[:self.next_len]
 
469
                if p == 0:
 
470
                    self.buffer = []
 
471
                else:
 
472
                    self.buffer = [s[self.next_len:]]
 
473
                s = ''
 
474
            else:
 
475
                return
 
476
            try:
 
477
                x = self.next_func(m)
 
478
            except:
 
479
                self.next_len, self.next_func = 1, self.read_dead
 
480
                raise
 
481
            if x is None:
 
482
                self.close()
 
483
                return
 
484
            self.next_len, self.next_func = x
 
485
            if self.next_len < 0:  # already checked buffer
 
486
                return             # wait for additional data
 
487
            
 
488
 
 
489
    def connection_flushed(self, connection):
 
490
        if self.complete:
 
491
            self.connecter.connection_flushed(self)
 
492
 
 
493
    def connection_lost(self, connection):
 
494
        if self.Encoder.connections.has_key(connection):
 
495
            self.sever()
 
496
 
 
497
 
 
498
class _dummy_banlist:
 
499
    def includes(self, x):
 
500
        return False
 
501
 
 
502
class Encoder:
 
503
    def __init__(self, connecter, raw_server, my_id, max_len,
 
504
            schedulefunc, keepalive_delay, download_id, 
 
505
            measurefunc, config, bans=_dummy_banlist() ):
 
506
        self.raw_server = raw_server
 
507
        self.connecter = connecter
 
508
        self.my_id = my_id
 
509
        self.max_len = max_len
 
510
        self.schedulefunc = schedulefunc
 
511
        self.keepalive_delay = keepalive_delay
 
512
        self.download_id = download_id
 
513
        self.measurefunc = measurefunc
 
514
        self.config = config
 
515
        self.connections = {}
 
516
        self.banned = {}
 
517
        self.external_bans = bans
 
518
        self.to_connect = []
 
519
        self.paused = False
 
520
        if self.config['max_connections'] == 0:
 
521
            self.max_connections = 2 ** 30
 
522
        else:
 
523
            self.max_connections = self.config['max_connections']
 
524
        schedulefunc(self.send_keepalives, keepalive_delay)
 
525
 
 
526
    def send_keepalives(self):
 
527
        self.schedulefunc(self.send_keepalives, self.keepalive_delay)
 
528
        if self.paused:
 
529
            return
 
530
        for c in self.connections.values():
 
531
            c.keepalive()
 
532
 
 
533
    def start_connections(self, list):
 
534
        if not self.to_connect:
 
535
            self.raw_server.add_task(self._start_connection_from_queue)
 
536
        self.to_connect = list
 
537
 
 
538
    def _start_connection_from_queue(self):
 
539
        if self.connecter.external_connection_made:
 
540
            max_initiate = self.config['max_initiate']
 
541
        else:
 
542
            max_initiate = int(self.config['max_initiate']*1.5)
 
543
        cons = len(self.connections)
 
544
        if cons >= self.max_connections or cons >= max_initiate:
 
545
            delay = 60
 
546
        elif self.paused or incompletecounter.toomany():
 
547
            delay = 1
 
548
        else:
 
549
            delay = 0
 
550
            dns, id, encrypted = self.to_connect.pop(0)
 
551
            self.start_connection(dns, id, encrypted)
 
552
        if self.to_connect:
 
553
            self.raw_server.add_task(self._start_connection_from_queue, delay)
 
554
 
 
555
    def start_connection(self, dns, id, encrypted = None):
 
556
        if ( self.paused
 
557
             or len(self.connections) >= self.max_connections
 
558
             or id == self.my_id
 
559
             or not self.check_ip(ip=dns[0]) ):
 
560
            return True
 
561
        if self.config['crypto_only']:
 
562
            if encrypted is None or encrypted:  # fails on encrypted = 0
 
563
                encrypted = True
 
564
            else:
 
565
                return True
 
566
        for v in self.connections.values():
 
567
            if v is None:
 
568
                continue
 
569
            if id and v.id == id:
 
570
                return True
 
571
            ip = v.get_ip(True)
 
572
            if self.config['security'] and ip != 'unknown' and ip == dns[0]:
 
573
                return True
 
574
        try:
 
575
            c = self.raw_server.start_connection(dns)
 
576
            con = Connection(self, c, id, encrypted = encrypted)
 
577
            self.connections[c] = con
 
578
            c.set_handler(con)
 
579
        except socketerror:
 
580
            return False
 
581
        return True
 
582
 
 
583
    def _start_connection(self, dns, id, encrypted = None):
 
584
        def foo(self=self, dns=dns, id=id, encrypted=encrypted):
 
585
            self.start_connection(dns, id, encrypted)
 
586
        self.schedulefunc(foo, 0)
 
587
 
 
588
    def check_ip(self, connection=None, ip=None):
 
589
        if not ip:
 
590
            ip = connection.get_ip(True)
 
591
        if self.config['security'] and self.banned.has_key(ip):
 
592
            return False
 
593
        if self.external_bans.includes(ip):
 
594
            return False
 
595
        return True
 
596
 
 
597
    def got_id(self, connection):
 
598
        if connection.id == self.my_id:
 
599
            self.connecter.external_connection_made -= 1
 
600
            return False
 
601
        ip = connection.get_ip(True)
 
602
        for v in self.connections.values():
 
603
            if connection is not v:
 
604
                if connection.id == v.id:
 
605
                    if ip == v.get_ip(True):
 
606
                        v.close()
 
607
                    else:
 
608
                        return False
 
609
                if self.config['security'] and ip != 'unknown' and ip == v.get_ip(True):
 
610
                    v.close()
 
611
        return True
 
612
 
 
613
    def external_connection_made(self, connection):
 
614
        if self.paused or len(self.connections) >= self.max_connections:
 
615
            connection.close()
 
616
            return False
 
617
        con = Connection(self, connection, None)
 
618
        self.connections[connection] = con
 
619
        connection.set_handler(con)
 
620
        return True
 
621
 
 
622
    def externally_handshaked_connection_made(self, connection, options,
 
623
                                              already_read, encrypted = None):
 
624
        if ( self.paused
 
625
             or len(self.connections) >= self.max_connections
 
626
             or not self.check_ip(connection=connection) ):
 
627
            connection.close()
 
628
            return False
 
629
        con = Connection(self, connection, None,
 
630
                ext_handshake = True, encrypted = encrypted, options = options)
 
631
        self.connections[connection] = con
 
632
        connection.set_handler(con)
 
633
        if already_read:
 
634
            con.data_came_in(con, already_read)
 
635
        return True
 
636
 
 
637
    def close_all(self):
 
638
        for c in self.connections.values():
 
639
            c.close()
 
640
        self.connections = {}
 
641
 
 
642
    def ban(self, ip):
 
643
        self.banned[ip] = 1
 
644
 
 
645
    def pause(self, flag):
 
646
        self.paused = flag