murder 0.0.0.pre

data/dist/BitTornado/BT1/NatCheck.py

@@ -0,0 +1,95 @@
+# Written by Bram Cohen
+# see LICENSE.txt for license information
+
+from cStringIO import StringIO
+from socket import error as socketerror
+from traceback import print_exc
+try:
+    True
+except:
+    True = 1
+    False = 0
+
+protocol_name = 'BitTorrent protocol'
+
+# header, reserved, download id, my id, [length, message]
+
+class NatCheck:
+    def __init__(self, resultfunc, downloadid, peerid, ip, port, rawserver):
+        self.resultfunc = resultfunc
+        self.downloadid = downloadid
+        self.peerid = peerid
+        self.ip = ip
+        self.port = port
+        self.closed = False
+        self.buffer = StringIO()
+        self.next_len = 1
+        self.next_func = self.read_header_len
+        try:
+            self.connection = rawserver.start_connection((ip, port), self)
+            self.connection.write(chr(len(protocol_name)) + protocol_name +
+                (chr(0) * 8) + downloadid)
+        except socketerror:
+            self.answer(False)
+        except IOError:
+            self.answer(False)
+
+    def answer(self, result):
+        self.closed = True
+        try:
+            self.connection.close()
+        except AttributeError:
+            pass
+        self.resultfunc(result, self.downloadid, self.peerid, self.ip, self.port)
+
+    def read_header_len(self, s):
+        if ord(s) != len(protocol_name):
+            return None
+        return len(protocol_name), self.read_header
+
+    def read_header(self, s):
+        if s != protocol_name:
+            return None
+        return 8, self.read_reserved
+
+    def read_reserved(self, s):
+        return 20, self.read_download_id
+
+    def read_download_id(self, s):
+        if s != self.downloadid:
+            return None
+        return 20, self.read_peer_id
+
+    def read_peer_id(self, s):
+        if s != self.peerid:
+            return None
+        self.answer(True)
+        return None
+
+    def data_came_in(self, connection, s):
+        while True:
+            if self.closed:
+                return
+            i = self.next_len - self.buffer.tell()
+            if i > len(s):
+                self.buffer.write(s)
+                return
+            self.buffer.write(s[:i])
+            s = s[i:]
+            m = self.buffer.getvalue()
+            self.buffer.reset()
+            self.buffer.truncate()
+            x = self.next_func(m)
+            if x is None:
+                if not self.closed:
+                    self.answer(False)
+                return
+            self.next_len, self.next_func = x
+
+    def connection_lost(self, connection):
+        if not self.closed:
+            self.closed = True
+            self.resultfunc(False, self.downloadid, self.peerid, self.ip, self.port)
+
+    def connection_flushed(self, connection):
+        pass

data/dist/BitTornado/BT1/PiecePicker.py

