murder 0.0.0.pre

data/dist/BitTornado/natpunch.py

@@ -0,0 +1,254 @@
+# Written by John Hoffman
+# derived from NATPortMapping.py by Yejun Yang
+# and from example code by Myers Carpenter
+# see LICENSE.txt for license information
+
+import socket
+from traceback import print_exc
+from subnetparse import IP_List
+from clock import clock
+from __init__ import createPeerID
+try:
+    True
+except:
+    True = 1
+    False = 0
+
+DEBUG = False
+
+EXPIRE_CACHE = 30 # seconds
+ID = "BT-"+createPeerID()[-4:]
+
+try:
+    import pythoncom, win32com.client
+    _supported = 1
+except ImportError:
+    _supported = 0
+
+
+
+class _UPnP1:   # derived from Myers Carpenter's code
+                # seems to use the machine's local UPnP
+                # system for its operation.  Runs fairly fast
+
+    def __init__(self):
+        self.map = None
+        self.last_got_map = -10e10
+
+    def _get_map(self):
+        if self.last_got_map + EXPIRE_CACHE < clock():
+            try:
+                dispatcher = win32com.client.Dispatch("HNetCfg.NATUPnP")
+                self.map = dispatcher.StaticPortMappingCollection
+                self.last_got_map = clock()
+            except:
+                self.map = None
+        return self.map
+
+    def test(self):
+        try:
+            assert self._get_map()     # make sure a map was found
+            success = True
+        except:
+            success = False
+        return success
+
+
+    def open(self, ip, p):
+        map = self._get_map()
+        try:
+            map.Add(p,'TCP',p,ip,True,ID)
+            if DEBUG:
+                print 'port opened: '+ip+':'+str(p)
+            success = True
+        except:
+            if DEBUG:
+                print "COULDN'T OPEN "+str(p)
+                print_exc()
+            success = False
+        return success
+
+
+    def close(self, p):
+        map = self._get_map()
+        try:
+            map.Remove(p,'TCP')
+            success = True
+            if DEBUG:
+                print 'port closed: '+str(p)
+        except:
+            if DEBUG:
+                print 'ERROR CLOSING '+str(p)
+                print_exc()
+            success = False
+        return success
+
+
+    def clean(self, retry = False):
+        if not _supported:
+            return
+        try:
+            map = self._get_map()
+            ports_in_use = []
+            for i in xrange(len(map)):
+                try:
+                    mapping = map[i]
+                    port = mapping.ExternalPort
+                    prot = str(mapping.Protocol).lower()
+                    desc = str(mapping.Description).lower()
+                except:
+                    port = None
+                if port and prot == 'tcp' and desc[:3] == 'bt-':
+                    ports_in_use.append(port)
+            success = True
+            for port in ports_in_use:
+                try:
+                    map.Remove(port,'TCP')
+                except:
+                    success = False
+            if not success and not retry:
+                self.clean(retry = True)
+        except:
+            pass
+
+
+class _UPnP2:   # derived from Yejun Yang's code
+                # apparently does a direct search for UPnP hardware
+                # may work in some cases where _UPnP1 won't, but is slow
+                # still need to implement "clean" method
+
+    def __init__(self):
+        self.services = None
+        self.last_got_services = -10e10
+                           
+    def _get_services(self):
+        if not self.services or self.last_got_services + EXPIRE_CACHE < clock():
+            self.services = []
+            try:
+                f=win32com.client.Dispatch("UPnP.UPnPDeviceFinder")
+                for t in ( "urn:schemas-upnp-org:service:WANIPConnection:1",
+                           "urn:schemas-upnp-org:service:WANPPPConnection:1" ):
+                    try:
+                        conns = f.FindByType(t,0)
+                        for c in xrange(len(conns)):
+                            try:
+                                svcs = conns[c].Services
+                                for s in xrange(len(svcs)):
+                                    try:
+                                        self.services.append(svcs[s])
+                                    except:
+                                        pass
+                            except:
+                                pass
+                    except:
+                        pass
+            except:
+                pass
+            self.last_got_services = clock()
+        return self.services
+
+    def test(self):
+        try:
+            assert self._get_services()    # make sure some services can be found
+            success = True
+        except:
+            success = False
+        return success
+
+
+    def open(self, ip, p):
+        svcs = self._get_services()
+        success = False
+        for s in svcs:
+            try:
+                s.InvokeAction('AddPortMapping',['',p,'TCP',p,ip,True,ID,0],'')
+                success = True
+            except:
+                pass
+        if DEBUG and not success:
+            print "COULDN'T OPEN "+str(p)
+            print_exc()
+        return success
+
+
+    def close(self, p):
+        svcs = self._get_services()
+        success = False
+        for s in svcs:
+            try:
+                s.InvokeAction('DeletePortMapping', ['',p,'TCP'], '')
+                success = True
+            except:
+                pass
+        if DEBUG and not success:
+            print "COULDN'T OPEN "+str(p)
+            print_exc()
+        return success
+
+
+class _UPnP:    # master holding class
+    def __init__(self):
+        self.upnp1 = _UPnP1()
+        self.upnp2 = _UPnP2()
+        self.upnplist = (None, self.upnp1, self.upnp2)
+        self.upnp = None
+        self.local_ip = None
+        self.last_got_ip = -10e10
+        
+    def get_ip(self):
+        if self.last_got_ip + EXPIRE_CACHE < clock():
+            local_ips = IP_List()
+            local_ips.set_intranet_addresses()
+            try:
+                for info in socket.getaddrinfo(socket.gethostname(),0,socket.AF_INET):
+                            # exception if socket library isn't recent
+                    self.local_ip = info[4][0]
+                    if local_ips.includes(self.local_ip):
+                        self.last_got_ip = clock()
+                        if DEBUG:
+                            print 'Local IP found: '+self.local_ip
+                        break
+                else:
+                    raise ValueError('couldn\'t find intranet IP')
+            except:
+                self.local_ip = None
+                if DEBUG:
+                    print 'Error finding local IP'
+                    print_exc()
+        return self.local_ip
+
+    def test(self, upnp_type):
+        if DEBUG:
+            print 'testing UPnP type '+str(upnp_type)
+        if not upnp_type or not _supported or self.get_ip() is None:
+            if DEBUG:
+                print 'not supported'
+            return 0
+        pythoncom.CoInitialize()                # leave initialized
+        self.upnp = self.upnplist[upnp_type]    # cache this
+        if self.upnp.test():
+            if DEBUG:
+                print 'ok'
+            return upnp_type
+        if DEBUG:
+            print 'tested bad'
+        return 0
+
+    def open(self, p):
+        assert self.upnp, "must run UPnP_test() with the desired UPnP access type first"
+        return self.upnp.open(self.get_ip(), p)
+
+    def close(self, p):
+        assert self.upnp, "must run UPnP_test() with the desired UPnP access type first"
+        return self.upnp.close(p)
+
+    def clean(self):
+        return self.upnp1.clean()
+
+_upnp_ = _UPnP()
+
+UPnP_test = _upnp_.test
+UPnP_open_port = _upnp_.open
+UPnP_close_port = _upnp_.close
+UPnP_reset = _upnp_.clean
+

