murder 0.0.0.pre

data/dist/BitTornado/BT1/StreamCheck.py

@@ -0,0 +1,135 @@
+# Written by Bram Cohen
+# see LICENSE.txt for license information
+
+from cStringIO import StringIO
+from binascii import b2a_hex
+from socket import error as socketerror
+from urllib import quote
+from traceback import print_exc
+import Connecter
+try:
+    True
+except:
+    True = 1
+    False = 0
+
+DEBUG = False
+
+
+protocol_name = 'BitTorrent protocol'
+option_pattern = chr(0)*8
+
+def toint(s):
+    return long(b2a_hex(s), 16)
+
+def tobinary(i):
+    return (chr(i >> 24) + chr((i >> 16) & 0xFF) + 
+        chr((i >> 8) & 0xFF) + chr(i & 0xFF))
+
+hexchars = '0123456789ABCDEF'
+hexmap = []
+for i in xrange(256):
+    hexmap.append(hexchars[(i&0xF0)/16]+hexchars[i&0x0F])
+
+def tohex(s):
+    r = []
+    for c in s:
+        r.append(hexmap[ord(c)])
+    return ''.join(r)
+
+def make_readable(s):
+    if not s:
+        return ''
+    if quote(s).find('%') >= 0:
+        return tohex(s)
+    return '"'+s+'"'
+   
+def toint(s):
+    return long(b2a_hex(s), 16)
+
+# header, reserved, download id, my id, [length, message]
+
+streamno = 0
+
+
+class StreamCheck:
+    def __init__(self):
+        global streamno
+        self.no = streamno
+        streamno += 1
+        self.buffer = StringIO()
+        self.next_len, self.next_func = 1, self.read_header_len
+
+    def read_header_len(self, s):
+        if ord(s) != len(protocol_name):
+            print self.no, 'BAD HEADER LENGTH'
+        return len(protocol_name), self.read_header
+
+    def read_header(self, s):
+        if s != protocol_name:
+            print self.no, 'BAD HEADER'
+        return 8, self.read_reserved
+
+    def read_reserved(self, s):
+        return 20, self.read_download_id
+
+    def read_download_id(self, s):
+        if DEBUG:
+            print self.no, 'download ID ' + tohex(s)
+        return 20, self.read_peer_id
+
+    def read_peer_id(self, s):
+        if DEBUG:
+            print self.no, 'peer ID' + make_readable(s)
+        return 4, self.read_len
+
+    def read_len(self, s):
+        l = toint(s)
+        if l > 2 ** 23:
+            print self.no, 'BAD LENGTH: '+str(l)+' ('+s+')'
+        return l, self.read_message
+
+    def read_message(self, s):
+        if not s:
+            return 4, self.read_len
+        m = s[0]
+        if ord(m) > 8:
+            print self.no, 'BAD MESSAGE: '+str(ord(m))
+        if m == Connecter.REQUEST:
+            if len(s) != 13:
+                print self.no, 'BAD REQUEST SIZE: '+str(len(s))
+                return 4, self.read_len
+            index = toint(s[1:5])
+            begin = toint(s[5:9])
+            length = toint(s[9:])
+            print self.no, 'Request: '+str(index)+': '+str(begin)+'-'+str(begin)+'+'+str(length)
+        elif m == Connecter.CANCEL:
+            if len(s) != 13:
+                print self.no, 'BAD CANCEL SIZE: '+str(len(s))
+                return 4, self.read_len
+            index = toint(s[1:5])
+            begin = toint(s[5:9])
+            length = toint(s[9:])
+            print self.no, 'Cancel: '+str(index)+': '+str(begin)+'-'+str(begin)+'+'+str(length)
+        elif m == Connecter.PIECE:
+            index = toint(s[1:5])
+            begin = toint(s[5:9])
+            length = len(s)-9
+            print self.no, 'Piece: '+str(index)+': '+str(begin)+'-'+str(begin)+'+'+str(length)
+        else:
+            print self.no, 'Message '+str(ord(m))+' (length '+str(len(s))+')'
+        return 4, self.read_len
+
+    def write(self, s):
+        while True:
+            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)
+            self.next_len, self.next_func = x