@@ -0,0 +1,320 @@
+# Written by Bram Cohen
+# see LICENSE.txt for license information
+
+from random import randrange, shuffle
+from BitTornado.clock import clock
+try:
+    True
+except:
+    True = 1
+    False = 0
+
+class PiecePicker:
+    def __init__(self, numpieces,
+                 rarest_first_cutoff = 1, rarest_first_priority_cutoff = 3,
+                 priority_step = 20):
+        self.rarest_first_cutoff = rarest_first_cutoff
+        self.rarest_first_priority_cutoff = rarest_first_priority_cutoff + priority_step
+        self.priority_step = priority_step
+        self.cutoff = rarest_first_priority_cutoff
+        self.numpieces = numpieces
+        self.started = []
+        self.totalcount = 0
+        self.numhaves = [0] * numpieces
+        self.priority = [1] * numpieces
+        self.removed_partials = {}
+        self.crosscount = [numpieces]
+        self.crosscount2 = [numpieces]
+        self.has = [0] * numpieces
+        self.numgot = 0
+        self.done = False
+        self.seed_connections = {}
+        self.past_ips = {}
+        self.seed_time = None
+        self.superseed = False
+        self.seeds_connected = 0
+        self._init_interests()
+
+    def _init_interests(self):
+        self.interests = [[] for x in xrange(self.priority_step)]
+        self.level_in_interests = [self.priority_step] * self.numpieces
+        interests = range(self.numpieces)
+        shuffle(interests)
+        self.pos_in_interests = [0] * self.numpieces
+        for i in xrange(self.numpieces):
+            self.pos_in_interests[interests[i]] = i
+        self.interests.append(interests)
+
+
+    def got_have(self, piece):
+        self.totalcount+=1
+        numint = self.numhaves[piece]
+        self.numhaves[piece] += 1
+        self.crosscount[numint] -= 1
+        if numint+1==len(self.crosscount):
+            self.crosscount.append(0)
+        self.crosscount[numint+1] += 1
+        if not self.done:
+            numintplus = numint+self.has[piece]
+            self.crosscount2[numintplus] -= 1
+            if numintplus+1 == len(self.crosscount2):
+                self.crosscount2.append(0)
+            self.crosscount2[numintplus+1] += 1
+            numint = self.level_in_interests[piece]
+            self.level_in_interests[piece] += 1
+        if self.superseed:
+            self.seed_got_haves[piece] += 1
+            numint = self.level_in_interests[piece]
+            self.level_in_interests[piece] += 1
+        elif self.has[piece] or self.priority[piece] == -1:
+            return
+        if numint == len(self.interests) - 1:
+            self.interests.append([])
+        self._shift_over(piece, self.interests[numint], self.interests[numint + 1])
+
+    def lost_have(self, piece):
+        self.totalcount-=1
+        numint = self.numhaves[piece]
+        self.numhaves[piece] -= 1
+        self.crosscount[numint] -= 1
+        self.crosscount[numint-1] += 1
+        if not self.done:
+            numintplus = numint+self.has[piece]
+            self.crosscount2[numintplus] -= 1
+            self.crosscount2[numintplus-1] += 1
+            numint = self.level_in_interests[piece]
+            self.level_in_interests[piece] -= 1
+        if self.superseed:
+            numint = self.level_in_interests[piece]
+            self.level_in_interests[piece] -= 1
+        elif self.has[piece] or self.priority[piece] == -1:
+            return
+        self._shift_over(piece, self.interests[numint], self.interests[numint - 1])
+
+    def _shift_over(self, piece, l1, l2):
+        assert self.superseed or (not self.has[piece] and self.priority[piece] >= 0)
+        parray = self.pos_in_interests
+        p = parray[piece]
+        assert l1[p] == piece
+        q = l1[-1]
+        l1[p] = q
+        parray[q] = p
+        del l1[-1]
+        newp = randrange(len(l2)+1)
+        if newp == len(l2):
+            parray[piece] = len(l2)
+            l2.append(piece)
+        else:
+            old = l2[newp]
+            parray[old] = len(l2)
+            l2.append(old)
+            l2[newp] = piece
+            parray[piece] = newp
+
+
+    def got_seed(self):
+        self.seeds_connected += 1
+        self.cutoff = max(self.rarest_first_priority_cutoff-self.seeds_connected,0)
+
+    def became_seed(self):
+        self.got_seed()
+        self.totalcount -= self.numpieces
+        self.numhaves = [i-1 for i in self.numhaves]
+        if self.superseed or not self.done:
+            self.level_in_interests = [i-1 for i in self.level_in_interests]
+            if self.interests:
+                del self.interests[0]
+        del self.crosscount[0]
+        if not self.done:
+            del self.crosscount2[0]
+
+    def lost_seed(self):
+        self.seeds_connected -= 1
+        self.cutoff = max(self.rarest_first_priority_cutoff-self.seeds_connected,0)
+
+
+    def requested(self, piece):
+        if piece not in self.started:
+            self.started.append(piece)
+
+    def _remove_from_interests(self, piece, keep_partial = False):
+        l = self.interests[self.level_in_interests[piece]]
+        p = self.pos_in_interests[piece]
+        assert l[p] == piece
+        q = l[-1]
+        l[p] = q
+        self.pos_in_interests[q] = p
+        del l[-1]
+        try:
+            self.started.remove(piece)
+            if keep_partial:
+                self.removed_partials[piece] = 1
+        except ValueError:
+            pass
+
+    def complete(self, piece):
+        assert not self.has[piece]
+        self.has[piece] = 1
+        self.numgot += 1
+        if self.numgot == self.numpieces:
+            self.done = True
+            self.crosscount2 = self.crosscount
+        else:
+            numhaves = self.numhaves[piece]
+            self.crosscount2[numhaves] -= 1
+            if numhaves+1 == len(self.crosscount2):
+                self.crosscount2.append(0)
+            self.crosscount2[numhaves+1] += 1
+        self._remove_from_interests(piece)
+
+
+    def next(self, haves, wantfunc, complete_first = False):
+        cutoff = self.numgot < self.rarest_first_cutoff
+        complete_first = (complete_first or cutoff) and not haves.complete()
+        best = None
+        bestnum = 2 ** 30
+        for i in self.started:
+            if haves[i] and wantfunc(i):
+                if self.level_in_interests[i] < bestnum:
+                    best = i
+                    bestnum = self.level_in_interests[i]
+        if best is not None:
+            if complete_first or (cutoff and len(self.interests) > self.cutoff):
+                return best
+        if haves.complete():
+            r = [ (0, min(bestnum,len(self.interests))) ]
+        elif cutoff and len(self.interests) > self.cutoff:
+            r = [ (self.cutoff, min(bestnum,len(self.interests))),
+                      (0, self.cutoff) ]
+        else:
+            r = [ (0, min(bestnum,len(self.interests))) ]
+        for lo,hi in r:
+            for i in xrange(lo,hi):
+                for j in self.interests[i]:
+                    if haves[j] and wantfunc(j):
+                        return j
+        if best is not None:
+            return best
+        return None
+
+
+    def am_I_complete(self):
+        return self.done
+    
+    def bump(self, piece):
+        l = self.interests[self.level_in_interests[piece]]
+        pos = self.pos_in_interests[piece]
+        del l[pos]
+        l.append(piece)
+        for i in range(pos,len(l)):
+            self.pos_in_interests[l[i]] = i
+        try:
+            self.started.remove(piece)
+        except:
+            pass
+
+    def set_priority(self, piece, p):
+        if self.superseed:
+            return False    # don't muck with this if you're a superseed
+        oldp = self.priority[piece]
+        if oldp == p:
+            return False
+        self.priority[piece] = p
+        if p == -1:
+            # when setting priority -1,
+            # make sure to cancel any downloads for this piece
+            if not self.has[piece]:
+                self._remove_from_interests(piece, True)
+            return True
+        if oldp == -1:
+            level = self.numhaves[piece] + (self.priority_step * p)
+            self.level_in_interests[piece] = level
+            if self.has[piece]:
+                return True
+            while len(self.interests) < level+1:
+                self.interests.append([])
+            l2 = self.interests[level]
+            parray = self.pos_in_interests
+            newp = randrange(len(l2)+1)
+            if newp == len(l2):
+                parray[piece] = len(l2)
+                l2.append(piece)
+            else:
+                old = l2[newp]
+                parray[old] = len(l2)
+                l2.append(old)
+                l2[newp] = piece
+                parray[piece] = newp
+            if self.removed_partials.has_key(piece):
+                del self.removed_partials[piece]
+                self.started.append(piece)
+            # now go to downloader and try requesting more
+            return True
+        numint = self.level_in_interests[piece]
+        newint = numint + ((p - oldp) * self.priority_step)
+        self.level_in_interests[piece] = newint
+        if self.has[piece]:
+            return False
+        while len(self.interests) < newint+1:
+            self.interests.append([])
+        self._shift_over(piece, self.interests[numint], self.interests[newint])
+        return False
+
+    def is_blocked(self, piece):
+        return self.priority[piece] < 0
+
+
+    def set_superseed(self):
+        assert self.done
+        self.superseed = True
+        self.seed_got_haves = [0] * self.numpieces
+        self._init_interests()  # assume everyone is disconnected
+
+    def next_have(self, connection, looser_upload):
+        if self.seed_time is None:
+            self.seed_time = clock()
+            return None
+        if clock() < self.seed_time+10:  # wait 10 seconds after seeing the first peers
+            return None                 # to give time to grab have lists
+        if not connection.upload.super_seeding:
+            return None
+        olddl = self.seed_connections.get(connection)
+        if olddl is None:
+            ip = connection.get_ip()
+            olddl = self.past_ips.get(ip)
+            if olddl is not None:                               # peer reconnected
+                self.seed_connections[connection] = olddl
+        if olddl is not None:
+            if looser_upload:
+                num = 1     # send a new have even if it hasn't spread that piece elsewhere
+            else:
+                num = 2
+            if self.seed_got_haves[olddl] < num:
+                return None
+            if not connection.upload.was_ever_interested:   # it never downloaded it?
+                connection.upload.skipped_count += 1
+                if connection.upload.skipped_count >= 3:    # probably another stealthed seed
+                    return -1                               # signal to close it
+        for tier in self.interests:
+            for piece in tier:
+                if not connection.download.have[piece]:
+                    seedint = self.level_in_interests[piece]
+                    self.level_in_interests[piece] += 1  # tweak it up one, so you don't duplicate effort
+                    if seedint == len(self.interests) - 1:
+                        self.interests.append([])
+                    self._shift_over(piece,
+                                self.interests[seedint], self.interests[seedint + 1])
+                    self.seed_got_haves[piece] = 0       # reset this
+                    self.seed_connections[connection] = piece
+                    connection.upload.seed_have_list.append(piece)
+                    return piece
+        return -1       # something screwy; terminate connection
+
+    def lost_peer(self, connection):
+        olddl = self.seed_connections.get(connection)
+        if olddl is None:
+            return
+        del self.seed_connections[connection]
+        self.past_ips[connection.get_ip()] = olddl
+        if self.seed_got_haves[olddl] == 1:
+            self.seed_got_haves[olddl] = 0