data/dist/BitTornado/parseargs.py

@@ -0,0 +1,137 @@
+# Written by Bill Bumgarner and Bram Cohen
+# see LICENSE.txt for license information
+
+from types import *
+from cStringIO import StringIO
+
+
+def splitLine(line, COLS=80, indent=10):
+    indent = " " * indent
+    width = COLS - (len(indent) + 1)
+    if indent and width < 15:
+        width = COLS - 2
+        indent = " "
+    s = StringIO()
+    i = 0
+    for word in line.split():
+        if i == 0:
+            s.write(indent+word)
+            i = len(word)
+            continue
+        if i + len(word) >= width:
+            s.write('\n'+indent+word)
+            i = len(word)
+            continue
+        s.write(' '+word)
+        i += len(word) + 1
+    return s.getvalue()
+
+def formatDefinitions(options, COLS, presets = {}):
+    s = StringIO()
+    for (longname, default, doc) in options:
+        s.write('--' + longname + ' <arg>\n')
+        default = presets.get(longname, default)
+        if type(default) in (IntType, LongType):
+            try:
+                default = int(default)
+            except:
+                pass
+        if default is not None:
+            doc += ' (defaults to ' + repr(default) + ')'
+        s.write(splitLine(doc,COLS,10))
+        s.write('\n\n')
+    return s.getvalue()
+
+
+def usage(str):
+    raise ValueError(str)
+
+
+def defaultargs(options):
+    l = {}
+    for (longname, default, doc) in options:
+        if default is not None:
+            l[longname] = default
+    return l
+        
+
+def parseargs(argv, options, minargs = None, maxargs = None, presets = {}):
+    config = {}
+    longkeyed = {}
+    for option in options:
+        longname, default, doc = option
+        longkeyed[longname] = option
+        config[longname] = default
+    for longname in presets.keys():        # presets after defaults but before arguments
+        config[longname] = presets[longname]
+    options = []
+    args = []
+    pos = 0
+    while pos < len(argv):
+        if argv[pos][:2] != '--':
+            args.append(argv[pos])
+            pos += 1
+        else:
+            if pos == len(argv) - 1:
+                usage('parameter passed in at end with no value')
+            key, value = argv[pos][2:], argv[pos+1]
+            pos += 2
+            if not longkeyed.has_key(key):
+                usage('unknown key --' + key)
+            longname, default, doc = longkeyed[key]
+            try:
+                t = type(config[longname])
+                if t is NoneType or t is StringType:
+                    config[longname] = value
+                elif t in (IntType, LongType):
+                    config[longname] = long(value)
+                elif t is FloatType:
+                    config[longname] = float(value)
+                else:
+                    assert 0
+            except ValueError, e:
+                usage('wrong format of --%s - %s' % (key, str(e)))
+    for key, value in config.items():
+        if value is None:
+            usage("Option --%s is required." % key)
+    if minargs is not None and len(args) < minargs:
+        usage("Must supply at least %d args." % minargs)
+    if maxargs is not None and len(args) > maxargs:
+        usage("Too many args - %d max." % maxargs)
+    return (config, args)
+
+def test_parseargs():
+    assert parseargs(('d', '--a', 'pq', 'e', '--b', '3', '--c', '4.5', 'f'), (('a', 'x', ''), ('b', 1, ''), ('c', 2.3, ''))) == ({'a': 'pq', 'b': 3, 'c': 4.5}, ['d', 'e', 'f'])
+    assert parseargs([], [('a', 'x', '')]) == ({'a': 'x'}, [])
+    assert parseargs(['--a', 'x', '--a', 'y'], [('a', '', '')]) == ({'a': 'y'}, [])
+    try:
+        parseargs([], [('a', 'x', '')])
+    except ValueError:
+        pass
+    try:
+        parseargs(['--a', 'x'], [])
+    except ValueError:
+        pass
+    try:
+        parseargs(['--a'], [('a', 'x', '')])
+    except ValueError:
+        pass
+    try:
+        parseargs([], [], 1, 2)
+    except ValueError:
+        pass
+    assert parseargs(['x'], [], 1, 2) == ({}, ['x'])
+    assert parseargs(['x', 'y'], [], 1, 2) == ({}, ['x', 'y'])
+    try:
+        parseargs(['x', 'y', 'z'], [], 1, 2)
+    except ValueError:
+        pass
+    try:
+        parseargs(['--a', '2.0'], [('a', 3, '')])
+    except ValueError:
+        pass
+    try:
+        parseargs(['--a', 'z'], [('a', 2.1, '')])
+    except ValueError:
+        pass
+