data/dist/BitTornado/BT1/T2T.py

@@ -0,0 +1,193 @@
+# Written by John Hoffman
+# see LICENSE.txt for license information
+
+from Rerequester import Rerequester
+from urllib import quote
+from threading import Event
+from random import randrange
+from string import lower
+import sys
+import __init__
+try:
+    True
+except:
+    True = 1
+    False = 0
+
+DEBUG = True
+
+
+def excfunc(x):
+    print x
+
+class T2TConnection:
+    def __init__(self, myid, tracker, hash, interval, peers, timeout,
+                     rawserver, disallow, isdisallowed):
+        self.tracker = tracker
+        self.interval = interval
+        self.hash = hash
+        self.operatinginterval = interval
+        self.peers = peers
+        self.rawserver = rawserver
+        self.disallow = disallow
+        self.isdisallowed = isdisallowed
+        self.active = True
+        self.busy = False
+        self.errors = 0
+        self.rejected = 0
+        self.trackererror = False
+        self.peerlists = []
+
+        self.rerequester = Rerequester([[tracker]], interval,
+            rawserver.add_task, lambda: 0, peers, self.addtolist, 
+            rawserver.add_task, lambda: 1, 0, 0, 0, '',
+            myid, hash, timeout, self.errorfunc, excfunc, peers, Event(),
+            lambda: 0, lambda: 0)
+
+        if self.isactive():
+            rawserver.add_task(self.refresh, randrange(int(self.interval/10), self.interval))
+                                        # stagger announces
+
+    def isactive(self):
+        if self.isdisallowed(self.tracker):    # whoops!
+            self.deactivate()
+        return self.active
+            
+    def deactivate(self):
+        self.active = False
+
+    def refresh(self):
+        if not self.isactive():
+            return
+        self.lastsuccessful = True
+        self.newpeerdata = []
+        if DEBUG:
+            print 'contacting %s for info_hash=%s' % (self.tracker, quote(self.hash))
+        self.rerequester.snoop(self.peers, self.callback)
+
+    def callback(self):
+        self.busy = False
+        if self.lastsuccessful:
+            self.errors = 0
+            self.rejected = 0
+            if self.rerequester.announce_interval > (3*self.interval):
+                # I think I'm stripping from a regular tracker; boost the number of peers requested
+                self.peers = int(self.peers * (self.rerequester.announce_interval / self.interval))
+            self.operatinginterval = self.rerequester.announce_interval
+            if DEBUG:
+                print ("%s with info_hash=%s returned %d peers" %
+                        (self.tracker, quote(self.hash), len(self.newpeerdata)))
+            self.peerlists.append(self.newpeerdata)
+            self.peerlists = self.peerlists[-10:]  # keep up to the last 10 announces
+        if self.isactive():
+            self.rawserver.add_task(self.refresh, self.operatinginterval)
+
+    def addtolist(self, peers):
+        for peer in peers:
+            self.newpeerdata.append((peer[1],peer[0][0],peer[0][1]))
+        
+    def errorfunc(self, r):
+        self.lastsuccessful = False
+        if DEBUG:
+            print "%s with info_hash=%s gives error: '%s'" % (self.tracker, quote(self.hash), r)
+        if r == self.rerequester.rejectedmessage + 'disallowed':   # whoops!
+            if DEBUG:
+                print ' -- disallowed - deactivating'
+            self.deactivate()
+            self.disallow(self.tracker)   # signal other torrents on this tracker
+            return
+        if lower(r[:8]) == 'rejected': # tracker rejected this particular torrent
+            self.rejected += 1
+            if self.rejected == 3:     # rejected 3 times
+                if DEBUG:
+                    print ' -- rejected 3 times - deactivating'
+                self.deactivate()
+            return
+        self.errors += 1
+        if self.errors >= 3:                         # three or more errors in a row
+            self.operatinginterval += self.interval  # lengthen the interval
+            if DEBUG:
+                print ' -- lengthening interval to '+str(self.operatinginterval)+' seconds'
+
+    def harvest(self):
+        x = []
+        for list in self.peerlists:
+            x += list
+        self.peerlists = []
+        return x
+
+
+class T2TList:
+    def __init__(self, enabled, trackerid, interval, maxpeers, timeout, rawserver):
+        self.enabled = enabled
+        self.trackerid = trackerid
+        self.interval = interval
+        self.maxpeers = maxpeers
+        self.timeout = timeout
+        self.rawserver = rawserver
+        self.list = {}
+        self.torrents = {}
+        self.disallowed = {}
+        self.oldtorrents = []
+
+    def parse(self, allowed_list):
+        if not self.enabled:
+            return
+
+        # step 1:  Create a new list with all tracker/torrent combinations in allowed_dir        
+        newlist = {}
+        for hash, data in allowed_list.items():
+            if data.has_key('announce-list'):
+                for tier in data['announce-list']:
+                    for tracker in tier:
+                        self.disallowed.setdefault(tracker, False)
+                        newlist.setdefault(tracker, {})
+                        newlist[tracker][hash] = None # placeholder
+                            
+        # step 2:  Go through and copy old data to the new list.
+        # if the new list has no place for it, then it's old, so deactivate it
+        for tracker, hashdata in self.list.items():
+            for hash, t2t in hashdata.items():
+                if not newlist.has_key(tracker) or not newlist[tracker].has_key(hash):
+                    t2t.deactivate()                # this connection is no longer current
+                    self.oldtorrents += [t2t]
+                        # keep it referenced in case a thread comes along and tries to access.
+                else:
+                    newlist[tracker][hash] = t2t
+            if not newlist.has_key(tracker):
+                self.disallowed[tracker] = False    # reset when no torrents on it left
+
+        self.list = newlist
+        newtorrents = {}
+
+        # step 3:  If there are any entries that haven't been initialized yet, do so.
+        # At the same time, copy all entries onto the by-torrent list.
+        for tracker, hashdata in newlist.items():
+            for hash, t2t in hashdata.items():
+                if t2t is None:
+                    hashdata[hash] = T2TConnection(self.trackerid, tracker, hash,
+                                        self.interval, self.maxpeers, self.timeout,
+                                        self.rawserver, self._disallow, self._isdisallowed)
+                newtorrents.setdefault(hash,[])
+                newtorrents[hash] += [hashdata[hash]]
+                
+        self.torrents = newtorrents
+
+        # structures:
+        # list = {tracker: {hash: T2TConnection, ...}, ...}
+        # torrents = {hash: [T2TConnection, ...]}
+        # disallowed = {tracker: flag, ...}
+        # oldtorrents = [T2TConnection, ...]
+
+    def _disallow(self,tracker):
+        self.disallowed[tracker] = True
+
+    def _isdisallowed(self,tracker):
+        return self.disallowed[tracker]
+
+    def harvest(self,hash):
+        harvest = []
+        if self.enabled:
+            for t2t in self.torrents[hash]:
+                harvest += t2t.harvest()
+        return harvest

