murder 0.0.0.pre

data/dist/BitTornado/ConnChoice.py

@@ -0,0 +1,31 @@
+connChoices=(
+    {'name':'automatic',
+     'rate':{'min':0, 'max':5000, 'def': 0},
+     'conn':{'min':0, 'max':100,  'def': 0},
+     'automatic':1},
+    {'name':'unlimited',
+     'rate':{'min':0, 'max':5000, 'def': 0, 'div': 50},
+     'conn':{'min':4, 'max':100,  'def': 4}},
+    {'name':'dialup/isdn',
+     'rate':{'min':3,   'max':   8, 'def':  5},
+     'conn':{'min':2, 'max':  3, 'def': 2},
+     'initiate': 12},
+    {'name':'dsl/cable slow',
+     'rate':{'min':10,  'max':  48, 'def': 13},
+     'conn':{'min':4, 'max': 20, 'def': 4}},
+    {'name':'dsl/cable fast',
+     'rate':{'min':20,  'max': 100, 'def': 40},
+     'conn':{'min':4, 'max': 30, 'def': 6}},
+    {'name':'T1',
+     'rate':{'min':100, 'max': 300, 'def':150},
+     'conn':{'min':4, 'max': 40, 'def':10}},
+    {'name':'T3+',
+     'rate':{'min':400, 'max':2000, 'def':500},
+     'conn':{'min':4, 'max':100, 'def':20}},
+    {'name':'seeder',
+     'rate':{'min':0, 'max':5000, 'def':0, 'div': 50},
+     'conn':{'min':1, 'max':100, 'def':1}},
+    {'name':'SUPER-SEED', 'super-seed':1}
+     )
+
+connChoiceList = map(lambda x:x['name'], connChoices)

data/dist/BitTornado/CreateIcons.py