data/dist/BitTornado/parsedir.py

@@ -0,0 +1,150 @@
+# Written by John Hoffman and Uoti Urpala
+# see LICENSE.txt for license information
+from bencode import bencode, bdecode
+from BT1.btformats import check_info
+from os.path import exists, isfile
+from sha import sha
+import sys, os
+
+try:
+    True
+except:
+    True = 1
+    False = 0
+
+NOISY = False
+
+def _errfunc(x):
+    print ":: "+x
+
+def parsedir(directory, parsed, files, blocked,
+             exts = ['.torrent'], return_metainfo = False, errfunc = _errfunc):
+    if NOISY:
+        errfunc('checking dir')
+    dirs_to_check = [directory]
+    new_files = {}
+    new_blocked = {}
+    torrent_type = {}
+    while dirs_to_check:    # first, recurse directories and gather torrents
+        directory = dirs_to_check.pop()
+        newtorrents = False
+        for f in os.listdir(directory):
+            newtorrent = None
+            for ext in exts:
+                if f.endswith(ext):
+                    newtorrent = ext[1:]
+                    break
+            if newtorrent:
+                newtorrents = True
+                p = os.path.join(directory, f)
+                new_files[p] = [(os.path.getmtime(p), os.path.getsize(p)), 0]
+                torrent_type[p] = newtorrent
+        if not newtorrents:
+            for f in os.listdir(directory):
+                p = os.path.join(directory, f)
+                if os.path.isdir(p):
+                    dirs_to_check.append(p)
+
+    new_parsed = {}
+    to_add = []
+    added = {}
+    removed = {}
+    # files[path] = [(modification_time, size), hash], hash is 0 if the file
+    # has not been successfully parsed
+    for p,v in new_files.items():   # re-add old items and check for changes
+        oldval = files.get(p)
+        if not oldval:          # new file
+            to_add.append(p)
+            continue
+        h = oldval[1]
+        if oldval[0] == v[0]:   # file is unchanged from last parse
+            if h:
+                if blocked.has_key(p):  # parseable + blocked means duplicate
+                    to_add.append(p)    # other duplicate may have gone away
+                else:
+                    new_parsed[h] = parsed[h]
+                new_files[p] = oldval
+            else:
+                new_blocked[p] = 1  # same broken unparseable file
+            continue
+        if parsed.has_key(h) and not blocked.has_key(p):
+            if NOISY:
+                errfunc('removing '+p+' (will re-add)')
+            removed[h] = parsed[h]
+        to_add.append(p)
+
+    to_add.sort()
+    for p in to_add:                # then, parse new and changed torrents
+        new_file = new_files[p]
+        v,h = new_file
+        if new_parsed.has_key(h): # duplicate
+            if not blocked.has_key(p) or files[p][0] != v:
+                errfunc('**warning** '+
+                    p +' is a duplicate torrent for '+new_parsed[h]['path'])
+            new_blocked[p] = 1
+            continue
+                
+        if NOISY:
+            errfunc('adding '+p)
+        try:
+            ff = open(p, 'rb')
+            d = bdecode(ff.read())
+            check_info(d['info'])
+            h = sha(bencode(d['info'])).digest()
+            new_file[1] = h
+            if new_parsed.has_key(h):
+                errfunc('**warning** '+
+                    p +' is a duplicate torrent for '+new_parsed[h]['path'])
+                new_blocked[p] = 1
+                continue
+
+            a = {}
+            a['path'] = p
+            f = os.path.basename(p)
+            a['file'] = f
+            a['type'] = torrent_type[p]
+            i = d['info']
+            l = 0
+            nf = 0
+            if i.has_key('length'):
+                l = i.get('length',0)
+                nf = 1
+            elif i.has_key('files'):
+                for li in i['files']:
+                    nf += 1
+                    if li.has_key('length'):
+                        l += li['length']
+            a['numfiles'] = nf
+            a['length'] = l
+            a['name'] = i.get('name', f)
+            def setkey(k, d = d, a = a):
+                if d.has_key(k):
+                    a[k] = d[k]
+            setkey('failure reason')
+            setkey('warning message')
+            setkey('announce-list')
+            if return_metainfo:
+                a['metainfo'] = d
+        except:
+            errfunc('**warning** '+p+' has errors')
+            new_blocked[p] = 1
+            continue
+        try:
+            ff.close()
+        except:
+            pass
+        if NOISY:
+            errfunc('... successful')
+        new_parsed[h] = a
+        added[h] = a
+
+    for p,v in files.items():       # and finally, mark removed torrents
+        if not new_files.has_key(p) and not blocked.has_key(p):
+            if NOISY:
+                errfunc('removing '+p)
+            removed[v[1]] = parsed[v[1]]
+
+    if NOISY:
+        errfunc('done checking')
+    return (new_parsed, new_files, new_blocked, added, removed)
+