Changeset 9648

Timestamp:

05/17/08 04:23:46 (3 months ago)

Author:

bct

Message:

fixed link-local messaging (broken by session-centric) and removed a ton of duplicated/unused code

Location:

trunk/src/common

Files:

• connection_handlers.py (modified) (31 diffs)
• zeroconf/connection_handlers_zeroconf.py (modified) (15 diffs)
• zeroconf/connection_zeroconf.py (modified) (4 diffs)

trunk/src/common/connection_handlers.py

@@ -83 +83 @@
                         return False
                 return True
-        
+
         def send_success_connect_reply(self, streamhost):
                 ''' send reply to the initiator of FT that we
@@ -98 +98 @@
                 stream_tag.setAttr('jid', streamhost['jid'])
                 self.connection.send(iq)
-        
+
         def remove_transfers_for_contact(self, contact):
                 ''' stop all active transfer for contact '''
@@ -113 +113 @@
                                 file_props['error'] = -3
                                 self.remove_transfer(file_props)
-        
+
         def remove_all_transfers(self):
                 ''' stops and removes all active connections from the socks5 pool '''
@@ -120 +120 @@
                 del(self.files_props)
                 self.files_props = {}
-        
+
         def remove_transfer(self, file_props, remove_from_list = True):
                 if file_props is None:
@@ -131 +131 @@
                         if self.files_props.has_key('sid'):
                                 del(self.files_props['sid'])
-        
+
         def disconnect_transfer(self, file_props):
                 if file_props is None:
@@ -143 +143 @@
                                         gajim.socks5queue.remove_receiver(host['idx'])
                                         gajim.socks5queue.remove_sender(host['idx'])
-        
+
         def send_socks5_info(self, file_props, fast = True, receiver = None,
                 sender = None):
@@ -166 +166 @@
                                         proxies.remove(default)
                                 proxies.insert(0, default)
-                        
+
                         for proxy in proxies:
                                 (host, _port, jid) = gajim.proxy65_manager.get_proxy(proxy, self.name)
@@ -314 +314 @@
                 field.addOption(common.xmpp.NS_BYTESTREAM)
                 self.connection.send(iq)
-        
+
         def _result_socks5_sid(self, sid, hash_id):
                 ''' store the result of sha message from auth. '''
@@ -322 +322 @@
                 file_props['hash'] = hash_id
                 return
-        
+
         def _connect_error(self, to, _id, sid, code = 404):
                 ''' cb, when there is an error establishing BS connection, or 
@@ -361 +361 @@
                 iq.setID(auth_id)
                 self.connection.send(iq)
-        
+
         # register xmpppy handlers for bytestream and FT stanzas
         def _bytestreamErrorCB(self, con, iq_obj):
@@ -377 +377 @@
                 self.dispatch('FILE_REQUEST_ERROR', (jid, file_props, ''))
                 raise common.xmpp.NodeProcessed
-        
+
         def _bytestreamSetCB(self, con, iq_obj):
                 gajim.log.debug('_bytestreamSetCB')
@@ -441 +441 @@
                                                 gajim.socks5queue.activate_proxy(host['idx'])
                                                 raise common.xmpp.NodeProcessed
-        
+
         def _bytestreamResultCB(self, con, iq_obj):
                 gajim.log.debug('_bytestreamResultCB')
@@ -448 +448 @@
                 query = iq_obj.getTag('query')
                 gajim.proxy65_manager.resolve_result(frm, query)
-                
+
                 try:
                         streamhost = query.getTag('streamhost-used')
@@ -513 +513 @@
                                         self._connect_error(frm, fasts[0]['id'], file_props['sid'],
                                                 code = 406)
-                
+
                 raise common.xmpp.NodeProcessed
-        
+
         def _siResultCB(self, con, iq_obj):
                 gajim.log.debug('_siResultCB')
@@ -552 +552 @@
                 self.send_socks5_info(file_props, fast = True)
                 raise common.xmpp.NodeProcessed
-        
+
         def _siSetCB(self, con, iq_obj):
                 gajim.log.debug('_siSetCB')
