GitLab

at 2016-11-02T22:33:40+01:00

[NooN8] checks if something is not in a list/dict/.. should be done with 'var not in list'

[NooN8] Checks with None should be made with is or is not

[NooN8] make all classes inherit from object

         # If the server supports a mechanism disable all weaker mechanisms.

         password_auth_mechs_strength = ['SCRAM-SHA-1-PLUS', 'SCRAM-SHA-1',

             'DIGEST-MD5', 'PLAIN', 'X-MESSENGER-OAUTH2']

         if self.channel_binding == None:

         if self.channel_binding is None:

             password_auth_mechs_strength.remove('SCRAM-SHA-1-PLUS')

         for i in range(0, len(password_auth_mechs_strength)):

             if password_auth_mechs_strength[i] in self.mecs:

                 raise NodeProcessed

             except kerberos.GSSError as e:

                 log.info('GSSAPI authentication failed: %s' % str(e))

         if 'SCRAM-SHA-1-PLUS' in self.mecs and self.channel_binding != None:

         if 'SCRAM-SHA-1-PLUS' in self.mecs and self.channel_binding is not None:

             self.mecs.remove('SCRAM-SHA-1-PLUS')

             self.mechanism = 'SCRAM-SHA-1-PLUS'

             self._owner._caller.get_password(self.set_password, self.mechanism)

             self.client_nonce = '%x' % rndg.getrandbits(196)

             self.scram_soup = 'n=' + self.username + ',r=' + self.client_nonce

             if self.mechanism == 'SCRAM-SHA-1':

                 if self.channel_binding == None:

                 if self.channel_binding is None:

                     # Client doesn't support Channel Binding

                     self.scram_gs2 = 'n,,' # No CB yet.

                 else:

     return rndg.getrandbits(50)

 class AckChecker():

 class AckChecker(object):

     """

     Class for generating rids and generating and checking acknowledgements in

     BOSH messages

         return self.rid

 class KeyStack():

 class KeyStack(object):

     """

     Class implementing key sequences for BOSH messages

     """

 log = logging.getLogger('nbxmpp.client_nb')

 class NonBlockingClient:

 class NonBlockingClient(object):

     """

     Client class is XMPP connection mountpoint. Objects for authentication,

     network communication, roster, xml parsing ... are plugged to client object.

                 if self.protocol_type != 'BOSH':

                     self._channel_binding = self.Connection.NonBlockingTLS.get_channel_binding()

                     # TLS handshake is finished so channel binding data muss exist

                     assert (self._channel_binding != None)

                     assert (self._channel_binding is not None)

             except NotImplementedError:

                 pass

         if auth_mechs == None:

         if auth_mechs is None:

             self._auth_mechs = SASL_AUTHENTICATION_MECHANISMS | set(['XEP-0078'])

         else:

             self._auth_mechs = auth_mechs

         """

         if data:

             self.Dispatcher.ProcessNonBlocking(data)

         if not 'SASL' in self.__dict__:

         if 'SASL' not in self.__dict__:

             # SASL is pluged out, possible disconnect

             return

         if self.SASL.startsasl == 'in-process':

 XML_DECLARATION = '<?xml version=\'1.0\'?>'

 # FIXME: ugly

 class Dispatcher():

 class Dispatcher(object):

     """

     Why is this here - I needed to redefine Dispatcher for BOSH and easiest way

     was to inherit original Dispatcher (now renamed to XMPPDispatcher). Trouble

             return SelectIdleQueue()

 class IdleObject:

 class IdleObject(object):

     """

     Idle listener interface. Listed methods are called by IdleQueue.

     """

         self._return_result()

 class IdleQueue:

 class IdleQueue(object):

     """

     IdleQueue provide three distinct time based features. Uses select.poll()

         Remove alarm callback alarm_cb scheduled on alarm_time. Returns True if

         it was removed sucessfully, otherwise False

         """

         if not alarm_time in self.alarms:

         if alarm_time not in self.alarms:

             return False

         i = -1

         for i in range(len(self.alarms[alarm_time])):

                 break

         if i != -1:

             del self.alarms[alarm_time][i]

             if self.alarms[alarm_time] == []:

             if not self.alarms[alarm_time]:

                 del self.alarms[alarm_time]

             return True

         else:

 import logging

 log = logging.getLogger('nbxmpp.plugin')

 class PlugIn:

 class PlugIn(object):

     """

     Abstract xmpppy plugin infrastructure code, providing plugging in/out and

     debugging functionality

                     'unsupported-version': UnsupportedVersion,

                     'xml-not-well-formed': XMLNotWellFormed}

 class JID:

 class JID(object):

     """

     JID can be built from string, modified, compared, serialised into string

     """

 import logging

 log = logging.getLogger('nbxmpp.proxy_connectors')

 class ProxyConnector:

 class ProxyConnector(object):

     """

     Interface for proxy-connecting object - when tunnneling XMPP over proxies,

     some connecting process usually has to be done before opening stream. Proxy

         roster representation

         """

         sender = stanza.getAttr('from')

         if not sender is None and not sender.bareMatch(

         if sender is not None and not sender.bareMatch(

         self._owner.User + '@' + self._owner.Server):

             return

         query = stanza.getTag('query')

             return self.NT

         raise AttributeError

 class T:

 class T(object):

     """

     Auxiliary class used to quick access to node's child nodes

     """

         else:

             return self.node.addChild(attr, payload=[val])

 class NodeBuilder:

 class NodeBuilder(object):

     """

     Builds a Node class minidom from data parsed to it. This class used for two

     purposes:

 import logging

 log = logging.getLogger('nbxmpp.smacks')

 class Smacks():

     '''

 class Smacks(object):

     """

     This is Smacks is the Stream Management class. It takes care of requesting

     and sending acks. Also, it keeps track of the unhandled outgoing stanzas.

     The dispatcher has to be able to access this class to increment the

     number of handled stanzas

     '''

     """

     def __init__(self, con):

         self.con = con # Connection object

 import unicodedata

 from encodings import idna

 class ILookupTable:

 class ILookupTable(object):

     """

     Interface for character lookup classes

     """

         """

         pass

 class IMappingTable:

 class IMappingTable(object):

     """

     Interface for character mapping classes

     """

         """

         pass

 class LookupTableFromFunction:

 class LookupTableFromFunction(object):

     __implements__ = ILookupTable

     def __init__(self, in_table_function):

         self.lookup = in_table_function

 class LookupTable:

 class LookupTable(object):

     __implements__ = ILookupTable

     def __init__(self, table):

     def lookup(self, c):

         return c in self._table

 class MappingTableFromFunction:

 class MappingTableFromFunction(object):

     __implements__ = IMappingTable

     def __init__(self, map_table_function):

         self.map = map_table_function

 class EmptyMappingTable:

 class EmptyMappingTable(object):

     __implements__ = IMappingTable

     def __init__(self, in_table_function):

             raise UnicodeError("Violation of BIDI Requirement 3")

 class NamePrep:

 class NamePrep(object):

     """

     Implements preparation of internationalized domain names

         return default

 class SSLWrapper:

 class SSLWrapper(object):

     """

     Abstract SSLWrapper base class

     """

Yann Leboulanger pushed to branch master at gajim / python-nbxmpp

Commits:

13 changed files:

Changes: