home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2009 June / maximum-cd-2009-06.iso / DiscContents / digsby_setup.exe / lib / msn / MsnHttpSocket.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-02-26  |  9.6 KB  |  297 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import threading
  5. import traceback
  6. import collections
  7. import time
  8. import logging
  9. import httplib
  10. import pprint
  11. import threading
  12. import util
  13. import util.allow_once as once
  14. import util.httplib2 as httplib2
  15. import util.threads.threadpool as threadpool
  16. import common
  17. import common.asynchttp as asynchttp
  18. log = logging.getLogger('msnhttp')
  19. import msn
  20. MIMEParse = msn.util.mime_to_dict
  21.  
  22. class MsnHttpSocket(msn.MSNSocketBase):
  23.     POLLINTERVAL = 3
  24.     proto = 'http'
  25.     gateway_ip = 'gateway.messenger.hotmail.com'
  26.     gateway_path = '/gateway/gateway.dll'
  27.     gateway_port = 80
  28.     
  29.     def get_local_sockname(self):
  30.         return ('localhost', 0)
  31.  
  32.     
  33.     def endpoint(self):
  34.         if self.gateway_port != httplib.HTTP_PORT:
  35.             s = '%s://%s:%s%s' % (self.proto, self.gateway_ip, self.gateway_port, self.gateway_path)
  36.         else:
  37.             s = '%s://%s%s' % (self.proto, self.gateway_ip, self.gateway_path)
  38.         return s
  39.  
  40.     endpoint = property(endpoint)
  41.     
  42.     def __init__(self, *a, **k):
  43.         self._session_id = None
  44.         msn.MSNSocketBase.__init__(self, *a, **k)
  45.         self._q = []
  46.         self._waiting = False
  47.         self._poller = util.RepeatTimer(self.POLLINTERVAL, self._poll)
  48.         self._poller._verbose = False
  49.         self._closed = False
  50.         self._paused = False
  51.  
  52.     
  53.     def connect(self, type_host):
  54.         (type, host) = self._parse_addr(type_host)
  55.         self.typehost = type_host
  56.         self.type = type
  57.         self.host = self._server = host
  58.         self.on_connect()
  59.  
  60.     _connect = connect
  61.     
  62.     def _parse_addr(self, type_addr):
  63.         
  64.         try:
  65.             (type, addr) = type_addr
  66.         except (ValueError, TypeError):
  67.             raise TypeError("%r.connect argument must be <type 'tuple'> (type, addr) not %r (%r)", type(self).__name__, type(host_port), host_port)
  68.  
  69.         bad_addr = False
  70.         port = None
  71.         if len(addr) == 1:
  72.             host = addr[0]
  73.             port = 80
  74.         elif isinstance(addr, basestring):
  75.             (host, port) = util.srv_str_to_tuple(addr, 80)
  76.         elif len(addr) == 2:
  77.             (host, port) = addr
  78.         else:
  79.             bad_addr = True
  80.         
  81.         try:
  82.             port = int(port)
  83.         except ValueError:
  84.             bad_addr = True
  85.  
  86.         if bad_addr:
  87.             raise TypeError('%r.connect argument\'s second element must be either string ("srv" or "srv:port") or tuple (("srv", port) or ("srv",)).Got %r instead' % addr)
  88.         
  89.         return (type, host)
  90.  
  91.     
  92.     def connect_args_for(self, type, addr):
  93.         return ((type.upper(), addr),)
  94.  
  95.     
  96.     def _poll(self):
  97.         if not self._waiting:
  98.             self.send(None)
  99.         
  100.  
  101.     
  102.     def pause(self):
  103.         self._paused = True
  104.  
  105.     
  106.     def unpause(self):
  107.         self._paused = False
  108.         common.netcall(self.process)
  109.  
  110.     
  111.     def send(self, msgobj, trid = sentinel, callback = None, **kw):
  112.         self._q.append((msgobj, trid, callback, kw))
  113.         if not self._paused:
  114.             common.netcall(self.process)
  115.         
  116.  
  117.     send = util.callsback(send)
  118.     
  119.     def process(self):
  120.         if not (self._q) or self._waiting:
  121.             return None
  122.         
  123.         self._waiting = True
  124.         data = []
  125.         sending = []
  126.         queue = self._q[:]
  127.         self._q[:] = []
  128.         while queue:
  129.             (msgobj, trid, callback, kw) = queue.pop(0)
  130.             if msgobj is not None:
  131.                 self.set_trid(msgobj, trid)
  132.                 self.set_callbacks(msgobj, callback)
  133.                 data.append(str(msgobj))
  134.             
  135.             sending.append(callback)
  136.         if self._session_id is None:
  137.             url_kws = dict(Action = 'open', Server = self.type, IP = self.host)
  138.         elif len(data) == 0:
  139.             url_kws = dict(Action = 'poll', SessionID = self._session_id)
  140.         else:
  141.             url_kws = dict(SessionID = self._session_id)
  142.         data = ''.join(data)
  143.         req = self.make_request(url_kws, data = data)
  144.         
  145.         def _transport_error(_req = None, _resp = (None, None, None)):
  146.             log.error('Transport error in MsnHttpSocket: req = %r, resp = %r', _req, _resp)
  147.             if isinstance(_req, Exception):
  148.                 e = _req
  149.             elif isinstance(_resp, Exception):
  150.                 e = _resp
  151.             else:
  152.                 e = _resp
  153.             for cb in sending:
  154.                 cb_error = getattr(callback, 'error', None)
  155.                 if cb_error is not None:
  156.                     cb_error(self, e)
  157.                     continue
  158.             
  159.             
  160.             try:
  161.                 del self.gateway_ip
  162.             except AttributeError:
  163.                 pass
  164.  
  165.             self._on_send_error(e)
  166.  
  167.         asynchttp.httpopen(req, success = self._on_response, error = _transport_error)
  168.  
  169.     
  170.     def fix_session_id(self, sess):
  171.         return sess
  172.  
  173.     
  174.     def _on_response(self, request, response):
  175.         if request.get_data():
  176.             log.debug_s('OUT : %r', request.get_data())
  177.         
  178.         if self._session_id is None:
  179.             self._poller.start()
  180.         
  181.         session_info = MIMEParse(response['x-msn-messenger'])
  182.         self.gateway_ip = session_info.get('GW-IP', self.gateway_ip)
  183.         self._session_id = self.fix_session_id(session_info.get('SessionID', None))
  184.         close = session_info.get('Session', '').lower() == 'close'
  185.         if self._session_id is None and not close:
  186.             raise Exception("Didn't get a session ID!")
  187.         
  188.         self._waiting = False
  189.         if not close:
  190.             common.netcall(self.process)
  191.         
  192.         if close:
  193.             self._session_id = None
  194.         
  195.         data = response.body
  196.         self._process_data(data)
  197.         if close:
  198.             self.on_close()
  199.         
  200.  
  201.     
  202.     def _process_data(self, data):
  203.         line = data.readline()
  204.         while line:
  205.             payload = False
  206.             line.rstrip('\r\n')
  207.             dlist = line.split()
  208.             cmd = dlist[0]
  209.             if cmd in self.payload_commands:
  210.                 payload = True
  211.                 
  212.                 try:
  213.                     sz = int(dlist[-1])
  214.                 except ValueError:
  215.                     sz = 0
  216.  
  217.                 line += data.read(sz)
  218.             
  219.             
  220.             try:
  221.                 msg = msn.Message.from_net(line, payload)
  222.                 self.on_message(msg)
  223.             except Exception:
  224.                 e = None
  225.                 log.error('Error handling %r. e = %r', line, e)
  226.                 traceback.print_exc()
  227.  
  228.             line = data.readline()
  229.  
  230.     
  231.     def _on_send_error(self, e):
  232.         log.error('Something bad happened in MsnHttpSocket: %r', e)
  233.         self.on_conn_error(e)
  234.  
  235.     
  236.     def make_request(self, url_kws, data = None):
  237.         url = util.UrlQuery(self.endpoint, url_kws)
  238.         headers = {
  239.             'Accept': '*/*',
  240.             'Content-Type': 'text/xml; charset=utf-8',
  241.             'User-Agent': 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.0; SIMBAR={0B74DA00-76D2-11DD-9ABA-0016CFF93348}; SLCC1; .NET CLR 2.0.50727; Media Center PC 5.0; .NET CLR 3.0.04506; .NET CLR 3.5.21022; .NET CLR 1.1.4322; Windows Live Messenger BETA 9.0.1407)',
  242.             'Cache-Control': 'no-cache',
  243.             'Accept-Language': 'en-us' }
  244.         req = asynchttp.HTTPRequest.make_request(url, data = data, headers = headers, method = 'POST')
  245.         return req
  246.  
  247.     
  248.     def close(self):
  249.         log.info('Closing %r', self)
  250.         msn.MSNSocketBase.close(self)
  251.         del self._q[:]
  252.         if self._session_id is None:
  253.             self.on_close()
  254.         else:
  255.             self.send(msn.Message('OUT'))
  256.  
  257.     close = once.allow_once(close)
  258.     
  259.     def on_close(self):
  260.         log.info('on_close: %r', self)
  261.         self._closed = True
  262.         self._poller.stop()
  263.         self._on_response = Null
  264.         self._on_send_error = Null
  265.         self._session_id = None
  266.         self.gateway_ip = type(self).gateway_ip
  267.         del self._q[:]
  268.         self.pause()
  269.         msn.MSNSocketBase.on_close(self)
  270.  
  271.     _disconnect = close_when_done = close
  272.     
  273.     def __repr__(self):
  274.         return '<%s session_id=%r gateway_ip=%r>' % (type(self).__name__, self._session_id, self.gateway_ip)
  275.  
  276.  
  277.  
  278. def main():
  279.     scktype = MsnHttpSocket
  280.     sck = scktype()
  281.     args = sck.connect_args_for('NS', ('messenger.hotmail.com', 1863))
  282.     print args
  283.     sck.connect(*args)
  284.     sck.send(msn.Message('VER', 'MSNP8', 'CVR0'), trid = True)
  285.     app.toggle_crust()
  286.     app.MainLoop()
  287.  
  288. if __name__ == '__main__':
  289.     import digsbysite
  290.     import netextensions
  291.     from tests.testapp import testapp
  292.     logging.getLogger('events').setLevel(1)
  293.     app = testapp('.')
  294.     threadpool.ThreadPool(5)
  295.     main()
  296.  
  297.