GitLab

at 2016-11-02T15:16:50+01:00

[NooN8] simplify arithmetic. See #38

[NooN8] make the really dense code more readable

             self.realm = chal['realm']

         if 'qop' in chal and ((chal['qop'] =='auth') or \

         (isinstance(chal['qop'], list) and 'auth' in chal['qop'])):

             self.resp = {}

             self.resp['username'] = self.username

             self.resp = {'username': self.username,

                 'nonce': chal['nonce'],

                 'cnonce': '%x' % rndg.getrandbits(196),

                 'nc': ('00000001'),  # ToDo: Is this a tupel or only a string?

                 'qop': 'auth',

                 'digest-uri': 'xmpp/' + self._owner.Server,

                 'charset': 'utf-8'

             }

             if self.realm:

                 self.resp['realm'] = self.realm

             else:

                 self.resp['realm'] = self._owner.Server

             self.resp['nonce'] = chal['nonce']

             self.resp['cnonce'] = '%x' % rndg.getrandbits(196)

             self.resp['nc'] = ('00000001')

             self.resp['qop'] = 'auth'

             self.resp['digest-uri'] = 'xmpp/' + self._owner.Server

             self.resp['charset'] = 'utf-8'

             # Password is now required

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

         elif 'rspauth' in chal:

         NonBlockingTransport.connect(self, conn_5tuple, on_connect, on_connect_failure)

         global FAKE_DESCRIPTOR

         FAKE_DESCRIPTOR = FAKE_DESCRIPTOR - 1

         FAKE_DESCRIPTOR -= 1

         self.fd = FAKE_DESCRIPTOR

         self.stanza_buffer = []

     s = "<" + node.name

     if node.namespace:

         if not node.parent or node.parent.namespace != node.namespace:

             s = s + ' xmlns="%s"' % node.namespace

             s += ' xmlns="%s"' % node.namespace

     sorted_attrs = sorted(node.attrs.keys())

     for key in sorted_attrs:

             continue

         val = ustr(node.attrs[key])

         # like XMLescape() but with whitespace and without &gt;

         s = s + ' %s="%s"' % ( key, normalise_attr(val) )

     s = s + ">"

         s += ' %s="%s"' % (key, normalise_attr(val))

     s += ">"

     cnt = 0

     if node.kids:

         for a in node.kids:

             if (len(node.data)-1) >= cnt:

                 s = s + normalise_text(node.data[cnt])

             s = s + c14n(a, is_buggy)

             cnt=cnt+1

             cnt += 1

     if (len(node.data)-1) >= cnt: s = s + normalise_text(node.data[cnt])

     if not node.kids and s.endswith('>'):

         s=s[:-1]+' />'

         """

         if err_message:

             log.debug('While looping over DNS A records: %s' % err_message)

         if self.ip_addresses == []:

         if not self.ip_addresses:

             msg = 'Run out of hosts for name %s:%s.' % (self.Server, self.Port)

             msg = msg + ' Error for last IP: %s' % err_message

             msg += ' Error for last IP: %s' % err_message

             self.disconnect(msg)

         else:

             self.current_ip = self.ip_addresses.pop(0)

         # \ufddo -> \ufdef range

         c = '\ufdd0'

         r = c

         while (c < '\ufdef'):

         while c < '\ufdef':

             c = chr(ord(c) + 1)

             r += '|' + c

         c = '\ufffe'

         r += '|' + c

         r += '|' + chr(ord(c) + 1)

         while (c < '\U0010fffe'):

         while c < '\U0010fffe':

             c = chr(ord(c) + 0x10000)

             r += '|' + c

             r += '|' + chr(ord(c) + 1)

         stanza.getName() != 'a' and stanza.getName() != 'enabled' and

         stanza.getName() != 'resumed'):

             # increments the number of stanzas that has been handled

             self.sm.in_h = self.sm.in_h + 1

             self.sm.in_h += 1

         list_ = ['default'] # we will use all handlers:

         if typ in self.handlers[xmlns][name]:

             list_.append(typ) # from very common...

         # If no ID then it is a whitespace

         if self.sm and self.sm.enabled and ID:

             self.sm.uqueue.append(stanza)

             self.sm.out_h = self.sm.out_h + 1

             self.sm.out_h += 1

             if len(self.sm.uqueue) > self.sm.max_queue:

                 self.sm.request_ack()

 #                               # Resolve locally

 #                               self.ipaddr = socket.inet_aton(socket.gethostbyname(self.xmpp_server[0]))

 #                               req = req + "\x01" + ipaddr

         req = req + struct.pack(">H", self.xmpp_server[1])

         req += struct.pack(">H", self.xmpp_server[1])

         self.onreceive(self._on_req_sent)

         self.send(req)

         self.enabled = True

         self.resuming = True

         self.con.set_oldst()

         if self.old_uqueue != []:

         if self.old_uqueue:

             log.info('Session resumed, replaying %s stanzas...' % len(self.old_uqueue))

             for i in self.old_uqueue:

                 self._owner.Connection.send(i, False)

                 if self.exc_str:

                     if self.strerror:

                         s += "(%s)" % self.exc_str

                     else: s += "(%s)" % str(self.exc_args)

                     else:

                         s += "(%s)" % str(self.exc_args)

             return s

     def __init__(self, sslobj, sock=None):

                 except UnicodeDecodeError:

                     for i in range(-1, -4, -1):

                         char = sent_data[i]

                         if char & 0xc0 == 0xc0:

                         if ord(char) & 0xc0 == 0xc0:

                             self.sent_bytes_buff = sent_data[i:]

                             sent_data = sent_data[:i]

                             break

             headers.append('Connection: Keep-Alive')

         headers.append('\r\n')

         headers = '\r\n'.join(headers)

         return('%s%s' % (headers, httpbody))

         return '%s%s' % (headers, httpbody)

     def parse_http_message(self, message):

         """

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

Commits:

9 changed files:

Changes: