home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / pyxmpp / clientstream.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  7.4 KB  |  236 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. __revision__ = '$Id: clientstream.py 720 2010-04-20 10:31:35Z jajcus $'
  5. __docformat__ = 'restructuredtext en'
  6. import logging
  7. from pyxmpp.stream import Stream
  8. from pyxmpp.streambase import BIND_NS
  9. from pyxmpp.streamsasl import SASLNotAvailable, SASLMechanismNotAvailable
  10. from pyxmpp.jid import JID
  11. from pyxmpp.utils import to_utf8
  12. from pyxmpp.exceptions import StreamError, StreamAuthenticationError, FatalStreamError
  13. from pyxmpp.exceptions import ClientStreamError, FatalClientStreamError
  14.  
  15. class ClientStream(Stream):
  16.     
  17.     def __init__(self, jid, password = None, server = None, port = None, auth_methods = ('sasl:DIGEST-MD5',), tls_settings = None, keepalive = 0, owner = None):
  18.         sasl_mechanisms = []
  19.         for m in auth_methods:
  20.             if not m.startswith('sasl:'):
  21.                 continue
  22.             
  23.             m = m[5:].upper()
  24.             sasl_mechanisms.append(m)
  25.         
  26.         Stream.__init__(self, 'jabber:client', sasl_mechanisms = sasl_mechanisms, tls_settings = tls_settings, keepalive = keepalive, owner = owner)
  27.         self.server = server
  28.         self.port = port
  29.         self.password = password
  30.         self.auth_methods = auth_methods
  31.         self.my_jid = jid
  32.         self.me = None
  33.         self._auth_methods_left = None
  34.         self._ClientStream__logger = logging.getLogger('pyxmpp.ClientStream')
  35.  
  36.     
  37.     def _reset(self):
  38.         Stream._reset(self)
  39.         self._auth_methods_left = []
  40.  
  41.     
  42.     def connect(self, server = None, port = None):
  43.         self.lock.acquire()
  44.         
  45.         try:
  46.             self._connect(server, port)
  47.         finally:
  48.             self.lock.release()
  49.  
  50.  
  51.     
  52.     def _connect(self, server = None, port = None):
  53.         if not (self.my_jid.node) or not (self.my_jid.resource):
  54.             raise ClientStreamError, 'Client JID must have username and resource'
  55.         not (self.my_jid.resource)
  56.         if not server:
  57.             server = self.server
  58.         
  59.         if not port:
  60.             port = self.port
  61.         
  62.         if server:
  63.             self._ClientStream__logger.debug('server: %r', (server,))
  64.             service = None
  65.         else:
  66.             service = 'xmpp-client'
  67.         if port is None:
  68.             port = 5222
  69.         
  70.         if server is None:
  71.             server = self.my_jid.domain
  72.         
  73.         self.me = self.my_jid
  74.         Stream._connect(self, server, port, service, self.my_jid.domain)
  75.  
  76.     
  77.     def accept(self, sock):
  78.         Stream.accept(self, sock, self.my_jid)
  79.  
  80.     
  81.     def _post_connect(self):
  82.         if self.initiator:
  83.             self._auth_methods_left = list(self.auth_methods)
  84.             self._try_auth()
  85.         
  86.  
  87.     
  88.     def _try_auth(self):
  89.         if not self.doc_out:
  90.             self._ClientStream__logger.debug('try_auth: disconnecting already?')
  91.             return None
  92.         if self.authenticated:
  93.             self._ClientStream__logger.debug('try_auth: already authenticated')
  94.             return None
  95.         self._ClientStream__logger.debug('trying auth: %r', (self._auth_methods_left,))
  96.         if not self._auth_methods_left:
  97.             raise StreamAuthenticationError, 'No allowed authentication methods available'
  98.         self._auth_methods_left
  99.         method = self._auth_methods_left[0]
  100.         if method.startswith('sasl:'):
  101.             if self.version:
  102.                 self._auth_methods_left.pop(0)
  103.                 
  104.                 try:
  105.                     mechanism = method[5:].upper()
  106.                     if mechanism != 'EXTERNAL':
  107.                         self._sasl_authenticate(self.my_jid.node, None, mechanism = mechanism)
  108.                     else:
  109.                         self._sasl_authenticate(self.my_jid.node, self.my_jid.bare().as_utf8(), mechanism = mechanism)
  110.                 except (SASLMechanismNotAvailable, SASLNotAvailable):
  111.                     self.authenticated
  112.                     self.authenticated
  113.                     self.doc_out
  114.                     self._ClientStream__logger.debug('Skipping unavailable auth method: %s', (method,))
  115.                     return self._try_auth()
  116.                 
  117.  
  118.             self.authenticated<EXCEPTION MATCH>(SASLMechanismNotAvailable, SASLNotAvailable)
  119.             self._auth_methods_left.pop(0)
  120.             self._ClientStream__logger.debug('Skipping auth method %s as legacy protocol is in use', (method,))
  121.             return self._try_auth()
  122.         method.startswith('sasl:')
  123.         self._auth_methods_left.pop(0)
  124.         self._ClientStream__logger.debug('Skipping unknown auth method: %s', method)
  125.         return self._try_auth()
  126.  
  127.     
  128.     def _get_stream_features(self):
  129.         features = Stream._get_stream_features(self)
  130.         if self.peer_authenticated:
  131.             bind = features.newChild(None, 'bind', None)
  132.             ns = bind.newNs(BIND_NS, None)
  133.             bind.setNs(ns)
  134.             self.set_iq_set_handler('bind', BIND_NS, self.do_bind)
  135.         
  136.         return features
  137.  
  138.     
  139.     def do_bind(self, stanza):
  140.         fr = stanza.get_from()
  141.         if fr and fr != self.peer:
  142.             r = stanza.make_error_response('forbidden')
  143.             self.send(r)
  144.             r.free()
  145.             return None
  146.         resource_n = stanza.xpath_eval('bind:bind/bind:resource', {
  147.             'bind': BIND_NS })
  148.         if resource_n:
  149.             resource = resource_n[0].getContent()
  150.         else:
  151.             resource = 'auto'
  152.         if not resource:
  153.             r = stanza.make_error_response('bad-request')
  154.         else:
  155.             self.unset_iq_set_handler('bind', BIND_NS)
  156.             r = stanza.make_result_response()
  157.             self.peer.set_resource(resource)
  158.             q = r.new_query(BIND_NS, 'bind')
  159.             q.newTextChild(None, 'jid', to_utf8(self.peer.as_unicode()))
  160.             self.state_change('authorized', self.peer)
  161.         r.set_to(None)
  162.         self.send(r)
  163.         r.free()
  164.  
  165.     
  166.     def get_password(self, username, realm = None, acceptable_formats = ('plain',)):
  167.         _unused = realm
  168.         if self.initiator and self.my_jid.node == username and 'plain' in acceptable_formats:
  169.             return (self.password, 'plain')
  170.         return (None, None)
  171.  
  172.     
  173.     def get_realms(self):
  174.         return [
  175.             self.my_jid.domain]
  176.  
  177.     
  178.     def choose_realm(self, realm_list):
  179.         if not realm_list:
  180.             return self.my_jid.domain
  181.         if self.my_jid.domain in realm_list:
  182.             return self.my_jid.domain
  183.         return realm_list[0]
  184.  
  185.     
  186.     def check_authzid(self, authzid, extra_info = None):
  187.         if not extra_info:
  188.             extra_info = { }
  189.         
  190.         if not authzid:
  191.             return 1
  192.         if not self.initiator:
  193.             jid = JID(authzid)
  194.             if not extra_info.has_key('username'):
  195.                 ret = 0
  196.             elif jid.node != extra_info['username']:
  197.                 ret = 0
  198.             elif jid.domain != self.my_jid.domain:
  199.                 ret = 0
  200.             elif not jid.resource:
  201.                 ret = 0
  202.             else:
  203.                 ret = 1
  204.         else:
  205.             ret = 0
  206.         return ret
  207.  
  208.     
  209.     def get_serv_type(self):
  210.         return 'xmpp'
  211.  
  212.     
  213.     def get_serv_name(self):
  214.         return self.my_jid.domain
  215.  
  216.     
  217.     def get_serv_host(self):
  218.         return self.my_jid.domain
  219.  
  220.     
  221.     def fix_out_stanza(self, stanza):
  222.         if self.initiator:
  223.             stanza.set_from(None)
  224.         elif not stanza.get_from():
  225.             stanza.set_from(self.my_jid)
  226.         
  227.  
  228.     
  229.     def fix_in_stanza(self, stanza):
  230.         if self.initiator:
  231.             Stream.fix_in_stanza(self, stanza)
  232.         else:
  233.             stanza.set_from(self.peer)
  234.  
  235.  
  236.