murder 0.0.0.pre

data/dist/BitTornado/RateMeasure.py

@@ -0,0 +1,75 @@
+# Written by Bram Cohen
+# see LICENSE.txt for license information
+
+from clock import clock
+try:
+    True
+except:
+    True = 1
+    False = 0
+
+FACTOR = 0.999
+
+class RateMeasure:
+    def __init__(self):
+        self.last = None
+        self.time = 1.0
+        self.got = 0.0
+        self.remaining = None
+        self.broke = False
+        self.got_anything = False
+        self.last_checked = None
+        self.rate = 0
+        self.lastten = False
+
+    def data_came_in(self, amount):
+        if not self.got_anything:
+            self.got_anything = True
+            self.last = clock()
+            return
+        self.update(amount)
+
+    def data_rejected(self, amount):
+        pass
+
+    def get_time_left(self, left):
+        t = clock()
+        if not self.got_anything:
+            return None
+        if t - self.last > 15:
+            self.update(0)
+        try:
+            remaining = left/self.rate
+            if not self.lastten and remaining <= 10:
+                self.lastten = True
+            if self.lastten:
+                return remaining
+            delta = max(remaining/20,2)
+            if self.remaining is None:
+                self.remaining = remaining
+            elif abs(self.remaining-remaining) > delta:
+                self.remaining = remaining
+            else:
+                self.remaining -= t - self.last_checked
+        except ZeroDivisionError:
+            self.remaining = None
+        if self.remaining is not None and self.remaining < 0.1:
+            self.remaining = 0.1
+        self.last_checked = t
+        return self.remaining
+
+    def update(self, amount):
+        t = clock()
+        t1 = int(t)
+        l1 = int(self.last)
+        for i in xrange(l1,t1):
+            self.time *= FACTOR
+            self.got *= FACTOR
+        self.got += amount
+        if t - self.last < 20:
+            self.time += t - self.last
+        self.last = t
+        try:
+            self.rate = self.got / self.time
+        except ZeroDivisionError:
+            pass

data/dist/BitTornado/RawServer.py

