home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 February / maximum-cd-2011-02.iso / DiscContents / digsby_setup85.exe / lib / common / proxysockets.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-11-24  |  16.5 KB  |  493 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. import util
  5. from AsyncSocket import AsyncSocket as asocket
  6. import socks
  7. from socket import _socket as socket
  8. from functools import wraps
  9. import sys
  10. import logging
  11. log = logging.getLogger('proxysockets')
  12.  
  13. class ProxyType:
  14.     SOCKS4 = socks.PROXY_TYPE_SOCKS4
  15.     SOCKS5 = socks.PROXY_TYPE_SOCKS5
  16.     HTTP = socks.PROXY_TYPE_HTTP
  17.     HTTPS = socks.PROXY_TYPE_HTTPS
  18.  
  19.  
  20. class ProxySocket(asocket):
  21.     
  22.     def __init__(self, proxy, conn, post):
  23.         asocket.__init__(self, conn)
  24.         self.callback = None
  25.         self.post_negotiate = post
  26.         self._negotiating = False
  27.         if proxy is None:
  28.             proxy = { }
  29.         
  30.         self._proxyinfo = proxy.copy()
  31.         self.mid = (self._proxyinfo.get('addr', ''), self._proxyinfo.get('port', 0))
  32.         self.end = ('', 0)
  33.  
  34.     
  35.     def connect(self, end, callback = None):
  36.         self.callback = callback
  37.         self.end = end
  38.         self._pconnect()
  39.  
  40.     connect = util.callbacks.callsback(connect)
  41.     
  42.     def _pconnect(self):
  43.         asocket.connect(self, self.mid)
  44.  
  45.     
  46.     def handle_close(self):
  47.         log.info('ProxySocket.handle_close - calling callback.error')
  48.         self.close()
  49.         asocket.handle_close(self)
  50.  
  51.     
  52.     def close(self):
  53.         if getattr(self, 'socket', None) is not None:
  54.             asocket.close(self)
  55.         
  56.         if self.callback is not None:
  57.             self.callback = None
  58.             cb = self.callback
  59.             cb.error()
  60.         
  61.  
  62.     
  63.     def handle_connect(self):
  64.         if not self._negotiating:
  65.             log.info('ProxySocket connected. starting negotiation... ')
  66.             self._negotiating = True
  67.             self._pnegotiate()
  68.         
  69.  
  70.     
  71.     def _pnegotiate(self):
  72.         negs = {
  73.             ProxyType.HTTP: self._negotiatehttp,
  74.             ProxyType.HTTPS: self._negotiatehttps,
  75.             ProxyType.SOCKS4: self._negotiatesocks4,
  76.             ProxyType.SOCKS5: self._negotiatesocks5 }
  77.         neg = negs.get(self._proxyinfo.get('proxytype', None), self._negotiation_done)
  78.         neg()
  79.  
  80.     
  81.     def _negotiatehttp(self):
  82.         self._endhost_resolved = None
  83.         endhost = self.end[0]
  84.         endport = self.end[1]
  85.         if not self._proxyinfo.get('rdns', True):
  86.             
  87.             try:
  88.                 endhost = self._endhost_resolved = socket.gethostbyname(self.end[0])
  89.             except socket.gaierror:
  90.                 pass
  91.             except:
  92.                 None<EXCEPTION MATCH>socket.gaierror
  93.             
  94.  
  95.         None<EXCEPTION MATCH>socket.gaierror
  96.         authstr = self._httpauthstring()
  97.         http_connect = 'CONNECT %s:%d HTTP/1.1\r\nHost: %s\r\n%s\r\n' % (endhost, endport, self.end[0], authstr)
  98.         None(log.info, 'ProxySocket._negotiatehttp: sending proxy CONNECT%s. %r:%r' if authstr else '', self, (endhost, endport))
  99.         self.push(http_connect)
  100.         self.push_handler(self._httpfinish)
  101.         self.set_terminator('\r\n\r\n')
  102.  
  103.     
  104.     def _httpauthstring(self):
  105.         username = self._proxyinfo.get('username', None)
  106.         password = self._proxyinfo.get('password', None)
  107.         if all((username, password)):
  108.             raw = '%s:%s' % (username, password)
  109.             auth = 'Basic %s' % ''.join(raw.encode('base-64').strip().split())
  110.             return 'Proxy-Authorization: %s\r\n' % auth
  111.         return ''
  112.  
  113.     
  114.     def _httpfinish(self, data):
  115.         self.pop_handler()
  116.         statusline = data.splitlines()[0].split(' ', 2)
  117.         if statusline[0] not in ('HTTP/1.0', 'HTTP/1.1'):
  118.             log.info('ProxySocket._httpfinish: Bad data from server, disconnecting: (%r)', data)
  119.             return self.close()
  120.         
  121.         try:
  122.             statuscode = int(statusline[1])
  123.         except ValueError:
  124.             statusline[0] not in ('HTTP/1.0', 'HTTP/1.1')
  125.             statusline[0] not in ('HTTP/1.0', 'HTTP/1.1')
  126.             log.info('ProxySocket._httpfinish: Got some bad data from the server, disconnecting: %r (%r)', statusline, data)
  127.             return self.close()
  128.  
  129.         if statuscode != 200:
  130.             log.info('ProxySocket._httpfinish: got HTTPError code %r, disconnecting (%r)', statuscode, data)
  131.             return self.close()
  132.         log.info('ProxySocket._httpfinish: success %r', self)
  133.         self._ProxySocket__proxysockname = ('0.0.0.0', 0)
  134.         if not self._endhost_resolved:
  135.             pass
  136.         self._ProxySocket__proxypeername = (self.end[0], self.end[1])
  137.         self._negotiation_done()
  138.  
  139.     
  140.     def _negotiation_done(self):
  141.         log.info('proxy negotiation complete')
  142.         self._proxy_setup = True
  143.         self.del_channel()
  144.         self.finish(self.socket, 'handle_connect')
  145.         if self.callback is not None:
  146.             self.callback.success()
  147.         
  148.         self.callback = None
  149.         self.socket = None
  150.  
  151.     
  152.     def finish(self, sck, handler_name):
  153.         sck = self.post_negotiate(sck)
  154.         sck.connected = True
  155.         sck._proxy_setup = True
  156.         self.collect_incoming_data = sck.collect_incoming_data
  157.         getattr(sck, handler_name)()
  158.  
  159.     
  160.     def _negotiatehttps(self):
  161.         raise NotImplementedError
  162.  
  163.     
  164.     def _negotiatesocks4(self):
  165.         pack = pack
  166.         import struct
  167.         destaddr = self.end[0]
  168.         destport = self.end[1]
  169.         rresolve = self._proxyinfo.get('rdns', True)
  170.         
  171.         def zstring(s):
  172.             return s + '\x00'
  173.  
  174.         
  175.         try:
  176.             ipaddr = socket.inet_aton(destaddr)
  177.         except socket.error:
  178.             if not rresolve:
  179.                 
  180.                 try:
  181.                     ipaddr = socket.inet_aton(socket.gethostbyname(destaddr))
  182.                 except socket.error:
  183.                     ipaddr = pack('!I', 1)
  184.                     rresolve = True
  185.                 except:
  186.                     None<EXCEPTION MATCH>socket.error
  187.                 
  188.  
  189.             None<EXCEPTION MATCH>socket.error
  190.  
  191.         req = pack('!BBH', 4, 1, destport) + ipaddr
  192.         username = self._proxyinfo.get('username', '')
  193.         req += zstring(username)
  194.         if rresolve:
  195.             req += zstring(destaddr)
  196.         
  197.         log.info('ProxySocket._negotiatesocks4: sending request')
  198.         self.push(req)
  199.         self.push_handler(self._socks4finish)
  200.         self.set_terminator(8)
  201.         if rresolve:
  202.             self._ProxySocket__proxypeername = (socket.inet_ntoa(ipaddr), destport)
  203.         else:
  204.             self._ProxySocket__proxypeername = (destaddr, destport)
  205.  
  206.     
  207.     def _socks4finish(self, data):
  208.         unpack = unpack
  209.         import struct
  210.         self.pop_handler()
  211.         log.info('ProxySocket._negotiatesocks4: received response')
  212.         
  213.         try:
  214.             (null, returncode, port, ip) = unpack('!BBH4s', data)
  215.         except Exception:
  216.             e = None
  217.             log.info('ProxySocket._negotiatesocks4: bad data received from server. original exception is: %r', e)
  218.             return self.close()
  219.  
  220.         ip = socket.inet_ntoa(ip)
  221.         if null != 0:
  222.             log.info('ProxySocket._negotiatesocks4: Bad data from server- expected null byte, got %r', null)
  223.             return self.close()
  224.         if returncode != 90:
  225.             log.info('ProxySocket._negotiatesocks4: received error code %r', returncode)
  226.             return self.close()
  227.         log.info('ProxySocket._negotiatesocks4: success')
  228.         self._ProxySocket__proxysockname = (ip, port)
  229.         self._negotiation_done()
  230.  
  231.     
  232.     def _negotiatesocks5_gen(self):
  233.         pack = pack
  234.         unpack = unpack
  235.         import struct
  236.         Storage = Storage
  237.         import util
  238.         (destaddr, destport) = self.end
  239.         uname = self._proxyinfo.get('username', '')
  240.         password = self._proxyinfo.get('password', '')
  241.         this = Storage()
  242.         this.errors = False
  243.         this.authtype = 0
  244.         this.incoming_host_type = 0
  245.         
  246.         def pstring(s):
  247.             return chr(len(s)) + s
  248.  
  249.         
  250.         def single_use_handler(f):
  251.             
  252.             def wrapper(data):
  253.                 self.pop_handler()
  254.                 return f(data)
  255.  
  256.             wrapper = (None, wraps(f))(wrapper)
  257.             return wrapper
  258.  
  259.         
  260.         def if_errors_close(f):
  261.             
  262.             def wrapper(*a, **k):
  263.                 ok = not (this.errors)
  264.                 if ok:
  265.                     
  266.                     try:
  267.                         return f(*a, **k)
  268.                     except Exception:
  269.                         e = None
  270.                         import traceback
  271.                         traceback.print_exc()
  272.                         log.info('ProxySocket._negotiatesocks5: there was an error calling %r(*%r, **%r). the exception was: %r', f, a, k, e)
  273.                         this.errors = True
  274.                         self.close()
  275.                         return ('', None)
  276.                     
  277.  
  278.                 None<EXCEPTION MATCH>Exception
  279.                 log.info('ProxySocket._negotiatesocks5: Previous errors prevented %r(*%r, **%r) from happening', f, a, k)
  280.                 return ('', None)
  281.  
  282.             return wrapper
  283.  
  284.         sender = if_errors_close
  285.         
  286.         def recver(f):
  287.             return if_errors_close(single_use_handler(f))
  288.  
  289.         
  290.         def _sendauthtype():
  291.             if uname and password:
  292.                 data = pack('!BBBB', 5, 2, 0, 2)
  293.             else:
  294.                 data = pack('!BBB', 5, 1, 0)
  295.             return (data, 2)
  296.  
  297.         _sendauthtype = (None, (None, (None, (None,))), sender)(_sendauthtype)
  298.         
  299.         def _recvauthtype(data):
  300.             (status, authmethod) = unpack('!BB', data)
  301.             if status != 5:
  302.                 raise Exception('Bad data was received from the proxy server: %r', data)
  303.             status != 5
  304.             if authmethod in (0, 2):
  305.                 this.authtype = authmethod
  306.             elif authmethod == 255:
  307.                 this.authtype = None
  308.                 raise Exception('All auth methods were rejected')
  309.             
  310.  
  311.         _recvauthtype = (None, recver)(_recvauthtype)
  312.         
  313.         def _sendauth():
  314.             return (chr(1) + pstring(uname) + pstring(password), 2)
  315.  
  316.         _sendauth = (None, None, sender)(_sendauth)
  317.         
  318.         def _recvauth(data):
  319.             (code, status) = map(ord, data)
  320.             if code != 1:
  321.                 raise Exception('Was expecting 1, got %r', code)
  322.             code != 1
  323.             if status != 0:
  324.                 raise Exception('authentication failed. bad uname/pword?')
  325.             status != 0
  326.  
  327.         _recvauth = recver(_recvauth)
  328.         
  329.         def _sendproxysetup():
  330.             request = pack('!BBB', 5, 1, 0)
  331.             rresolve = self._proxyinfo.get('rdns', True)
  332.             this.resolved_ip = None
  333.             if rresolve:
  334.                 
  335.                 try:
  336.                     this.resolved_ip = socket.inet_aton(destaddr)
  337.                 except socket.error:
  338.                     
  339.                     try:
  340.                         this.resolved_ip = socket.inet_aton(socket.gethostbyname(destaddr))
  341.                     rresolve = True
  342.  
  343.                 except:
  344.                     None<EXCEPTION MATCH>socket.error
  345.                 
  346.  
  347.             None<EXCEPTION MATCH>socket.error
  348.             if rresolve or this.resolved_ip is None:
  349.                 request += chr(3) + pstring(destaddr)
  350.             else:
  351.                 request += chr(1) + this.resolved_ip
  352.             request += pack('!H', destport)
  353.             return (request, 4)
  354.  
  355.         _sendproxysetup = (None, None, None, None, None, sender)(_sendproxysetup)
  356.         
  357.         def _recvproxysetup(data):
  358.             (five, null, _unused, status) = map(ord, data)
  359.             if five != 5:
  360.                 raise Exception('Was expecting 5, got: %r', five)
  361.             five != 5
  362.             if null != 0:
  363.                 raise Exception('Connection failed, reason code was: %r', null)
  364.             null != 0
  365.             if status in (1, 3):
  366.                 this.incoming_host_type = status
  367.                 return None
  368.             raise Exception('Unknown error occurred.')
  369.  
  370.         _recvproxysetup = (recver,)(_recvproxysetup)
  371.         
  372.         def _sendpstringhost1():
  373.             return ('', 1)
  374.  
  375.         _sendpstringhost1 = sender(_sendpstringhost1)
  376.         
  377.         def _recvpstringhost1(data):
  378.             this.hostlen = ord(data)
  379.  
  380.         _recvpstringhost1 = (recver,)(_recvpstringhost1)
  381.         
  382.         def _sendpstringhost2():
  383.             return ('', this.hostlen)
  384.  
  385.         _sendpstringhost2 = (sender,)(_sendpstringhost2)
  386.         
  387.         def _recvpstringhost2(data):
  388.             this.boundhost = data
  389.  
  390.         _recvpstringhost2 = (recver,)(_recvpstringhost2)
  391.         
  392.         def _sendiphost():
  393.             return ('', 4)
  394.  
  395.         _sendiphost = sender(_sendiphost)
  396.         
  397.         def _recvhost(data):
  398.             this.boundhost = socket.inet_ntoa(data)
  399.  
  400.         _recvhost = (recver,)(_recvhost)
  401.         
  402.         def _getport():
  403.             return ('', 2)
  404.  
  405.         _getport = sender(_getport)
  406.         
  407.         def _recvport(data):
  408.             (this.boundport,) = unpack('!H', data)
  409.  
  410.         _recvport = (None, recver)(_recvport)
  411.         steps = ((_recvauthtype, _sendauthtype, None), (_recvauth, (_sendauth,), (lambda : this.authtype)), (_recvproxysetup, _sendproxysetup, None), (_recvhost, (_sendiphost,), (lambda : this.incoming_host_type == 1)), (_recvpstringhost1, (_sendpstringhost1,), (lambda : this.incoming_host_type == 3)), (_recvpstringhost2, (_sendpstringhost2,), (lambda : this.incoming_host_type == 3)), (_recvport, _getport, None))
  412.         for recvr, sendr, check in steps:
  413.             if check is None or check():
  414.                 yield sendr
  415.                 None(recvr)
  416.                 continue
  417.         
  418.         self._ProxySocket__proxysockname = (this.boundhost, this.boundport)
  419.         if this.resolved_ip is not None:
  420.             self._ProxySocket__proxypeername = (socket.inet_ntoa(this.resolved_ip), destport)
  421.         else:
  422.             self._ProxySocket__proxypeername = (destaddr, destport)
  423.         if not this.errors:
  424.             self._negotiation_done()
  425.         else:
  426.             self.close()
  427.  
  428.     
  429.     def _negotiatesocks5(self):
  430.         gen = self._negotiatesocks5_gen()
  431.         
  432.         def handler(data):
  433.             log.info('ProxySocket._negotiatesocks5: in =%r', data)
  434.             
  435.             try:
  436.                 next = gen.send(data)
  437.             except StopIteration:
  438.                 return None
  439.  
  440.             (data, term) = next()
  441.             if data and ord(data[0]) == 1:
  442.                 logdata = '<authstring omitted>'
  443.             else:
  444.                 logdata = data
  445.             log.info('ProxySocket._negotiatesocks5: out=%r, terminator=%r', logdata, term)
  446.             self.push(data)
  447.             self.push_handler(handler)
  448.             self.set_terminator(term)
  449.  
  450.         handler(None)
  451.  
  452.     
  453.     def __repr__(self):
  454.         parentrepr = asocket.__repr__(self).strip('<>')
  455.         return '<%s, fileno=%r>' % (parentrepr, self._fileno)
  456.  
  457.  
  458.  
  459. def main():
  460.     testapp = testapp
  461.     import tests.testapp
  462.     end = end
  463.     import AsyncoreThread
  464.     import wx
  465.     a = testapp('../..')
  466.     a.toggle_crust()
  467.     
  468.     class HeadSocket(asocket):
  469.         
  470.         def __init__(self, *a, **k):
  471.             asocket.__init__(self, *a, **k)
  472.             self.set_terminator('\r\n\r\n')
  473.             self.push('HEAD / HTTP/1.0\r\n\r\n')
  474.             self.push_handler((lambda d: log.info(repr(d))))
  475.  
  476.         
  477.         def GetProxyInfo(self):
  478.             return { }
  479.  
  480.  
  481.     h = HeadSocket()
  482.     h.connect(('www.google.com', 80), success = (lambda s = h: log.info('success! socket: %r', s)))
  483.     a.MainLoop()
  484.     end()
  485.  
  486. if __name__ == '__main__':
  487.     
  488.     def GetProxyInfo():
  489.         return dict(proxytype = 3, username = 'digsby', password = 'password', addr = 'athena', port = 9999)
  490.  
  491.     print main()
  492.  
  493.