data/dist/BitTornado/BT1/Uploader.py

@@ -0,0 +1,145 @@
+# Written by Bram Cohen
+# see LICENSE.txt for license information
+
+from BitTornado.CurrentRateMeasure import Measure
+
+try:
+    True
+except:
+    True = 1
+    False = 0
+
+class Upload:
+    def __init__(self, connection, ratelimiter, totalup, choker, storage,
+                 picker, config):
+        self.connection = connection
+        self.ratelimiter = ratelimiter
+        self.totalup = totalup
+        self.choker = choker
+        self.storage = storage
+        self.picker = picker
+        self.config = config
+        self.max_slice_length = config['max_slice_length']
+        self.choked = True
+        self.cleared = True
+        self.interested = False
+        self.super_seeding = False
+        self.buffer = []
+        self.measure = Measure(config['max_rate_period'], config['upload_rate_fudge'])
+        self.was_ever_interested = False
+        if storage.get_amount_left() == 0:
+            if choker.super_seed:
+                self.super_seeding = True   # flag, and don't send bitfield
+                self.seed_have_list = []    # set from piecepicker
+                self.skipped_count = 0
+            else:
+                if config['breakup_seed_bitfield']:
+                    bitfield, msgs = storage.get_have_list_cloaked()
+                    connection.send_bitfield(bitfield)
+                    for have in msgs:
+                        connection.send_have(have)
+                else:
+                    connection.send_bitfield(storage.get_have_list())
+        else:
+            if storage.do_I_have_anything():
+                connection.send_bitfield(storage.get_have_list())
+        self.piecedl = None
+        self.piecebuf = None
+
+    def got_not_interested(self):
+        if self.interested:
+            self.interested = False
+            del self.buffer[:]
+            self.piecedl = None
+            if self.piecebuf:
+                self.piecebuf.release()
+            self.piecebuf = None
+            self.choker.not_interested(self.connection)
+
+    def got_interested(self):
+        if not self.interested:
+            self.interested = True
+            self.was_ever_interested = True
+            self.choker.interested(self.connection)
+
+    def get_upload_chunk(self):
+        if self.choked or not self.buffer:
+            return None
+        index, begin, length = self.buffer.pop(0)
+        if self.config['buffer_reads']:
+            if index != self.piecedl:
+                if self.piecebuf:
+                    self.piecebuf.release()
+                self.piecedl = index
+                self.piecebuf = self.storage.get_piece(index, 0, -1)
+            try:
+                piece = self.piecebuf[begin:begin+length]
+                assert len(piece) == length
+            except:     # fails if storage.get_piece returns None or if out of range
+                self.connection.close()
+                return None
+        else:
+            if self.piecebuf:
+                self.piecebuf.release()
+                self.piecedl = None
+            piece = self.storage.get_piece(index, begin, length)
+            if piece is None:
+                self.connection.close()
+                return None
+        self.measure.update_rate(len(piece))
+        self.totalup.update_rate(len(piece))
+        return (index, begin, piece)
+
+    def got_request(self, index, begin, length):
+        if ( (self.super_seeding and not index in self.seed_have_list)
+                   or not self.interested or length > self.max_slice_length ):
+            self.connection.close()
+            return
+        if not self.cleared:
+            self.buffer.append((index, begin, length))
+        if not self.choked and self.connection.next_upload is None:
+                self.ratelimiter.queue(self.connection)
+
+
+    def got_cancel(self, index, begin, length):
+        try:
+            self.buffer.remove((index, begin, length))
+        except ValueError:
+            pass
+
+    def choke(self):
+        if not self.choked:
+            self.choked = True
+            self.connection.send_choke()
+        self.piecedl = None
+        if self.piecebuf:
+            self.piecebuf.release()
+            self.piecebuf = None
+
+    def choke_sent(self):
+        del self.buffer[:]
+        self.cleared = True
+
+    def unchoke(self):
+        if self.choked:
+            self.choked = False
+            self.cleared = False
+            self.connection.send_unchoke()
+        
+    def disconnected(self):
+        if self.piecebuf:
+            self.piecebuf.release()
+            self.piecebuf = None
+
+    def is_choked(self):
+        return self.choked
+        
+    def is_interested(self):
+        return self.interested
+
+    def has_queries(self):
+        return not self.choked and len(self.buffer) > 0
+
+    def get_rate(self):
+        return self.measure.get_rate()
+