@@ -0,0 +1,195 @@
+# Written by Bram Cohen
+# see LICENSE.txt for license information
+
+from bisect import insort
+from SocketHandler import SocketHandler, UPnP_ERROR
+import socket
+from cStringIO import StringIO
+from traceback import print_exc
+from select import error
+from threading import Thread, Event
+from time import sleep
+from clock import clock
+import sys
+try:
+    True
+except:
+    True = 1
+    False = 0
+
+
+def autodetect_ipv6():
+    try:
+        assert sys.version_info >= (2,3)
+        assert socket.has_ipv6
+        socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
+    except:
+        return 0
+    return 1
+
+def autodetect_socket_style():
+	if sys.platform.find('linux') < 0:
+		return 1
+	else:
+		try:
+			f = open('/proc/sys/net/ipv6/bindv6only','r')
+			dual_socket_style = int(f.read())
+			f.close()
+			return int(not dual_socket_style)
+		except:
+			return 0
+
+
+READSIZE = 100000
+
+class RawServer:
+    def __init__(self, doneflag, timeout_check_interval, timeout, noisy = True,
+                 ipv6_enable = True, failfunc = lambda x: None, errorfunc = None,
+                 sockethandler = None, excflag = Event()):
+        self.timeout_check_interval = timeout_check_interval
+        self.timeout = timeout
+        self.servers = {}
+        self.single_sockets = {}
+        self.dead_from_write = []
+        self.doneflag = doneflag
+        self.noisy = noisy
+        self.failfunc = failfunc
+        self.errorfunc = errorfunc
+        self.exccount = 0
+        self.funcs = []
+        self.externally_added = []
+        self.finished = Event()
+        self.tasks_to_kill = []
+        self.excflag = excflag
+        
+        if sockethandler is None:
+            sockethandler = SocketHandler(timeout, ipv6_enable, READSIZE)
+        self.sockethandler = sockethandler
+        self.add_task(self.scan_for_timeouts, timeout_check_interval)
+
+    def get_exception_flag(self):
+        return self.excflag
+
+    def _add_task(self, func, delay, id = None):
+        assert float(delay) >= 0
+        insort(self.funcs, (clock() + delay, func, id))
+
+    def add_task(self, func, delay = 0, id = None):
+        assert float(delay) >= 0
+        self.externally_added.append((func, delay, id))
+
+    def scan_for_timeouts(self):
+        self.add_task(self.scan_for_timeouts, self.timeout_check_interval)
+        self.sockethandler.scan_for_timeouts()
+
+    def bind(self, port, bind = '', reuse = False,
+                        ipv6_socket_style = 1, upnp = False):
+        self.sockethandler.bind(port, bind, reuse, ipv6_socket_style, upnp)
+
+    def find_and_bind(self, minport, maxport, bind = '', reuse = False,
+                      ipv6_socket_style = 1, upnp = 0, randomizer = False):
+        return self.sockethandler.find_and_bind(minport, maxport, bind, reuse,
+                                 ipv6_socket_style, upnp, randomizer)
+
+    def start_connection_raw(self, dns, socktype, handler = None):
+        return self.sockethandler.start_connection_raw(dns, socktype, handler)
+
+    def start_connection(self, dns, handler = None, randomize = False):
+        return self.sockethandler.start_connection(dns, handler, randomize)
+
+    def get_stats(self):
+        return self.sockethandler.get_stats()
+
+    def pop_external(self):
+        while self.externally_added:
+            (a, b, c) = self.externally_added.pop(0)
+            self._add_task(a, b, c)
+
+
+    def listen_forever(self, handler):
+        self.sockethandler.set_handler(handler)
+        try:
+            while not self.doneflag.isSet():
+                try:
+                    self.pop_external()
+                    self._kill_tasks()
+                    if self.funcs:
+                        period = self.funcs[0][0] + 0.001 - clock()
+                    else:
+                        period = 2 ** 30
+                    if period < 0:
+                        period = 0
+                    events = self.sockethandler.do_poll(period)
+                    if self.doneflag.isSet():
+                        return
+                    while self.funcs and self.funcs[0][0] <= clock():
+                        garbage1, func, id = self.funcs.pop(0)
+                        if id in self.tasks_to_kill:
+                            pass
+                        try:
+#                            print func.func_name
+                            func()
+                        except (SystemError, MemoryError), e:
+                            self.failfunc(str(e))
+                            return
+                        except KeyboardInterrupt:
+#                            self.exception(True)
+                            return
+                        except:
+                            if self.noisy:
+                                self.exception()
+                    self.sockethandler.close_dead()
+                    self.sockethandler.handle_events(events)
+                    if self.doneflag.isSet():
+                        return
+                    self.sockethandler.close_dead()
+                except (SystemError, MemoryError), e:
+                    self.failfunc(str(e))
+                    return
+                except error:
+                    if self.doneflag.isSet():
+                        return
+                except KeyboardInterrupt:
+#                    self.exception(True)
+                    return
+                except:
+                    self.exception()
+                if self.exccount > 10:
+                    return
+        finally:
+#            self.sockethandler.shutdown()
+            self.finished.set()
+
+    def is_finished(self):
+        return self.finished.isSet()
+
+    def wait_until_finished(self):
+        self.finished.wait()
+
+    def _kill_tasks(self):
+        if self.tasks_to_kill:
+            new_funcs = []
+            for (t, func, id) in self.funcs:
+                if id not in self.tasks_to_kill:
+                    new_funcs.append((t, func, id))
+            self.funcs = new_funcs
+            self.tasks_to_kill = []
+
+    def kill_tasks(self, id):
+        self.tasks_to_kill.append(id)
+
+    def exception(self, kbint = False):
+        if not kbint:
+            self.excflag.set()
+        self.exccount += 1
+        if self.errorfunc is None:
+            print_exc()
+        else:
+            data = StringIO()
+            print_exc(file = data)
+#            print data.getvalue()   # report exception here too
+            if not kbint:           # don't report here if it's a keyboard interrupt
+                self.errorfunc(data.getvalue())
+
+    def shutdown(self):
+        self.sockethandler.shutdown()

data/dist/BitTornado/ServerPortHandler.py

