home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / pyxmpp / jabber / clientstream.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  11.7 KB  |  360 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. __revision__ = '$Id: clientstream.py 703 2010-04-03 17:45:43Z jajcus $'
  5. __docformat__ = 'restructuredtext en'
  6. import hashlib
  7. import logging
  8. from pyxmpp.iq import Iq
  9. from pyxmpp.utils import to_utf8, from_utf8
  10. from pyxmpp.jid import JID
  11. from pyxmpp.clientstream import ClientStream
  12. from pyxmpp.jabber.register import Register
  13. from pyxmpp.exceptions import ClientStreamError, LegacyAuthenticationError, RegistrationError
  14.  
  15. class LegacyClientStream(ClientStream):
  16.     
  17.     def __init__(self, jid, password = None, server = None, port = 5222, auth_methods = ('sasl:DIGEST-MD5', 'digest'), tls_settings = None, keepalive = 0, owner = None):
  18.         (self.authenticated, self.available_auth_methods, self.auth_stanza, self.peer_authenticated, self.auth_method_used, self.registration_callback, self.registration_form, self._LegacyClientStream__register) = (None, None, None, None, None, None, None, None)
  19.         ClientStream.__init__(self, jid, password, server, port, auth_methods, tls_settings, keepalive, owner)
  20.         self._LegacyClientStream__logger = logging.getLogger('pyxmpp.jabber.LegacyClientStream')
  21.  
  22.     
  23.     def _reset(self):
  24.         ClientStream._reset(self)
  25.         self.available_auth_methods = None
  26.         self.auth_stanza = None
  27.         self.registration_callback = None
  28.  
  29.     
  30.     def _post_connect(self):
  31.         if not self.initiator:
  32.             if 'plain' in self.auth_methods or 'digest' in self.auth_methods:
  33.                 self.set_iq_get_handler('query', 'jabber:iq:auth', self.auth_in_stage1)
  34.                 self.set_iq_set_handler('query', 'jabber:iq:auth', self.auth_in_stage2)
  35.             
  36.         elif self.registration_callback:
  37.             iq = Iq(stanza_type = 'get')
  38.             iq.set_content(Register())
  39.             self.set_response_handlers(iq, self.registration_form_received, self.registration_error)
  40.             self.send(iq)
  41.             return None
  42.         ClientStream._post_connect(self)
  43.  
  44.     
  45.     def _post_auth(self):
  46.         ClientStream._post_auth(self)
  47.         if not self.initiator:
  48.             self.unset_iq_get_handler('query', 'jabber:iq:auth')
  49.             self.unset_iq_set_handler('query', 'jabber:iq:auth')
  50.         
  51.  
  52.     
  53.     def _try_auth(self):
  54.         if self.authenticated:
  55.             self._LegacyClientStream__logger.debug('try_auth: already authenticated')
  56.             return None
  57.         self._LegacyClientStream__logger.debug('trying auth: %r' % (self._auth_methods_left,))
  58.         if not self._auth_methods_left:
  59.             raise LegacyAuthenticationError, 'No allowed authentication methods available'
  60.         self._auth_methods_left
  61.         method = self._auth_methods_left[0]
  62.         if method.startswith('sasl:'):
  63.             return ClientStream._try_auth(self)
  64.         if method not in ('plain', 'digest'):
  65.             self._auth_methods_left.pop(0)
  66.             self._LegacyClientStream__logger.debug('Skipping unknown auth method: %s' % method)
  67.             return self._try_auth()
  68.         if self.available_auth_methods is not None:
  69.             self._auth_methods_left.pop(0)
  70.             if method in self.available_auth_methods:
  71.                 self.auth_method_used = method
  72.                 self.auth_stanza = None
  73.                 return None
  74.             self._LegacyClientStream__logger.debug('Skipping unavailable auth method: %s' % method)
  75.             return self._try_auth()
  76.         self.available_auth_methods is not None
  77.         self._auth_stage1()
  78.  
  79.     
  80.     def auth_in_stage1(self, stanza):
  81.         self.lock.acquire()
  82.         
  83.         try:
  84.             if 'plain' not in self.auth_methods and 'digest' not in self.auth_methods:
  85.                 iq = stanza.make_error_response('not-allowed')
  86.                 self.send(iq)
  87.                 return None
  88.             iq = stanza.make_result_response()
  89.             q = iq.new_query('jabber:iq:auth')
  90.             q.newChild(None, 'username', None)
  91.             q.newChild(None, 'resource', None)
  92.             if 'plain' in self.auth_methods:
  93.                 q.newChild(None, 'password', None)
  94.             
  95.             if 'digest' in self.auth_methods:
  96.                 q.newChild(None, 'digest', None)
  97.             
  98.             self.send(iq)
  99.             iq.free()
  100.         finally:
  101.             self.lock.release()
  102.  
  103.  
  104.     
  105.     def auth_in_stage2(self, stanza):
  106.         self.lock.acquire()
  107.         
  108.         try:
  109.             if 'plain' not in self.auth_methods and 'digest' not in self.auth_methods:
  110.                 iq = stanza.make_error_response('not-allowed')
  111.                 self.send(iq)
  112.                 return None
  113.             username = stanza.xpath_eval('a:query/a:username', {
  114.                 'a': 'jabber:iq:auth' })
  115.             if username:
  116.                 username = from_utf8(username[0].getContent())
  117.             
  118.             resource = stanza.xpath_eval('a:query/a:resource', {
  119.                 'a': 'jabber:iq:auth' })
  120.             if resource:
  121.                 resource = from_utf8(resource[0].getContent())
  122.             
  123.             if not username or not resource:
  124.                 self._LegacyClientStream__logger.debug('No username or resource found in auth request')
  125.                 iq = stanza.make_error_response('bad-request')
  126.                 self.send(iq)
  127.                 return None
  128.             if stanza.xpath_eval('a:query/a:password', {
  129.                 'a': 'jabber:iq:auth' }):
  130.                 if 'plain' not in self.auth_methods:
  131.                     iq = stanza.make_error_response('not-allowed')
  132.                     self.send(iq)
  133.                     return None
  134.                 return self._plain_auth_in_stage2(username, resource, stanza)
  135.             stanza.xpath_eval('a:query/a:password', {
  136.                 'a': 'jabber:iq:auth' })
  137.             if stanza.xpath_eval('a:query/a:digest', {
  138.                 'a': 'jabber:iq:auth' }):
  139.                 if 'plain' not in self.auth_methods:
  140.                     iq = stanza.make_error_response('not-allowed')
  141.                     self.send(iq)
  142.                     return None
  143.                 return self._digest_auth_in_stage2(username, resource, stanza)
  144.             stanza.xpath_eval('a:query/a:digest', {
  145.                 'a': 'jabber:iq:auth' })
  146.         finally:
  147.             self.lock.release()
  148.  
  149.  
  150.     
  151.     def _auth_stage1(self):
  152.         iq = Iq(stanza_type = 'get')
  153.         q = iq.new_query('jabber:iq:auth')
  154.         q.newTextChild(None, 'username', to_utf8(self.my_jid.node))
  155.         q.newTextChild(None, 'resource', to_utf8(self.my_jid.resource))
  156.         self.send(iq)
  157.         self.set_response_handlers(iq, self.auth_stage2, self.auth_error, self.auth_timeout, timeout = 60)
  158.         iq.free()
  159.  
  160.     
  161.     def auth_timeout(self):
  162.         self.lock.acquire()
  163.         
  164.         try:
  165.             self._LegacyClientStream__logger.debug('Timeout while waiting for jabber:iq:auth result')
  166.             if self._auth_methods_left:
  167.                 self._auth_methods_left.pop(0)
  168.         finally:
  169.             self.lock.release()
  170.  
  171.  
  172.     
  173.     def auth_error(self, stanza):
  174.         self.lock.acquire()
  175.         
  176.         try:
  177.             err = stanza.get_error()
  178.             ae = err.xpath_eval('e:*', {
  179.                 'e': 'jabber:iq:auth:error' })
  180.             if ae:
  181.                 ae = ae[0].name
  182.             else:
  183.                 ae = err.get_condition().name
  184.             raise LegacyAuthenticationError, 'Authentication error condition: %s' % (ae,)
  185.         finally:
  186.             self.lock.release()
  187.  
  188.  
  189.     
  190.     def auth_stage2(self, stanza):
  191.         self.lock.acquire()
  192.         
  193.         try:
  194.             self._LegacyClientStream__logger.debug('Procesing auth response...')
  195.             self.available_auth_methods = []
  196.             if stanza.xpath_eval('a:query/a:digest', {
  197.                 'a': 'jabber:iq:auth' }) and self.stream_id:
  198.                 self.available_auth_methods.append('digest')
  199.             
  200.             if stanza.xpath_eval('a:query/a:password', {
  201.                 'a': 'jabber:iq:auth' }):
  202.                 self.available_auth_methods.append('plain')
  203.             
  204.             self.auth_stanza = stanza.copy()
  205.             self._try_auth()
  206.         finally:
  207.             self.lock.release()
  208.  
  209.  
  210.     
  211.     def _plain_auth_stage2(self, _unused):
  212.         iq = Iq(stanza_type = 'set')
  213.         q = iq.new_query('jabber:iq:auth')
  214.         q.newTextChild(None, 'username', to_utf8(self.my_jid.node))
  215.         q.newTextChild(None, 'resource', to_utf8(self.my_jid.resource))
  216.         q.newTextChild(None, 'password', to_utf8(self.password))
  217.         self.send(iq)
  218.         self.set_response_handlers(iq, self.auth_finish, self.auth_error)
  219.         iq.free()
  220.  
  221.     
  222.     def _plain_auth_in_stage2(self, username, _unused, stanza):
  223.         password = stanza.xpath_eval('a:query/a:password', {
  224.             'a': 'jabber:iq:auth' })
  225.         if password:
  226.             password = from_utf8(password[0].getContent())
  227.         
  228.         if not password:
  229.             self._LegacyClientStream__logger.debug('No password found in plain auth request')
  230.             iq = stanza.make_error_response('bad-request')
  231.             self.send(iq)
  232.             return None
  233.         if self.check_password(username, password):
  234.             iq = stanza.make_result_response()
  235.             self.send(iq)
  236.             self.peer_authenticated = True
  237.             self.auth_method_used = 'plain'
  238.             self.state_change('authorized', self.peer)
  239.             self._post_auth()
  240.         else:
  241.             self._LegacyClientStream__logger.debug('Plain auth failed')
  242.             iq = stanza.make_error_response('bad-request')
  243.             e = iq.get_error()
  244.             e.add_custom_condition('jabber:iq:auth:error', 'user-unauthorized')
  245.             self.send(iq)
  246.  
  247.     
  248.     def _digest_auth_stage2(self, _unused):
  249.         iq = Iq(stanza_type = 'set')
  250.         q = iq.new_query('jabber:iq:auth')
  251.         q.newTextChild(None, 'username', to_utf8(self.my_jid.node))
  252.         q.newTextChild(None, 'resource', to_utf8(self.my_jid.resource))
  253.         digest = hashlib.sha1(to_utf8(self.stream_id) + to_utf8(self.password)).hexdigest()
  254.         q.newTextChild(None, 'digest', digest)
  255.         self.send(iq)
  256.         self.set_response_handlers(iq, self.auth_finish, self.auth_error)
  257.         iq.free()
  258.  
  259.     
  260.     def _digest_auth_in_stage2(self, username, _unused, stanza):
  261.         digest = stanza.xpath_eval('a:query/a:digest', {
  262.             'a': 'jabber:iq:auth' })
  263.         if digest:
  264.             digest = digest[0].getContent()
  265.         
  266.         if not digest:
  267.             self._LegacyClientStream__logger.debug('No digest found in digest auth request')
  268.             iq = stanza.make_error_response('bad-request')
  269.             self.send(iq)
  270.             return None
  271.         (password, pwformat) = self.get_password(username)
  272.         if not password or pwformat != 'plain':
  273.             iq = stanza.make_error_response('bad-request')
  274.             e = iq.get_error()
  275.             e.add_custom_condition('jabber:iq:auth:error', 'user-unauthorized')
  276.             self.send(iq)
  277.             return None
  278.         mydigest = hashlib.sha1(to_utf8(self.stream_id) + to_utf8(password)).hexdigest()
  279.  
  280.     
  281.     def auth_finish(self, _unused):
  282.         self.lock.acquire()
  283.         
  284.         try:
  285.             self._LegacyClientStream__logger.debug('Authenticated')
  286.             self.authenticated = True
  287.             self.state_change('authorized', self.my_jid)
  288.             self._post_auth()
  289.         finally:
  290.             self.lock.release()
  291.  
  292.  
  293.     
  294.     def registration_error(self, stanza):
  295.         self.lock.acquire()
  296.         
  297.         try:
  298.             err = stanza.get_error()
  299.             ae = err.xpath_eval('e:*', {
  300.                 'e': 'jabber:iq:auth:error' })
  301.             if ae:
  302.                 ae = ae[0].name
  303.             else:
  304.                 ae = err.get_condition().name
  305.             raise RegistrationError, 'Authentication error condition: %s' % (ae,)
  306.         finally:
  307.             self.lock.release()
  308.  
  309.  
  310.     
  311.     def registration_form_received(self, stanza):
  312.         self.lock.acquire()
  313.         
  314.         try:
  315.             self._LegacyClientStream__register = Register(stanza.get_query())
  316.             self.registration_callback(stanza, self._LegacyClientStream__register.get_form())
  317.         finally:
  318.             self.lock.release()
  319.  
  320.  
  321.     
  322.     def submit_registration_form(self, form):
  323.         self.lock.acquire()
  324.         
  325.         try:
  326.             if form and form.type != 'cancel':
  327.                 self.registration_form = form
  328.                 iq = Iq(stanza_type = 'set')
  329.                 iq.set_content(self._LegacyClientStream__register.submit_form(form))
  330.                 self.set_response_handlers(iq, self.registration_success, self.registration_error)
  331.                 self.send(iq)
  332.             else:
  333.                 self._LegacyClientStream__register = None
  334.         finally:
  335.             self.lock.release()
  336.  
  337.  
  338.     
  339.     def registration_success(self, stanza):
  340.         _unused = stanza
  341.         self.lock.acquire()
  342.         
  343.         try:
  344.             self.state_change('registered', self.registration_form)
  345.             if 'FORM_TYPE' in self.registration_form and self.registration_form['FORM_TYPE'].value == 'jabber:iq:register':
  346.                 if 'username' in self.registration_form:
  347.                     self.my_jid = JID(self.registration_form['username'].value, self.my_jid.domain, self.my_jid.resource)
  348.                 
  349.                 if 'password' in self.registration_form:
  350.                     self.password = self.registration_form['password'].value
  351.                 
  352.             
  353.             self.registration_callback = None
  354.             self._post_connect()
  355.         finally:
  356.             self.lock.release()
  357.  
  358.  
  359.  
  360.