@@ -617 +617 @@
                         For feature: var is mandatory'''
                 self._discover(common.xmpp.NS_DISCO_INFO, jid, node, id_prefix)
-        
+
         def request_register_agent_info(self, agent):
                 if not self.connection:
@@ -643 +643 @@
                         # fixed: blocking
                         common.xmpp.features_nb.register(self.connection, agent, info, None)
-        
-        
+
+
         def _discover(self, ns, jid, node = None, id_prefix = None):
                 if not self.connection:
@@ -655 +655 @@
                         iq.setQuerynode(node)
                 self.connection.send(iq)
-        
+
         def _ReceivedRegInfo(self, con, resp, agent):
                 common.xmpp.features_nb._ReceivedRegInfo(con, resp, agent)
                 self._IqCB(con, resp)
-        
+
         def _discoGetCB(self, con, iq_obj):
                 ''' get disco info '''
@@ -676 +676 @@
                         feature.setAttr('var', f)
                         query.addChild(node=feature)
-                
+
                 self.connection.send(iq)
                 raise common.xmpp.NodeProcessed
-        
+
         def _DiscoverItemsErrorCB(self, con, iq_obj):
                 gajim.log.debug('DiscoverItemsErrorCB')
@@ -711 +711 @@
                         items.append(attr)
                 jid = helpers.get_full_jid_from_iq(iq_obj)
-                hostname = gajim.config.get_per('accounts', self.name, 
+                hostname = gajim.config.get_per('accounts', self.name,
                                                                                                         'hostname')
                 id = iq_obj.getID()
@@ -740 +740 @@
                 if self.commandInfoQuery(con, iq_obj):
                         raise common.xmpp.NodeProcessed
-                
+
                 else:
                         iq = iq_obj.buildReply('result')
@@ -852 +852 @@
                         return self.add_caps(p)
                 return p
-        
+
         def add_caps(self, p):
                 ''' advertise our capabilities in presence stanza (xep-0115)'''
@@ -860 +860 @@
                 c.setAttr('ver', gajim.caps_hash)
                 return p
-        
+
         def node_to_dict(self, node):
                 dict = {}
@@ -903 +903 @@
                 except IOError, e:
                         self.dispatch('ERROR', (_('Disk Write Error'), str(e)))
-        
+
         def get_cached_vcard(self, fjid, is_fake_jid = False):
                 '''return the vcard as a dict
@@ -931 +931 @@
                         if not isinstance(vcard['PHOTO'], dict):
                                 del vcard['PHOTO']
+                        elif vcard['PHOTO'].has_key('SHA'):
+                                cached_sha = vcard['PHOTO']['SHA']
+                                if self.vcard_shas.has_key(jid) and self.vcard_shas[jid] != \
+                                        cached_sha:
+                                        # user change his vcard so don't use the cached one
+                                        return {}
                 vcard['jid'] = jid
                 vcard['resource'] = gajim.get_resource_from_jid(fjid)
@@ -1196 +1202 @@
                         self.dispatch('VCARD', vcard)
 
-class ConnectionHandlers(ConnectionVcard, ConnectionBytestream, ConnectionDisco, ConnectionCommands, ConnectionPubSub, ConnectionCaps):
+# basic connection handlers used here and in zeroconf
+class ConnectionHandlersBase:
         def __init__(self):
-                ConnectionVcard.__init__(self)
-                ConnectionBytestream.__init__(self)
-                ConnectionCommands.__init__(self)
-                ConnectionPubSub.__init__(self)
-                self.gmail_url = None
                 # List of IDs we are waiting answers for {id: (type_of_request, data), }
                 self.awaiting_answers = {}
@@ -1211 +1213 @@
                 # SUBSCRIBED event to gui
                 self.automatically_added = []