@@ -0,0 +1,105 @@
+# Generated from bt_MakeCreateIcons - 05/10/04 22:15:33
+# T-0.3.0 (BitTornado)
+
+from binascii import a2b_base64
+from zlib import decompress
+from os.path import join
+
+icons = {
+    "icon_bt.ico":
+        "eJyt1K+OFEEQx/FaQTh5GDRZhSQpiUHwCrxCBYXFrjyJLXeXEARPsZqUPMm+" +
+        "AlmP+PGtngoLDji69zMz2zt/qqtr1mxHv7621d4+MnvK/jl66Bl2drV+e7Wz" +
+        "S/v12A7rY4fDtuvOwfF4tOPXo52/fLLz+WwpWd6nqRXHKXux39sTrtnjNd7g" +
+        "PW7wGSd860f880kffjvJ2QYS1Zcw4AjcoaA5yRFIFDQXOgKJguZmjkCioB4T" +
+        "Y2CqxpTXA7sHEgVNEC8RSBQ0gfk7xtknCupgk3EEEgXlNgFHIFHQTMoRSBQ0" +
+        "E+1ouicKmsk7AomCJiGOQKKgSZIjkChoEucIJAqaZDoCiYImwb4iydULmqQ7" +
+        "AomC1kLcEQ/jSBQ0i+MIJAqaBXMEElVdi9siOgKJgmZhfWWlVjTddXW/FtsR" +
+        "SBQ0BeAIJAqaonAEEgVNoTgCiYKmeByBREHaqiVWRtSRrAJzBBIFTdE5AomC" +
+        "phBPpxPP57dVkDfrTl063nUVnWe383fZx9tb3uN+o7U+BLDtuvcQm8d/27Y/" +
+        "jO3o5/ay+YPv/+f6y30e1OyB7QcsGWFj",
+    "icon_done.ico":
+        "eJyt1K2OVEEQhuEaQbJyMWgyCklSEoPgFvYWKigsduRKbLndhCC4itGk5Erm" +
+        "Fsh4xMdbfSoMOGDpnuf89Jyf6uqaMdvRr69ttbdPzJ6xf4Eeeo6dXa3vXu/s" +
+        "0n49tsP62OGw7bpzcDwe7fj1aOcvn+x8PltKlg9pasVxyl7u9/aUe/Z4gxu8" +
+        "xy0+44Rv/Yp/vujDbxc520Ci+hYGHIF7FDQXOQKJguZGRyBR0DzMEUgU1GNi" +
+        "DEzVmPJ6YfdAoqAJ4hUCiYImMH/HOPtEQR1sMo5AoqDcJuAIJAqaSTkCiYJm" +
+        "oh1N90RBM3lHIFHQJMQRSBQ0SXIEEgVN4hyBREGTTEcgUdAk2FckuXpBk3RH" +
+        "IFHQWoh74mEciYJmcRyBREGzYI5AoqprcVtERyBR0Cysr6zUiqa7rh7WYjsC" +
+        "iYKmAByBREFTFI5AoqApFEcgUdAUjyOQKEhbtcTKiDqSVWCOQKKgKTpHIFHQ" +
+        "FOLpdOL9fLcK8nY9qUvHu66i8+x2/i77eHfH77h/0VofAth23Xuoz/+2bX8Y" +
+        "29HP7WXzB+f/5/7Lcx7V7JHtB9dPG3I=",
+    "black.ico":
+        "eJzt1zsOgkAYReFLLCztjJ2UlpLY485kOS7DpbgESwqTcQZDghjxZwAfyfl0" +
+        "LIieGzUWSom/pan840rHnbSUtPHHX9Je9+tAh2ybNe8TZZ/vk8ajJ4zl6JVJ" +
+        "+xFx+0R03Djx1/2B8bcT9L/bt0+4Wq+4se8e/VTfMvGqb4n3nYiIGz+lvt9s" +
+        "9EpE2T4xJN4xNFYWU6t+JWXuXDFzTom7SodSyi/S+iwtwjlJ80KaNY/C34rW" +
+        "aT8nvK5uhF7ohn7Yqfb87kffLAAAAAAAAAAAAAAAAAAAGMUNy7dADg==",
+    "blue.ico":
+        "eJzt10EOwUAYhuGv6cLSTux06QD2dTM9jmM4iiNYdiEZ81cIFTWddtDkfbQW" +
+        "De8XogtS5h9FIf+81H4jLSSt/ekvaavrdaCDez4SZV+PpPHoicBy9ErSfkQ8" +
+        "fCI6Hjgx6f7A+McJ+r/t95i46xMP7bf8Uz9o4k0/XMT338voP5shK0MkjXcM" +
+        "YSqam6Qunatyf7Nk7iztaqk8SaujNLfzIM0qKX88ZX8rWmf7Nfa+W8N61rW+" +
+        "7TR7fverHxYAAAAAAAAAAAAAAAAAAIziApVZ444=",
+    "green.ico":
+        "eJzt1zEOgjAAheFHGBzdjJuMHsAdbybxNB7Do3gERwaT2mJIBCOWlqok/yc4" +
+        "EP1fNDIoZfZRFLLPa5120krS1p72kvZ6XAeGHLtHouzrkTQePOFZDl5J2g+I" +
+        "+08Exz0nZt2PjH+coP/bvveEaY2L+/VN13/1PSbe9v0FfP+jTP6ziVmJkTQ+" +
+        "MISZaO6SujSmyu3dkpmbdKil8iptLtLSnWdpUUn58yn3t6J39l/j3tc2XM91" +
+        "Xd/tNHt296sfFgAAAAAAAAAAAAAAAAAATOIOVLEoDg==",
+    "red.ico":
+        "eJzt10EOwUAYhuGv6cLSTux06QD2dTOO4xiO4giWXUjG/BVCRTuddtDkfbQW" +
+        "De8XogtS5h9FIf+81GEjLSSt/ekvaavbdaCVez0SZd+PpPHoicBy9ErSfkQ8" +
+        "fCI6Hjgx6f7AeOcE/d/2QyceesaD+g1/1u+e+NwPF/H99zL6z2bIyhBJ4y1D" +
+        "mIb6LqlK5/a5v1syd5F2lVSepdVJmtt5lGZ7KX8+ZX8rGmfzNfa+e8N61rW+" +
+        "7dR7fverHxYAAAAAAAAAAAAAAAAAAIziCpgs444=",
+    "white.ico":
+        "eJzt1zsOgkAYReFLKCztjJ2ULsAed6bLcRnuwYTaJVhSmIwzGBLEiD8D+EjO" +
+        "p2NB9NyosVBK/C3L5B+XOmykhaS1P/6StrpfBzoUp6J5nyj7fJ80Hj1hLEev" +
+        "TNqPiNsnouPGib/uD4y/naD/3b59wtV6xY199+in+paJV31LvO9ERNz4KfX9" +
+        "ZqNXIsr2iSHxjqGxspha9Sspc+f2qXNK3FXalVJ+kVZnaR7OUZrtpbR5FP5W" +
+        "tE77OeF1dSP0Qjf0w06153c/+mYBAAAAAAAAAAAAAAAAAMAobj//I7s=",
+    "yellow.ico":
+        "eJzt1zsOgkAYReFLKCztjJ2ULsAedybLcRkuxSVYUpiM82M0ihGHgVFJzidY" +
+        "ED03vgqlzN+KQv5+qf1GWkha+9Nf0lbX60AX556ORNnXI2k8eiKwHL2StB8R" +
+        "D5+IjgdOTLo/MP5xgv5v+8ETd/3iYf2W/+oHTLzth4t4/3sZ/WszZGWIpPGO" +
+        "IUxE8yupS+eq3H9smTtLu1oqT9LqKM3tPEizSsofT9nfitbZfow979awnnWt" +
+        "bzvNnt/96osFAAAAAAAAAAAAAAAAAACjuABhjmIs",
+    "black1.ico":
+        "eJzt0zEOgkAUANEhFpZSGTstTWzkVt5Cj8ZROAIHMNGPWBCFDYgxMZkHn2Iz" +
+        "G5YCyOLKc+K54XSANbCPiSV2tOt/qjgW3XtSnN41FH/Qv29Jx/P7qefp7W8P" +
+        "4z85HQ+9JRG/7BpTft31DPUKyiVcFjEZzQ/TTtdzrWnKmCr6evv780qSJEmS" +
+        "JEmSJEmSJEmSpPnunVFDcA==",
+    "green1.ico":
+        "eJzt0zEKwkAQRuEXLCyTSuy0DHgxb6F4shzFI+QAgpkkFoombowIwvt2Z4vh" +
+        "X5gtFrJYRUGca/Y7WAFlVLTY0vf/1elxTwqP3xoKf5B/vjIenp+fOs+r/LWT" +
+        "/uQ34aGpUqQnv+1ygDqHagnHRVRG+2H6unfrtZkq6hz5evP7eSVJkiRJkiRJ" +
+        "kiRJkiRJ0nwNoWQ+AA==",
+    "yellow1.ico":
+        "eJzt0zEKwkAQRuEXLCxNJXZaCl7MW8Sj5SgeIQcQ4oS1UDTJxkhAeN/ubDH8" +
+        "C7PFQhGrLIlzx/kEW+AYFS0OpP6/atuXPSk8fKsv/EX+/cpweH5+6jyf8kn+" +
+        "k0fCfVPlyE/+2q2CZgP1Gi6rqILuw6R69uh1mTrqGvlmv/y8kiRJkiRJkiRJ" +
+        "kiRJkiRpvjsp9L8k",
+    "alloc.gif":
+        "eJxz93SzsEw0YRBh+M4ABi0MS3ue///P8H8UjIIRBhR/sjAyMDAx6IAyAihP" +
+        "MHAcYWDlkPHYsOBgM4ewVsyJDQsPNzEoebF8CHjo0smjH3dmRsDjI33C7Dw3" +
+        "MiYuOtjNyDShRSNwyemJguJJKhaGS32nGka61Vg2NJyYKRd+bY+nwtMzjbqV" +
+        "Qh84gxMCJgnlL4vJuqJyaa5NfFLNLsNVV2a7syacfVWkHd4bv7RN1ltM7ejm" +
+        "tMtNZ19Oyb02p8C3aqr3dr2GbXl/7fZyOej5rW653WZ7MzzHZV+v7O2/EZM+" +
+        "Pt45kbX6ScWHNWfOilo3n5thucXv8org1XF3DRQYrAEWiVY3"
+}
+
+def GetIcons():
+    return icons.keys()
+
+def CreateIcon(icon, savedir):
+    try:
+        f = open(join(savedir,icon),"wb")
+        f.write(decompress(a2b_base64(icons[icon])))
+        success = 1
+    except:
+        success = 0
+    try:
+        f.close()
+    except:
+        pass
+    return success

