home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2012 January / maximum-cd-2012-01.iso / DiscContents / digsby_setup.exe / lib / digsby / loginutil.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-10-05  |  8.3 KB  |  265 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. from socket import SocketType as socket
  5. from hashlib import sha1, md5
  6. from struct import pack, unpack
  7. from common.timeoutsocket import TimeoutSocketOne
  8. from functools import partial
  9. from common.timeoutsocket import TimeoutSocketMulti
  10. from util import Timer
  11. from util import lock
  12. from traceback import print_exc
  13. from logging import getLogger
  14. log = getLogger('loginutil')
  15. POLL_SLEEP_TIME = 3.5
  16.  
  17. class DigsbyLoginError(Exception):
  18.     
  19.     def __init__(self, reason):
  20.         self.reason = reason
  21.         Exception.__init__(self, {
  22.             'auth': 'Incorrect username or password.',
  23.             'server': 'Server is unable to authenticate you at this time.',
  24.             'client': 'Could not contact remote server. Check your internet connection.',
  25.             'connlost': 'The connection to the server was unexpectedly terminated.' }.get(reason, 'Unknown error: %r' % reason))
  26.  
  27.  
  28.  
  29. def send_pstring(sck, str):
  30.     sck.sendall(pack('!I', len(str)))
  31.     sck.sendall(str)
  32.     print '>>>', str
  33.  
  34.  
  35. def recv_pstring(sck):
  36.     i = unpack('!I', sck.recv(4))[0]
  37.     print '<<<', i
  38.     v = sck.recv(i)
  39.     print '<<<', v
  40.     return v
  41.  
  42.  
  43. def login(srv, cid, un, password):
  44.     s = socket()
  45.     s.connect(srv)
  46.     send_pstring(s, cid)
  47.     send_pstring(s, un)
  48.     send_pstring(s, password)
  49.     
  50.     try:
  51.         code = recv_pstring(s)
  52.         if code == 'success':
  53.             cookie = recv_pstring(s)
  54.             servers = recv_pstring(s)
  55.             servers = servers.split(' ')
  56.             return (cookie, servers)
  57.         if code == 'error':
  58.             reason = recv_pstring(s)
  59.             raise DigsbyLoginError(reason)
  60.         code == 'error'
  61.         raise DigsbyLoginError('client')
  62.     except DigsbyLoginError:
  63.         e = None
  64.         raise e
  65.     except Exception:
  66.         e = None
  67.         print_exc()
  68.         raise DigsbyLoginError('client')
  69.  
  70.  
  71.  
  72. def custom_crypt(c):
  73.     return str(int(c) + 1)
  74.  
  75.  
  76. def hash_cookie(cookie, password):
  77.     return sha1(custom_crypt(cookie) + password).hexdigest().lower()
  78.  
  79.  
  80. def connect(host, jid, password):
  81.     raise NotImplementedError
  82.  
  83.  
  84. def digsby_login(srv, cid, un, password):
  85.     password = md5(password).hexdigest()
  86.     (cookie, host) = login(srv, cid, un, password)
  87.     password = hash_cookie(cookie, password)
  88.     connect(host, un, password)
  89.  
  90.  
  91. def make_pstring(s):
  92.     l = len(s)
  93.     format_str = '!I%ds' % l
  94.     return pack(format_str, l, s)
  95.  
  96.  
  97. class DigsbyConnect(TimeoutSocketOne):
  98.     _SERVERTIMEOUT = 8
  99.     
  100.     def stale_connection(self):
  101.         if getattr(self, '_triumphant', False):
  102.             log.info('stale_connection was called but i already won! yayayay')
  103.         else:
  104.             log.info('%r had a stale connection. Calling do_fail (%r) with a connlost error', self, self.do_fail)
  105.             self.do_fail(DigsbyLoginError('connlost'))
  106.  
  107.     
  108.     def succ(self):
  109.         generator = self.do_login()
  110.         self._timeouttimer = Timer(self._SERVERTIMEOUT, self.stale_connection)
  111.         self._timeouttimer.start()
  112.         self.run_sequence(generator)
  113.  
  114.     
  115.     def handle_error(self, e = None):
  116.         if hasattr(self, '_timeouttimer'):
  117.             self._timeouttimer.stop()
  118.         
  119.         TimeoutSocketOne.handle_error(self)
  120.  
  121.     handle_error = lock(handle_error)
  122.     
  123.     def handle_expt(self):
  124.         if hasattr(self, '_timeouttimer'):
  125.             self._timeouttimer.stop()
  126.         
  127.         TimeoutSocketOne.handle_expt(self)
  128.  
  129.     handle_expt = lock(handle_expt)
  130.     
  131.     def handle_close(self):
  132.         if hasattr(self, '_timeouttimer'):
  133.             self._timeouttimer.stop()
  134.         
  135.         TimeoutSocketOne.handle_close(self)
  136.  
  137.     handle_close = lock(handle_close)
  138.     
  139.     def do_login(self):
  140.         login_str = make_pstring(self.cid) + make_pstring(self.un) + make_pstring(self.password)
  141.         yield (4, login_str)
  142.         codelen = None
  143.         codelen = unpack('!I', codelen)[0]
  144.         if codelen <= 0:
  145.             raise DigsbyLoginError('client')
  146.         codelen <= 0
  147.         yield (codelen, '')
  148.         code = None
  149.         
  150.         try:
  151.             if code == 'success':
  152.                 yield (4, '')
  153.                 cookielen = None(unpack, '!I')[0]
  154.                 yield (cookielen, '')
  155.                 cookie = None
  156.                 log.debug('Got cookie: %r', cookie)
  157.                 yield (4, '')
  158.                 serverslen = None(unpack, '!I')[0]
  159.                 yield (serverslen, '')
  160.                 servers = None
  161.                 log.debug('Got servers: %r', servers)
  162.                 servers = servers.split(' ')
  163.                 self.cookie = cookie
  164.                 self.servers = servers
  165.                 self._triumphant = True
  166.                 return None
  167.             if code == 'error':
  168.                 log.debug('Got error!')
  169.                 yield (4, '')
  170.                 reasonlen = code == 'success'(unpack, '!I')[0]
  171.                 yield (reasonlen, '')
  172.                 reason = None
  173.                 log.debug('Got error reason: %r', reason)
  174.                 raise DigsbyLoginError(reason)
  175.             code == 'error'
  176.             log.debug('Unknown error occurred! blaming the client!')
  177.             raise DigsbyLoginError('client')
  178.         except DigsbyLoginError:
  179.             e = None
  180.             if e.reason == 'server':
  181.                 log.debug('Got "upgrading digsby" error code. Sleeping.')
  182.                 import time
  183.                 time.sleep(POLL_SLEEP_TIME)
  184.             
  185.             raise e
  186.         except Exception:
  187.             e = None
  188.             print_exc()
  189.             raise DigsbyLoginError('client')
  190.         finally:
  191.             self._timeouttimer.stop()
  192.  
  193.  
  194.     
  195.     def run_sequence(self, generator):
  196.         
  197.         try:
  198.             (to_read, out_bytes) = generator.send(self.data)
  199.         except StopIteration:
  200.             self.close()
  201.             self._timeouttimer.stop()
  202.             return TimeoutSocketOne.succ(self)
  203.             except DigsbyLoginError:
  204.                 e = None
  205.                 print 'DigsbyLoginError:', e.reason
  206.                 self._timeouttimer.stop()
  207.                 self.do_fail(e)
  208.                 return None
  209.                 except Exception:
  210.                     e = None
  211.                     print 'Exception', e
  212.                     self._timeouttimer.stop()
  213.                     self.do_fail(e)
  214.                     return None
  215.                 else:
  216.                     bytes = str(out_bytes)
  217.                     if out_bytes:
  218.                         log.info('Sending %r', bytes)
  219.                         self.push(bytes)
  220.                     
  221.  
  222.         self.data = ''
  223.         self.found_terminator = partial(self.run_sequence, generator)
  224.         if isinstance(to_read, int):
  225.             self.set_terminator(to_read)
  226.         else:
  227.             self.set_terminator(to_read._size())
  228.  
  229.  
  230.  
  231. def connected(sock):
  232.     print 'cookie:', sock.cookie, 'servers:', sock.servers
  233.  
  234.  
  235. def youfail():
  236.     print 'FAIL'
  237.  
  238.  
  239. class DigsbyLoginMulti(TimeoutSocketMulti):
  240.     
  241.     def lose(self, e = None):
  242.         if e or getattr(e, 'reason', None) == 'auth' or self.attempts >= len(self._ips):
  243.             self.on_fail(e)
  244.         else:
  245.             self.try_connect()
  246.  
  247.  
  248.  
  249. def new_digsby_login(addrtuples, cid, un, password, win, lose):
  250.     
  251.     def provide(self):
  252.         self.cid = cid
  253.         self.un = un
  254.         self.password = password
  255.  
  256.     t = DigsbyLoginMulti()
  257.     t.tryconnect(addrtuples, win, lose, timeout = 20, cls = DigsbyConnect, provide_init = provide)
  258.  
  259. if __name__ == '__main__':
  260.     password = md5('password2').hexdigest()
  261.     new_digsby_login([
  262.         ('129.21.160.40', 5555),
  263.         ('129.21.160.41', 5555)], 'foo', 'chris', password, connected, youfail)
  264.  
  265.