+
+                # keep track of sessions this connection has with other JIDs
+                self.sessions = {}
+
+        def _FeatureNegCB(self, con, stanza, session):
+                gajim.log.debug('FeatureNegCB')
+                feature = stanza.getTag(name='feature', namespace=common.xmpp.NS_FEATURE)
+                form = common.xmpp.DataForm(node=feature.getTag('x'))
+
+                if form['FORM_TYPE'] == 'urn:xmpp:ssn':
+                        self.dispatch('SESSION_NEG', (stanza.getFrom(), session, form))
+                else:
+                        reply = stanza.buildReply()
+                        reply.setType('error')
+
+                        reply.addChild(feature)
+                        reply.addChild(node=common.xmpp.ErrorNode('service-unavailable', typ='cancel'))
+
+                        con.send(reply)
+
+                raise common.xmpp.NodeProcessed
+
+        def _InitE2ECB(self, con, stanza, session):
+                gajim.log.debug('InitE2ECB')
+                init = stanza.getTag(name='init', namespace=common.xmpp.NS_ESESSION_INIT)
+                form = common.xmpp.DataForm(node=init.getTag('x'))
+
+                self.dispatch('SESSION_NEG', (stanza.getFrom(), session, form))
+
+                raise common.xmpp.NodeProcessed
+
+        def get_or_create_session(self, jid, thread_id):
+                '''returns an existing session between this connection and 'jid', returns a new one if none exist.'''
+
+                pm = True
+                if not gajim.interface.is_pm_contact(jid, self.name):
+                        pm = False
+                        jid = gajim.get_jid_without_resource(jid)
+
+                session = self.find_session(jid, thread_id)
+
+                if session:
+                        return session
+
+                if pm:
+                        return self.make_new_session(jid, thread_id, type = 'pm')
+                else:
+                        return self.make_new_session(jid, thread_id)
+
+        def find_session(self, jid, thread_id):
+                try:
+                        if not thread_id:
+                                return self.find_null_session(jid)
+                        else:
+                                return self.sessions[jid][thread_id]
+                except KeyError:
+                        return None
+
+        def terminate_sessions(self):
+                '''send termination messages and delete all active sessions'''
+                for jid in self.sessions:
+                        for thread_id in self.sessions[jid]:
+                                self.sessions[jid][thread_id].terminate()
+
+                self.sessions = {}
+
+        def delete_session(self, jid, thread_id):
+                try:
+                        del self.sessions[jid][thread_id]
+
+                        if not self.sessions[jid]:
+                                del self.sessions[jid]
+                except KeyError:
+                        pass
+
+        def find_null_session(self, jid):
+                '''finds all of the sessions between us and a remote jid in which we
+haven't received a thread_id yet and returns the session that we last
+sent a message to.'''
+
+                sessions = self.sessions[jid].values()
+
+                # sessions that we haven't received a thread ID in
+                idless = filter(lambda s: not s.received_thread_id, sessions)
+
+                # filter out everything exceptthe default session type
+                chat_sessions = filter(lambda s: isinstance(s, ChatControlSession), idless)
+
+                if chat_sessions:
+                        # return the session that we last sent a message in
+                        chat_sessions.sort(key=lambda s: s.last_send)
+                        return chat_sessions[-1]
+                else:
+                        return None
+
+        def make_new_session(self, jid, thread_id=None, type='chat', klass=None):
+                if not klass:
+                        klass = ChatControlSession
+
+                # determine if this session is a pm session
+                # if not, discard the resource
+                if not type == 'pm':
+                        jid = gajim.get_jid_without_resource(jid)
+
+                sess = klass(self, common.xmpp.JID(jid), thread_id, type)
+
+                if not jid in self.sessions:
+                        self.sessions[jid] = {}
+
+                self.sessions[jid][sess.thread_id] = sess
+
+                return sess
+
+class ConnectionHandlers(ConnectionVcard, ConnectionBytestream, ConnectionDisco, ConnectionCommands, ConnectionPubSub, ConnectionCaps, ConnectionHandlersBase):
+        def __init__(self):
+                ConnectionVcard.__init__(self)
+                ConnectionBytestream.__init__(self)
+                ConnectionCommands.__init__(self)
+                ConnectionPubSub.__init__(self)
+                ConnectionHandlersBase.__init__(self)
+                self.gmail_url = None
+
                 # keep the latest subscribed event for each jid to prevent loop when we
-                # acknoledge presences
+                # acknowledge presences
                 self.subscribed_events = {}
                 # IDs of jabber:iq:last requests
@@ -1221 +1345 @@
                 self.awaiting_xmpp_ping_id = None
 
-                # keep track of sessions this connection has with other JIDs
-                self.sessions = {}
                 try:
                         idle.init()
@@ -1235 +1357 @@
                                 common.xmpp.protocol.ERR_NOT_AUTHORIZED)
                         self.connection.send(err)
-        
+
         def _HttpAuthCB(self, con, iq_obj):
                 gajim.log.debug('HttpAuthCB')
@@ -1247 +1369 @@
                         msg = iq_obj.getTagData('body') # In case it's a message with a body
                         self.dispatch('HTTP_AUTH', (method, url, id, iq_obj, msg));
-                raise common.xmpp.NodeProcessed
-
-        def _FeatureNegCB(self, con, stanza, session):
-                gajim.log.debug('FeatureNegCB')
-                feature = stanza.getTag(name='feature', namespace=common.xmpp.NS_FEATURE)
-                form = common.xmpp.DataForm(node=feature.getTag('x'))
-
-                if form['FORM_TYPE'] == 'urn:xmpp:ssn':
-                        self.dispatch('SESSION_NEG', (stanza.getFrom(), session, form))
-                else:
-                        reply = stanza.buildReply()
-                        reply.setType('error')
-
-                        reply.addChild(feature)
-                        reply.addChild(node=common.xmpp.ErrorNode('service-unavailable', typ='cancel'))
-
-                        con.send(reply)
-
-                raise common.xmpp.NodeProcessed
-
-        def _InitE2ECB(self, con, stanza, session):
-                gajim.log.debug('InitE2ECB')
-                init = stanza.getTag(name='init', namespace=common.xmpp.NS_ESESSION_INIT)
-                form = common.xmpp.DataForm(node=init.getTag('x'))
-
-                self.dispatch('SESSION_NEG', (stanza.getFrom(), session, form))
-
                 raise common.xmpp.NodeProcessed
 
@@ -1727 +1822 @@
                 self.dispatch('GC_INVITATION',(frm, jid_from, reason, password,
                         is_continued))
-
-        def get_or_create_session(self, jid, thread_id):
-                '''returns an existing session between this connection and 'jid', returns a new one if none exist.'''
-
-                pm = True
-                if not gajim.interface.is_pm_contact(jid, self.name):
-                        pm = False
-                        jid = gajim.get_jid_without_resource(jid)
-
-                session = self.find_session(jid, thread_id)
-
-                if session:
-                        return session
-
-                if pm:
-                        return self.make_new_session(jid, thread_id, type = 'pm')
-                else:
-                        return self.make_new_session(jid, thread_id)
-
-        def find_session(self, jid, thread_id):
-                try:
-                        if not thread_id:
-                                return self.find_null_session(jid)
-                        else:
-                                return self.sessions[jid][thread_id]
-                except KeyError:
-                        return None
-
-        def terminate_sessions(self):
-                '''send termination messages and delete all active sessions'''
-                for jid in self.sessions:
-                        for thread_id in self.sessions[jid]:
-                                self.sessions[jid][thread_id].terminate()
-
-                self.sessions = {}
-
-        def delete_session(self, jid, thread_id):
-                try:
-                        del self.sessions[jid][thread_id]
-
-                        if not self.sessions[jid]:
-                                del self.sessions[jid]
-                except KeyError:
-                        pass
-
-        def find_null_session(self, jid):
-                '''finds all of the sessions between us and a remote jid in which we
-haven't received a thread_id yet and returns the session that we last
-sent a message to.'''
-
-                sessions = self.sessions[jid].values()
-
-                # sessions that we haven't received a thread ID in
-                idless = filter(lambda s: not s.received_thread_id, sessions)
-
-                # filter out everything exceptthe default session type
-                chat_sessions = filter(lambda s: isinstance(s, ChatControlSession), idless)
-
-                if chat_sessions:
-                        # return the session that we last sent a message in
-                        chat_sessions.sort(key=lambda s: s.last_send)
-                        return chat_sessions[-1]
-                else:
-                        return None
-
-        def make_new_session(self, jid, thread_id=None, type='chat', klass=None):
-                if not klass:
-                        klass = ChatControlSession
-
-                # determine if this session is a pm session
-                # if not, discard the resource
-                if not type == 'pm':
-                        jid = gajim.get_jid_without_resource(jid)
-
-                sess = klass(self, common.xmpp.JID(jid), thread_id, type)
-
-                if not jid in self.sessions:
-                        self.sessions[jid] = {}
-
-                self.sessions[jid][sess.thread_id] = sess
-
-                return sess
 
         def _pubsubEventCB(self, con, msg):

trunk/src/common/zeroconf/connection_handlers_zeroconf.py

@@ -36 +36 @@
 from common import gajim
 from common.zeroconf import zeroconf
+
 STATUS_LIST = ['offline', 'connecting', 'online', 'chat', 'away', 'xa', 'dnd',
         'invisible']
@@ -49 +50 @@
         HAS_IDLE = False
 
-from common.stanza_session import EncryptedStanzaSession 
-
-class ConnectionVcard:
-        def __init__(self): 
-                self.vcard_sha = None 
-                self.vcard_shas = {} # sha of contacts 
-                self.room_jids = [] # list of gc jids so that vcard are saved in a folder
-
-        def add_sha(self, p, send_caps = True): 
-                pass 
-        
+from common import connection_handlers
+from session import ChatControlSession
+
+class ConnectionVcard(connection_handlers.ConnectionVcard):
+        def add_sha(self, p, send_caps = True):
+                pass
+
         def add_caps(self, p):
                 pass
 
-        def node_to_dict(self, node):
-                dict = {}
-                
-                for info in node.getChildren():
-                        name = info.getName()
-                        if name in ('ADR', 'TEL', 'EMAIL'): # we can have several
-                                if not dict.has_key(name):
-                                        dict[name] = []
-                                entry = {}
-                                for c in info.getChildren():
-                                         entry[c.getName()] = c.getData()
-                                dict[name].append(entry)
-                        elif info.getChildren() == []:
-                                dict[name] = info.getData()
-                        else:
-                                dict[name] = {}
-                                for c in info.getChildren():
-                                         dict[name][c.getName()] = c.getData()
-                
-                return dict
-
-        def save_vcard_to_hd(self, full_jid, card):
-                jid, nick = gajim.get_room_and_nick_from_fjid(full_jid)
-                puny_jid = helpers.sanitize_filename(jid)
-                path = os.path.join(gajim.VCARD_PATH, puny_jid)
-                if jid in self.room_jids or os.path.isdir(path):
-                        # remove room_jid file if needed
-                        if os.path.isfile(path):
-                                os.remove(path)
-                        # create folder if needed
-                        if not os.path.isdir(path):
-                                os.mkdir(path, 0700)
-                        puny_nick = helpers.sanitize_filename(nick)
-                        path_to_file = os.path.join(gajim.VCARD_PATH, puny_jid, puny_nick)
-                else:
-                        path_to_file = path
-                fil = open(path_to_file, 'w')
-                fil.write(str(card))
-                fil.close()
-        
-        def get_cached_vcard(self, fjid, is_fake_jid = False):
-                '''return the vcard as a dict
-                return {} if vcard was too old
-                return None if we don't have cached vcard'''
-                jid, nick = gajim.get_room_and_nick_from_fjid(fjid)
-                puny_jid = helpers.sanitize_filename(jid)
-                if is_fake_jid:
-                        puny_nick = helpers.sanitize_filename(nick)
-                        path_to_file = os.path.join(gajim.VCARD_PATH, puny_jid, puny_nick)
-                else:
-                        path_to_file = os.path.join(gajim.VCARD_PATH, puny_jid)
-                if not os.path.isfile(path_to_file):
-                        return None
-                # We have the vcard cached
-                f = open(path_to_file)
-                c = f.read()
-                f.close()
-                card = common.xmpp.Node(node = c)
-                vcard = self.node_to_dict(card)
-                if vcard.has_key('PHOTO'):
-                        if not isinstance(vcard['PHOTO'], dict):
-                                del vcard['PHOTO']
-                        elif vcard['PHOTO'].has_key('SHA'):
-                                cached_sha = vcard['PHOTO']['SHA']
-                                if self.vcard_shas.has_key(jid) and self.vcard_shas[jid] != \
-                                        cached_sha:
-                                        # user change his vcard so don't use the cached one
-                                        return {}
-                vcard['jid'] = jid