data/dist/BitTornado/CurrentRateMeasure.py

@@ -0,0 +1,37 @@
+# Written by Bram Cohen
+# see LICENSE.txt for license information
+
+from clock import clock
+
+class Measure:
+    def __init__(self, max_rate_period, fudge = 1):
+        self.max_rate_period = max_rate_period
+        self.ratesince = clock() - fudge
+        self.last = self.ratesince
+        self.rate = 0.0
+        self.total = 0l
+
+    def update_rate(self, amount):
+        self.total += amount
+        t = clock()
+        self.rate = (self.rate * (self.last - self.ratesince) + 
+            amount) / (t - self.ratesince + 0.0001)
+        self.last = t
+        if self.ratesince < t - self.max_rate_period:
+            self.ratesince = t - self.max_rate_period
+
+    def get_rate(self):
+        self.update_rate(0)
+        return self.rate
+
+    def get_rate_noupdate(self):
+        return self.rate
+
+    def time_until_rate(self, newrate):
+        if self.rate <= newrate:
+            return 0
+        t = clock() - self.ratesince
+        return ((self.rate * t) / newrate) - t
+
+    def get_total(self):
+        return self.total

data/dist/BitTornado/HTTPHandler.py

@@ -0,0 +1,167 @@
+# Written by Bram Cohen
+# see LICENSE.txt for license information
+
+from cStringIO import StringIO
+from sys import stdout
+import time
+from clock import clock
+from gzip import GzipFile
+try:
+    True
+except:
+    True = 1
+    False = 0
+
+DEBUG = False
+
+weekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
+
+months = [None, 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+    'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+
+class HTTPConnection:
+    def __init__(self, handler, connection):
+        self.handler = handler
+        self.connection = connection
+        self.buf = ''
+        self.closed = False
+        self.done = False
+        self.donereading = False
+        self.next_func = self.read_type
+
+    def get_ip(self):
+        return self.connection.get_ip()
+
+    def data_came_in(self, data):
+        if self.donereading or self.next_func is None:
+            return True
+        self.buf += data
+        while True:
+            try:
+                i = self.buf.index('\n')
+            except ValueError:
+                return True
+            val = self.buf[:i]
+            self.buf = self.buf[i+1:]
+            self.next_func = self.next_func(val)
+            if self.donereading:
+                return True
+            if self.next_func is None or self.closed:
+                return False
+
+    def read_type(self, data):
+        self.header = data.strip()
+        words = data.split()
+        if len(words) == 3:
+            self.command, self.path, garbage = words
+            self.pre1 = False
+        elif len(words) == 2:
+            self.command, self.path = words
+            self.pre1 = True
+            if self.command != 'GET':
+                return None
+        else:
+            return None
+        if self.command not in ('HEAD', 'GET'):
+            return None
+        self.headers = {}
+        return self.read_header
+
+    def read_header(self, data):
+        data = data.strip()
+        if data == '':
+            self.donereading = True
+            if self.headers.get('accept-encoding','').find('gzip') > -1:
+                self.encoding = 'gzip'
+            else:
+                self.encoding = 'identity'
+            r = self.handler.getfunc(self, self.path, self.headers)
+            if r is not None:
+                self.answer(r)
+            return None
+        try:
+            i = data.index(':')
+        except ValueError:
+            return None
+        self.headers[data[:i].strip().lower()] = data[i+1:].strip()
+        if DEBUG:
+            print data[:i].strip() + ": " + data[i+1:].strip()
+        return self.read_header
+
+    def answer(self, (responsecode, responsestring, headers, data)):
+        if self.closed:
+            return
+        if self.encoding == 'gzip':
+            compressed = StringIO()
+            gz = GzipFile(fileobj = compressed, mode = 'wb', compresslevel = 9)
+            gz.write(data)
+            gz.close()
+            cdata = compressed.getvalue()
+            if len(cdata) >= len(data):
+                self.encoding = 'identity'
+            else:
+                if DEBUG:
+                   print "Compressed: %i  Uncompressed: %i\n" % (len(cdata),len(data))
+                data = cdata
+                headers['Content-Encoding'] = 'gzip'
+
+        # i'm abusing the identd field here, but this should be ok
+        if self.encoding == 'identity':
+            ident = '-'
+        else:
+            ident = self.encoding
+        self.handler.log( self.connection.get_ip(), ident, '-',
+                          self.header, responsecode, len(data),
+                          self.headers.get('referer','-'),
+                          self.headers.get('user-agent','-') )
+        self.done = True
+        r = StringIO()
+        r.write('HTTP/1.0 ' + str(responsecode) + ' ' + 
+            responsestring + '\r\n')
+        if not self.pre1:
+            headers['Content-Length'] = len(data)
+            for key, value in headers.items():
+                r.write(key + ': ' + str(value) + '\r\n')
+            r.write('\r\n')
+        if self.command != 'HEAD':
+            r.write(data)
+        self.connection.write(r.getvalue())
+        if self.connection.is_flushed():
+            self.connection.shutdown(1)
+
+class HTTPHandler:
+    def __init__(self, getfunc, minflush):
+        self.connections = {}
+        self.getfunc = getfunc
+        self.minflush = minflush
+        self.lastflush = clock()
+
+    def external_connection_made(self, connection):
+        self.connections[connection] = HTTPConnection(self, connection)
+
+    def connection_flushed(self, connection):
+        if self.connections[connection].done:
+            connection.shutdown(1)
+
+    def connection_lost(self, connection):
+        ec = self.connections[connection]
+        ec.closed = True
+        del ec.connection
+        del ec.next_func
+        del self.connections[connection]
+
+    def data_came_in(self, connection, data):
+        c = self.connections[connection]
+        if not c.data_came_in(data) and not c.closed:
+            c.connection.shutdown(1)
+
+    def log(self, ip, ident, username, header,
+            responsecode, length, referrer, useragent):
+        year, month, day, hour, minute, second, a, b, c = time.localtime(time.time())
+        print '%s %s %s [%02d/%3s/%04d:%02d:%02d:%02d] "%s" %i %i "%s" "%s"' % (
+            ip, ident, username, day, months[month], year, hour,
+            minute, second, header, responsecode, length, referrer, useragent)
+        t = clock()
+        if t - self.lastflush > self.minflush:
+            self.lastflush = t
+            stdout.flush()

data/dist/BitTornado/PSYCO.py

@@ -0,0 +1,5 @@
+# edit this file to enable/disable Psyco
+# psyco = 1 -- enabled
+# psyco = 0 -- disabled
+
+psyco = 0

data/dist/BitTornado/RateLimiter.py

@@ -0,0 +1,153 @@
+# Written by Bram Cohen
+# see LICENSE.txt for license information
+
+from traceback import print_exc
+from binascii import b2a_hex
+from clock import clock
+from CurrentRateMeasure import Measure
+from cStringIO import StringIO
+from math import sqrt
+
+try:
+    True
+except:
+    True = 1
+    False = 0
+try:
+    sum([1])
+except:
+    sum = lambda a: reduce(lambda x,y: x+y, a, 0)
+
+DEBUG = False
+
+MAX_RATE_PERIOD = 20.0
+MAX_RATE = 10e10
+PING_BOUNDARY = 1.2
+PING_SAMPLES = 7
+PING_DISCARDS = 1
+PING_THRESHHOLD = 5
+PING_DELAY = 5  # cycles 'til first upward adjustment
+PING_DELAY_NEXT = 2  # 'til next
+ADJUST_UP = 1.05
+ADJUST_DOWN = 0.95
+UP_DELAY_FIRST = 5
+UP_DELAY_NEXT = 2
+SLOTS_STARTING = 6
+SLOTS_FACTOR = 1.66/1000
+
+class RateLimiter:
+    def __init__(self, sched, unitsize, slotsfunc = lambda x: None):
+        self.sched = sched
+        self.last = None
+        self.unitsize = unitsize
+        self.slotsfunc = slotsfunc
+        self.measure = Measure(MAX_RATE_PERIOD)
+        self.autoadjust = False
+        self.upload_rate = MAX_RATE * 1000
+        self.slots = SLOTS_STARTING    # garbage if not automatic
+
+    def set_upload_rate(self, rate):
+        # rate = -1 # test automatic
+        if rate < 0:
+            if self.autoadjust:
+                return
+            self.autoadjust = True
+            self.autoadjustup = 0
+            self.pings = []
+            rate = MAX_RATE
+            self.slots = SLOTS_STARTING
+            self.slotsfunc(self.slots)
+        else:
+            self.autoadjust = False
+        if not rate:
+            rate = MAX_RATE
+        self.upload_rate = rate * 1000
+        self.lasttime = clock()
+        self.bytes_sent = 0
+
+    def queue(self, conn):
+        assert conn.next_upload is None
+        if self.last is None:
+            self.last = conn
+            conn.next_upload = conn
+            self.try_send(True)
+        else:
+            conn.next_upload = self.last.next_upload
+            self.last.next_upload = conn
+            self.last = conn
+
+    def try_send(self, check_time = False):
+        t = clock()
+        self.bytes_sent -= (t - self.lasttime) * self.upload_rate
+        self.lasttime = t
+        if check_time:
+            self.bytes_sent = max(self.bytes_sent, 0)
+        cur = self.last.next_upload
+        while self.bytes_sent <= 0:
+            bytes = cur.send_partial(self.unitsize)
+            self.bytes_sent += bytes
+            self.measure.update_rate(bytes)
+            if bytes == 0 or cur.backlogged():
+                if self.last is cur:
+                    self.last = None
+                    cur.next_upload = None
+                    break
+                else:
+                    self.last.next_upload = cur.next_upload
+                    cur.next_upload = None
+                    cur = self.last.next_upload
+            else:
+                self.last = cur
+                cur = cur.next_upload
+        else:
+            self.sched(self.try_send, self.bytes_sent / self.upload_rate)
+
+    def adjust_sent(self, bytes):
+        self.bytes_sent = min(self.bytes_sent+bytes, self.upload_rate*3)
+        self.measure.update_rate(bytes)
+
+
+    def ping(self, delay):
+        if DEBUG:
+            print delay
+        if not self.autoadjust:
+            return
+        self.pings.append(delay > PING_BOUNDARY)
+        if len(self.pings) < PING_SAMPLES+PING_DISCARDS:
+            return
+        if DEBUG:
+            print 'cycle'
+        pings = sum(self.pings[PING_DISCARDS:])
+        del self.pings[:]
+        if pings >= PING_THRESHHOLD:   # assume flooded
+            if self.upload_rate == MAX_RATE:
+                self.upload_rate = self.measure.get_rate()*ADJUST_DOWN
+            else:
+                self.upload_rate = min(self.upload_rate,
+                                       self.measure.get_rate()*1.1)
+            self.upload_rate = max(int(self.upload_rate*ADJUST_DOWN),2)
+            self.slots = int(sqrt(self.upload_rate*SLOTS_FACTOR))
+            self.slotsfunc(self.slots)
+            if DEBUG:
+                print 'adjust down to '+str(self.upload_rate)
+            self.lasttime = clock()
+            self.bytes_sent = 0
+            self.autoadjustup = UP_DELAY_FIRST
+        else:   # not flooded
+            if self.upload_rate == MAX_RATE:
+                return
+            self.autoadjustup -= 1
+            if self.autoadjustup:
+                return
+            self.upload_rate = int(self.upload_rate*ADJUST_UP)
+            self.slots = int(sqrt(self.upload_rate*SLOTS_FACTOR))
+            self.slotsfunc(self.slots)
+            if DEBUG:
+                print 'adjust up to '+str(self.upload_rate)
+            self.lasttime = clock()
+            self.bytes_sent = 0
+            self.autoadjustup = UP_DELAY_NEXT
+
+
+
+