data/dist/BitTornado/BT1/Rerequester.py

@@ -0,0 +1,426 @@
+# Written by Bram Cohen
+# modified for multitracker operation by John Hoffman
+# see LICENSE.txt for license information
+
+from BitTornado.zurllib import urlopen, quote
+from urlparse import urlparse, urlunparse
+from socket import gethostbyname
+from btformats import check_peers
+from BitTornado.bencode import bdecode
+from threading import Thread, Lock
+from cStringIO import StringIO
+from traceback import print_exc
+from socket import error, gethostbyname
+from random import shuffle
+from sha import sha
+from time import time
+try:
+    from os import getpid
+except ImportError:
+    def getpid():
+        return 1
+    
+try:
+    True
+except:
+    True = 1
+    False = 0
+
+mapbase64 = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz.-'
+keys = {}
+basekeydata = str(getpid()) + repr(time()) + 'tracker'
+
+def add_key(tracker):
+    key = ''
+    for i in sha(basekeydata+tracker).digest()[-6:]:
+        key += mapbase64[ord(i) & 0x3F]
+    keys[tracker] = key
+
+def get_key(tracker):
+    try:
+        return "&key="+keys[tracker]
+    except:
+        add_key(tracker)
+        return "&key="+keys[tracker]
+
+class fakeflag:
+    def __init__(self, state=False):
+        self.state = state
+    def wait(self):
+        pass
+    def isSet(self):
+        return self.state
+
+class Rerequester:
+    def __init__(self, trackerlist, interval, sched, howmany, minpeers, 
+            connect, externalsched, amount_left, up, down,
+            port, ip, myid, infohash, timeout, errorfunc, excfunc,
+            maxpeers, doneflag, upratefunc, downratefunc,
+            unpauseflag = fakeflag(True),
+            seed_id = '', seededfunc = None, force_rapid_update = False ):
+
+        self.excfunc = excfunc
+        newtrackerlist = []        
+        for tier in trackerlist:
+            if len(tier)>1:
+                shuffle(tier)
+            newtrackerlist += [tier]
+        self.trackerlist = newtrackerlist
+        self.lastsuccessful = ''
+        self.rejectedmessage = 'rejected by tracker - '
+        
+        self.url = ('?info_hash=%s&peer_id=%s&port=%s' %
+            (quote(infohash), quote(myid), str(port)))
+        self.ip = ip
+        self.interval = interval
+        self.last = None
+        self.trackerid = None
+        self.announce_interval = 30 * 60
+        self.sched = sched
+        self.howmany = howmany
+        self.minpeers = minpeers
+        self.connect = connect
+        self.externalsched = externalsched
+        self.amount_left = amount_left
+        self.up = up
+        self.down = down
+        self.timeout = timeout
+        self.errorfunc = errorfunc
+        self.maxpeers = maxpeers
+        self.doneflag = doneflag
+        self.upratefunc = upratefunc
+        self.downratefunc = downratefunc
+        self.unpauseflag = unpauseflag
+        if seed_id:
+            self.url += '&seed_id='+quote(seed_id)
+        self.seededfunc = seededfunc
+        if seededfunc:
+            self.url += '&check_seeded=1'
+        self.force_rapid_update = force_rapid_update
+        self.last_failed = True
+        self.never_succeeded = True
+        self.errorcodes = {}
+        self.lock = SuccessLock()
+        self.special = None
+        self.stopped = False
+
+    def start(self):
+        self.sched(self.c, self.interval/2)
+        self.d(0)
+
+    def c(self):
+        if self.stopped:
+            return
+        if not self.unpauseflag.isSet() and (
+            self.howmany() < self.minpeers or self.force_rapid_update ):
+            self.announce(3, self._c)
+        else:
+            self._c()
+
+    def _c(self):
+        self.sched(self.c, self.interval)
+
+    def d(self, event = 3):
+        if self.stopped:
+            return
+        if not self.unpauseflag.isSet():
+            self._d()
+            return
+        self.announce(event, self._d)
+
+    def _d(self):
+        if self.never_succeeded:
+            self.sched(self.d, 60)  # retry in 60 seconds
+        elif self.force_rapid_update:
+            return
+        else:
+            self.sched(self.d, self.announce_interval)
+
+
+    def hit(self, event = 3):
+        if not self.unpauseflag.isSet() and (
+            self.howmany() < self.minpeers or self.force_rapid_update ):
+            self.announce(event)
+
+    def announce(self, event = 3, callback = lambda: None, specialurl = None):
+
+        if specialurl is not None:
+            s = self.url+'&uploaded=0&downloaded=0&left=1'   # don't add to statistics
+            if self.howmany() >= self.maxpeers:
+                s += '&numwant=0'
+            else:
+                s += '&no_peer_id=1&compact=1'
+            self.last_failed = True         # force true, so will display an error
+            self.special = specialurl
+            self.rerequest(s, callback)
+            return
+        
+        else:
+            s = ('%s&uploaded=%s&downloaded=%s&left=%s' %
+                (self.url, str(self.up()), str(self.down()), 
+                str(self.amount_left())))
+        if self.last is not None:
+            s += '&last=' + quote(str(self.last))
+        if self.trackerid is not None:
+            s += '&trackerid=' + quote(str(self.trackerid))
+        if self.howmany() >= self.maxpeers:
+            s += '&numwant=0'
+        else:
+            s += '&no_peer_id=1&compact=1'
+        if event != 3:
+            s += '&event=' + ['started', 'completed', 'stopped'][event]
+        if event == 2:
+            self.stopped = True
+        self.rerequest(s, callback)
+
+
+    def snoop(self, peers, callback = lambda: None):  # tracker call support
+        self.rerequest(self.url
+            +'&event=stopped&port=0&uploaded=0&downloaded=0&left=1&tracker=1&numwant='
+            +str(peers), callback)
+
+
+    def rerequest(self, s, callback):
+        if not self.lock.isfinished():  # still waiting for prior cycle to complete??
+            def retry(self = self, s = s, callback = callback):
+                self.rerequest(s, callback)
+            self.sched(retry,5)         # retry in 5 seconds
+            return
+        self.lock.reset()
+        rq = Thread(target = self._rerequest, args = [s, callback])
+        rq.setDaemon(False)
+        rq.start()
+
+    def _rerequest(self, s, callback):
+        try:
+            def fail (self = self, callback = callback):
+                self._fail(callback)
+            if self.ip:
+                try:
+                    s += '&ip=' + gethostbyname(self.ip)
+                except:
+                    self.errorcodes['troublecode'] = 'unable to resolve: '+self.ip
+                    self.externalsched(fail)
+            self.errorcodes = {}
+            if self.special is None:
+                for t in range(len(self.trackerlist)):
+                    for tr in range(len(self.trackerlist[t])):
+                        tracker  = self.trackerlist[t][tr]
+                        if self.rerequest_single(tracker, s, callback):
+                            if not self.last_failed and tr != 0:
+                                del self.trackerlist[t][tr]
+                                self.trackerlist[t] = [tracker] + self.trackerlist[t]
+                            return
+            else:
+                tracker = self.special
+                self.special = None
+                if self.rerequest_single(tracker, s, callback):
+                    return
+            # no success from any tracker
+            self.externalsched(fail)
+        except:
+            self.exception(callback)
+
+
+    def _fail(self, callback):
+        if ( (self.upratefunc() < 100 and self.downratefunc() < 100)
+             or not self.amount_left() ):
+            for f in ['rejected', 'bad_data', 'troublecode']:
+                if self.errorcodes.has_key(f):
+                    r = self.errorcodes[f]
+                    break
+            else:
+                r = 'Problem connecting to tracker - unspecified error'
+                return
+            self.errorfunc(r)
+
+        self.last_failed = True
+        self.lock.give_up()
+        self.externalsched(callback)
+
+
+    def rerequest_single(self, t, s, callback):
+        l = self.lock.set()
+        rq = Thread(target = self._rerequest_single, args = [t, s+get_key(t), l, callback])
+        rq.setDaemon(False)
+        rq.start()
+        self.lock.wait()
+        if self.lock.success:
+            self.lastsuccessful = t
+            self.last_failed = False
+            self.never_succeeded = False
+            return True
+        if not self.last_failed and self.lastsuccessful == t:
+            # if the last tracker hit was successful, and you've just tried the tracker
+            # you'd contacted before, don't go any further, just fail silently.
+            self.last_failed = True
+            self.externalsched(callback)
+            self.lock.give_up()
+            return True
+        return False    # returns true if it wants rerequest() to exit
+
+
+    def _rerequest_single(self, t, s, l, callback):
+        try:        
+            closer = [None]
+            def timedout(self = self, l = l, closer = closer):
+                if self.lock.trip(l):
+                    self.errorcodes['troublecode'] = 'Problem connecting to tracker - timeout exceeded'
+                    self.lock.unwait(l)
+                try:
+                    closer[0]()
+                except:
+                    pass
+                    
+            self.externalsched(timedout, self.timeout)
+
+            err = None
+            try:
+                h = urlopen(t+s)
+                closer[0] = h.close
+                data = h.read()
+            except (IOError, error), e:
+                err = 'Problem connecting to tracker - ' + str(e)
+            except:
+                err = 'Problem connecting to tracker'
+            try:
+                h.close()
+            except:
+                pass
+            if err:        
+                if self.lock.trip(l):
+                    self.errorcodes['troublecode'] = err
+                    self.lock.unwait(l)
+                return
+
+            if data == '':
+                if self.lock.trip(l):
+                    self.errorcodes['troublecode'] = 'no data from tracker'
+                    self.lock.unwait(l)
+                return
+            
+            try:
+                r = bdecode(data, sloppy=1)
+                check_peers(r)
+            except ValueError, e:
+                if self.lock.trip(l):
+                    self.errorcodes['bad_data'] = 'bad data from tracker - ' + str(e)
+                    self.lock.unwait(l)
+                return
+            
+            if r.has_key('failure reason'):
+                if self.lock.trip(l):
+                    self.errorcodes['rejected'] = self.rejectedmessage + r['failure reason']
+                    self.lock.unwait(l)
+                return
+                
+            if self.lock.trip(l, True):     # success!
+                self.lock.unwait(l)
+            else:
+                callback = lambda: None     # attempt timed out, don't do a callback
+
+            # even if the attempt timed out, go ahead and process data
+            def add(self = self, r = r, callback = callback):
+                self.postrequest(r, callback)
+            self.externalsched(add)
+        except:
+            self.exception(callback)
+
+
+    def postrequest(self, r, callback):
+        if r.has_key('warning message'):
+                self.errorfunc('warning from tracker - ' + r['warning message'])
+        self.announce_interval = r.get('interval', self.announce_interval)
+        self.interval = r.get('min interval', self.interval)
+        self.trackerid = r.get('tracker id', self.trackerid)
+        self.last = r.get('last')
+#        ps = len(r['peers']) + self.howmany()
+        p = r['peers']
+        peers = []
+        if type(p) == type(''):
+            for x in xrange(0, len(p), 6):
+                ip = '.'.join([str(ord(i)) for i in p[x:x+4]])
+                port = (ord(p[x+4]) << 8) | ord(p[x+5])
+                peers.append(((ip, port), 0))
+        else:
+            for x in p:
+                peers.append(((x['ip'].strip(), x['port']), x.get('peer id',0)))
+        ps = len(peers) + self.howmany()
+        if ps < self.maxpeers:
+            if self.doneflag.isSet():
+                if r.get('num peers', 1000) - r.get('done peers', 0) > ps * 1.2:
+                    self.last = None
+            else:
+                if r.get('num peers', 1000) > ps * 1.2:
+                    self.last = None
+        if self.seededfunc and r.get('seeded'):
+            self.seededfunc()
+        elif peers:
+            shuffle(peers)
+            self.connect(peers)
+        callback()
+
+    def exception(self, callback):
+        data = StringIO()
+        print_exc(file = data)
+        def r(s = data.getvalue(), callback = callback):
+            if self.excfunc:
+                self.excfunc(s)
+            else:
+                print s
+            callback()
+        self.externalsched(r)
+
+
+class SuccessLock:
+    def __init__(self):
+        self.lock = Lock()
+        self.pause = Lock()
+        self.code = 0L
+        self.success = False
+        self.finished = True
+
+    def reset(self):
+        self.success = False
+        self.finished = False
+
+    def set(self):
+        self.lock.acquire()
+        if not self.pause.locked():
+            self.pause.acquire()
+        self.first = True
+        self.code += 1L
+        self.lock.release()
+        return self.code
+
+    def trip(self, code, s = False):
+        self.lock.acquire()
+        try:
+            if code == self.code and not self.finished:
+                r = self.first
+                self.first = False
+                if s:
+                    self.finished = True
+                    self.success = True
+                return r
+        finally:
+            self.lock.release()
+
+    def give_up(self):
+        self.lock.acquire()
+        self.success = False
+        self.finished = True
+        self.lock.release()
+
+    def wait(self):
+        self.pause.acquire()
+
+    def unwait(self, code):
+        if code == self.code and self.pause.locked():
+            self.pause.release()
+
+    def isfinished(self):
+        self.lock.acquire()
+        x = self.finished
+        self.lock.release()
+        return x