@@ -0,0 +1,188 @@
+# Written by John Hoffman
+# see LICENSE.txt for license information
+
+from cStringIO import StringIO
+#from RawServer import RawServer
+try:
+    True
+except:
+    True = 1
+    False = 0
+
+from BT1.Encrypter import protocol_name
+
+default_task_id = []
+
+class SingleRawServer:
+    def __init__(self, info_hash, multihandler, doneflag, protocol):
+        self.info_hash = info_hash
+        self.doneflag = doneflag
+        self.protocol = protocol
+        self.multihandler = multihandler
+        self.rawserver = multihandler.rawserver
+        self.finished = False
+        self.running = False
+        self.handler = None
+        self.taskqueue = []
+
+    def shutdown(self):
+        if not self.finished:
+            self.multihandler.shutdown_torrent(self.info_hash)
+
+    def _shutdown(self):
+        if not self.finished:
+            self.finished = True
+            self.running = False
+            self.rawserver.kill_tasks(self.info_hash)
+            if self.handler:
+                self.handler.close_all()
+
+    def _external_connection_made(self, c, options, already_read):
+        if self.running:
+            c.set_handler(self.handler)
+            self.handler.externally_handshaked_connection_made(
+                c, options, already_read)
+
+    ### RawServer functions ###
+
+    def add_task(self, func, delay=0, id = default_task_id):
+        if id is default_task_id:
+            id = self.info_hash
+        if not self.finished:
+            self.rawserver.add_task(func, delay, id)
+
+#    def bind(self, port, bind = '', reuse = False):
+#        pass    # not handled here
+        
+    def start_connection(self, dns, handler = None):
+        if not handler:
+            handler = self.handler
+        c = self.rawserver.start_connection(dns, handler)
+        return c
+
+#    def listen_forever(self, handler):
+#        pass    # don't call with this
+    
+    def start_listening(self, handler):
+        self.handler = handler
+        self.running = True
+        return self.shutdown    # obviously, doesn't listen forever
+
+    def is_finished(self):
+        return self.finished
+
+    def get_exception_flag(self):
+        return self.rawserver.get_exception_flag()
+
+
+class NewSocketHandler:     # hand a new socket off where it belongs
+    def __init__(self, multihandler, connection):
+        self.multihandler = multihandler
+        self.connection = connection
+        connection.set_handler(self)
+        self.closed = False
+        self.buffer = StringIO()
+        self.complete = False
+        self.next_len, self.next_func = 1, self.read_header_len
+        self.multihandler.rawserver.add_task(self._auto_close, 15)
+
+    def _auto_close(self):
+        if not self.complete:
+            self.close()
+        
+    def close(self):
+        if not self.closed:
+            self.connection.close()
+            self.closed = True
+
+        
+#   header format:
+#        connection.write(chr(len(protocol_name)) + protocol_name + 
+#            (chr(0) * 8) + self.encrypter.download_id + self.encrypter.my_id)
+
+    # copied from Encrypter and modified
+    
+    def read_header_len(self, s):
+        l = ord(s)
+        return l, self.read_header
+
+    def read_header(self, s):
+        self.protocol = s
+        return 8, self.read_reserved
+
+    def read_reserved(self, s):
+        self.options = s
+        return 20, self.read_download_id
+
+    def read_download_id(self, s):
+        if self.multihandler.singlerawservers.has_key(s):
+            if self.multihandler.singlerawservers[s].protocol == self.protocol:
+                return True
+        return None
+
+    def read_dead(self, s):
+        return None
+
+    def data_came_in(self, garbage, 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()
+            try:
+                x = self.next_func(m)
+            except:
+                self.next_len, self.next_func = 1, self.read_dead
+                raise
+            if x is None:
+                self.close()
+                return
+            if x == True:       # ready to process
+                self.multihandler.singlerawservers[m]._external_connection_made(
+                        self.connection, self.options, s)
+                self.complete = True
+                return
+            self.next_len, self.next_func = x
+
+    def connection_flushed(self, ss):
+        pass
+
+    def connection_lost(self, ss):
+        self.closed = True
+
+class MultiHandler:
+    def __init__(self, rawserver, doneflag):
+        self.rawserver = rawserver
+        self.masterdoneflag = doneflag
+        self.singlerawservers = {}
+        self.connections = {}
+        self.taskqueues = {}
+
+    def newRawServer(self, info_hash, doneflag, protocol=protocol_name):
+        new = SingleRawServer(info_hash, self, doneflag, protocol)
+        self.singlerawservers[info_hash] = new
+        return new
+
+    def shutdown_torrent(self, info_hash):
+        self.singlerawservers[info_hash]._shutdown()
+        del self.singlerawservers[info_hash]
+
+    def listen_forever(self):
+        self.rawserver.listen_forever(self)
+        for srs in self.singlerawservers.values():
+            srs.finished = True
+            srs.running = False
+            srs.doneflag.set()
+        
+    ### RawServer handler functions ###
+    # be wary of name collisions
+
+    def external_connection_made(self, ss):
+        NewSocketHandler(self, ss)