GitLab

at 2020-01-23T19:39:58+01:00

Port from getAnID() to generate_id()

 import nbxmpp

 from nbxmpp.const import Realm

 from nbxmpp.const import Event

+from nbxmpp.util import generate_id

 

 from gajim import common

 from gajim.common import helpers

                           namespace=nbxmpp.NS_CORRECT)

 

         # XEP-0359

-        obj.stanza_id = self.connection.getAnID()

+        obj.stanza_id = generate_id()

         msg_iq.setID(obj.stanza_id)

         if obj.message:

             msg_iq.setOriginID(obj.stanza_id)

                                 typ='groupchat',

                                 xhtml=xhtml)

 

-        obj.stanza_id = self.connection.getAnID()

+        obj.stanza_id = generate_id()

         msg_iq.setID(obj.stanza_id)

         if obj.message:

             msg_iq.setOriginID(obj.stanza_id)

 from enum import Enum, unique

 

 import nbxmpp

+from nbxmpp.util import generate_id

 

 from gajim.common import app

 from gajim.common.jingle_transport import get_jingle_transport

         # what state is session in? (one from JingleStates)

         self.state = JingleStates.ENDED

         if not sid:

-            sid = con.connection.getAnID()

+            sid = generate_id()

         self.sid = sid # sessionid

         # iq stanza id, used to determine which sessions to summon callback

         # later on when iq-result stanza arrives

 from enum import IntEnum, unique

 

 import nbxmpp

+from nbxmpp.util import generate_id

 

 from gajim.common import app

 

     def set_connection(self, conn):

         self.connection = conn

         if not self.sid:

-            self.sid = self.connection.connection.getAnID()

+            self.sid = generate_id()

 

     def set_file_props(self, file_props):

         self.file_props = file_props

 

         candidate = {

             'host': self.connection.peerhost[0],

-            'candidate_id': self.connection.connection.getAnID(),

+            'candidate_id': generate_id(),

             'port': port,

             'type': 'direct',

             'jid': self.ourjid,

                 addr != '::1':

                     candidate = {

                         'host': addr,

-                        'candidate_id': self.connection.connection.getAnID(),

+                        'candidate_id': generate_id(),

                         'port': port,

                         'type': 'direct',

                         'jid': self.ourjid,

                             continue

                         candidate = {

                             'host': addr,

-                            'candidate_id': self.connection.connection.getAnID(),

+                            'candidate_id': generate_id(),

                             'port': port,

                             'type': 'direct',

                             'jid': self.ourjid,

                             continue

                         candidate = {

                             'host': addr,

-                            'candidate_id': self.connection.connection.getAnID(),

+                            'candidate_id': generate_id(),

                             'port': port,

                             'type': 'direct',

                             'jid': self.ourjid,

             for host in hosts:

                 candidate = {

                     'host': host,

-                    'candidate_id': self.connection.connection.getAnID(),

+                    'candidate_id': generate_id(),

                     'port': port,

                     'type': 'direct',

                     'jid': self.ourjid,

             for proxyhost in proxyhosts:

                 candidate = {

                     'host': proxyhost['host'],

-                    'candidate_id': self.connection.connection.getAnID(),

+                    'candidate_id': generate_id(),

                     'port': int(proxyhost['port']),

                     'type': 'proxy',

                     'jid': proxyhost['jid'],

 from OpenSSL import SSL, crypto

 

 import nbxmpp

+from nbxmpp.util import generate_id

 from gajim.common import app

 from gajim.common import configpaths

 

 

 def send_cert_request(con, to_jid):

     iq = nbxmpp.Iq('get', to=to_jid)

-    id_ = con.connection.getAnID()

+    id_ = generate_id()

     iq.setAttr('id', id_)

     pubkey = iq.setTag('pubkeys')

     pubkey.setNamespace(nbxmpp.NS_PUBKEY_PUBKEY)

 import nbxmpp

 from nbxmpp.structs import StanzaHandler

 from nbxmpp.modules import dataforms

+from nbxmpp.util import generate_id

 

 from gajim.common import app

 from gajim.common import helpers

                 raise nbxmpp.NodeProcessed

 

             # generate new sessionid

-            sessionid = self._con.connection.getAnID()

+            sessionid = generate_id()

 

             # create new instance and run it

             obj = newcmd(conn=self, jid=jid, sessionid=sessionid)

 from datetime import datetime, timedelta

 

 import nbxmpp

+from nbxmpp.util import generate_id

 from nbxmpp.structs import StanzaHandler

 

 from gajim.common import app

         return valid_id == properties.mam.query_id

 

     def _get_query_id(self, jid):

-        query_id = self._con.connection.getAnID()

+        query_id = generate_id()

         self._mam_query_ids[jid] = query_id

         return query_id

 

 from nbxmpp.transports import DATA_RECEIVED

 from nbxmpp.transports import DATA_SENT

 from nbxmpp.transports import DATA_ERROR

+from nbxmpp.util import generate_id

 

 from gajim.common import app

 from gajim.common.zeroconf import zeroconf

                 thread_id = stanza.getThread()

                 id_ = stanza.getID()

                 if not id_:

-                    id_ = self.Dispatcher.getAnID()

+                    id_ = generate_id()

                 if self.fd in self.conn_holder.ids_of_awaiting_messages:

                     self.conn_holder.ids_of_awaiting_messages[self.fd].append((

                         id_, thread_id))

             thread_id = stanza.getThread()

             id_ = stanza.getID()

             if not id_:

-                id_ = self.Dispatcher.getAnID()

+                id_ = generate_id()

             if self.fd in self.conn_holder.ids_of_awaiting_messages:

                 self.conn_holder.ids_of_awaiting_messages[self.fd].append((id_,

                     thread_id))

         P2PClient(None, addresses_, self,

             [(stanza, is_message)], to, on_ok=on_ok, on_not_ok=on_not_ok)

 

-    def getAnID(self):

-        """

-        Generate a random id

-        """

-        return ''.join(Random().sample(string.ascii_letters + string.digits, 6))

-

     def RegisterDisconnectHandler(self, handler):

         """

         Register handler that will be called on disconnect

Philipp Hörist pushed to branch master at gajim / gajim

Commits:

7 changed files:

Changes: