source: ralphm-patches/c2s_server_factory.patch

wokkel/client.py

@@ -22 +22 @@
 
 from wokkel import generic
 from wokkel.iwokkel import IUserSession
+from wokkel.subprotocols import ServerStreamManager
 from wokkel.subprotocols import StreamManager
+from wokkel.subprotocols import XMPPHandler
 
 NS_CLIENT = 'jabber:client'
 
@@ -480 +482 @@
             self.portal = self.portals[self.xmlstream.thisEntity]
         except KeyError:
             raise error.StreamError('host-unknown')
+
+
+
+class RecipientAddressStamper(XMPPHandler):
+    """
+    Protocol handler to ensure client stanzas have a sender address.
+    """
+
+    def connectionInitialized(self):
+        self.xmlstream.addObserver('/*', self.onStanza, priority=1)
+
+
+    def onStanza(self, element):
+        """
+        Make sure each stanza has a sender address.
+        """
+        if element.uri != self.xmlstream.namespace:
+            return
+
+        if (element.name == 'presence' and
+            element.getAttribute('type') in ('subscribe', 'subscribed',
+                                             'unsubscribe', 'unsubscribed')):
+            element['from'] = self.xmlstream.avatar.entity.userhost()
+        elif element.name in ('message', 'presence', 'iq'):
+            element['from'] = self.xmlstream.avatar.entity.full()
+
+
+
+class XMPPC2SServerFactory(xmlstream.XmlStreamServerFactory):
+    """
+    Server factory for XMPP client-server connections.
+    """
+
+    def __init__(self, portals):
+        def authenticatorFactory():
+            return XMPPClientListenAuthenticator(portals)
+
+        xmlstream.XmlStreamServerFactory.__init__(self, authenticatorFactory)
+        self.addBootstrap(xmlstream.STREAM_CONNECTED_EVENT,
+                          self.onConnectionMade)
+
+
+    def onConnectionMade(self, xs):
+        """
+        Called when a connection is made.
+
+        This creates a stream manager, calls L{setupHandlers} to attach
+        subprotocol handlers and then signals the stream manager that
+        the connection was made.
+        """
+        sm = ServerStreamManager()
+        sm.logTraffic = self.logTraffic
+
+        for handler in self.setupHandlers():
+            handler.setHandlerParent(sm)
+
+        sm.makeConnection(xs)
+
+
+    def setupHandlers(self):
+        """
+        Set up XMPP subprotocol handlers.
+        """
+        return [
+            generic.StanzaForwarder(),
+            RecipientAddressStamper(),
+            ]

wokkel/generic.py

@@ -480 +480 @@
     standard full stop.
     """
     return name.encode('idna')
+
+
+
+class StanzaForwarder(XMPPHandler):
+    """
+    XMPP protocol for passing incoming stanzas to the stream avatar.
+
+    This handler adds an observer for all XML Stanzas to forward to the C{send}
+    method on the cred avatar set on the XML Stream, unless it has been handled
+    by other observers.
+
+    Stream errors are logged.
+    """
+
+    def connectionMade(self):
+        """
+        Called when a connection is made.
+        """
+        self.xmlstream.addObserver(xmlstream.STREAM_ERROR_EVENT, self.onError)
+
+
+    def connectionInitialized(self):
+        """
+        Called when the stream has been initialized.
+        """
+        self.xmlstream.addObserver('/*', self.onStanza, priority=-1)
+
+
+
+    def onStanza(self, element):
+        """
+        Called when a stanza element was received.
+
+        If this is an XML stanza, and it has not been handled by another
+        subprotocol handler, the stanza is passed on to the avatar's C{send}
+        method.
+
+        If there is no recipient address on the stanza, a service-unavailable
+        is returned instead.
+        """
+        if element.handled:
+            return
+
+        if (element.name not in ('iq', 'message', 'presence') or
+            element.uri != self.xmlstream.namespace):
+            return
+
+        stanza = Stanza.fromElement(element)
+
+        if not stanza.recipient:
+            exc = error.StanzaError('service-unavailable')
+            self.send(exc.toResponse(stanza.element))
+        else:
+            self.xmlstream.avatar.send(stanza.element)
+
+
+    def onError(self, reason):
+        """
+        Log a stream error.
+        """
+        log.err(reason, "Stream error")

wokkel/test/test_client.py

@@ -7 +7 @@
 
 from base64 import b64encode
 
-from zope.interface import implements
+from zope.interface import implementer
 
 from twisted.cred.portal import IRealm, Portal
 from twisted.cred.checkers import InMemoryUsernamePasswordDatabaseDontUse
@@ -28 +28 @@
 
 from wokkel import client, iwokkel
 from wokkel.generic import TestableXmlStream, FeatureListenAuthenticator
+from wokkel.generic import parseXml
+from wokkel.test.helpers import XmlStreamStub
 
 class XMPPClientTest(unittest.TestCase):
     """
@@ -180 +182 @@
 
 
 
+@implementer(iwokkel.IUserSession)
 class TestSession(object):
-    implements(iwokkel.IUserSession)
 
     def __init__(self, domain, user):
         self.domain = domain
@@ -189 +191 @@
 
 
     def bindResource(self, resource):
-        return defer.succeed(JID(tuple=(self.user, self.domain, resource)))
+        self.entity = JID(tuple=(self.user, self.domain, resource))
+        return defer.succeed(self.entity)
 
 
 
+@implementer(IRealm)
 class TestRealm(object):
 
-    implements(IRealm)
-
     logoutCalled = False
 
     def __init__(self, domain):
@@ -679 +681 @@
                          "to='example.com' "
                          "version='1.0'>")
         self.xmlstream.assertStreamError(self, condition='host-unknown')
+
+
+
+class RecipientAddressStamperTest(unittest.TestCase):
+    """
+    Tests for L{client.RecipientAddressStamper}.
+    """
+
+
+    def setUp(self):
+        self.stub = XmlStreamStub()
+        self.stub.xmlstream.namespace = ''
+        avatar = TestSession(u'example.org', u'test')
+        avatar.bindResource(u'Home')
+        self.stub.xmlstream.avatar = avatar
+
+        self.protocol = client.RecipientAddressStamper()
+        self.protocol.makeConnection(self.stub.xmlstream)
+        self.protocol.connectionInitialized()
+
+
+    def test_presence(self):
+        """
+        The from address is set to the full JID on presence stanzas.
+        """
+        xml = """<presence/>"""
+        element = parseXml(xml)
+        self.stub.xmlstream.dispatch(element)
+        self.assertEqual(u'test@example.org/Home',
+                         element.getAttribute('from'))
+
+
+    def test_presenceSubscribe(self):
+        """
+        The from address is set to the bare JID on presence subscribe.
+        """
+        xml = """<presence type='subscribe'/>"""
+        element = parseXml(xml)
+        self.stub.xmlstream.dispatch(element)
+        self.assertEqual(u'test@example.org',
+                         element.getAttribute('from'))
+
+
+    def test_fromAlreadySet(self):
+        """
+        The from address is overridden if already present.
+        """
+        xml = """<presence from='test@example.org/Work'/>"""
+        element = parseXml(xml)
+        self.stub.xmlstream.dispatch(element)
+        self.assertEqual(u'test@example.org/Home',
+                         element.getAttribute('from'))
+
+
+    def test_notHandled(self):
+        """
+        The stanza will not have its 'handled' attribute set to True.
+        """
+        xml = """<presence/>"""
+        element = parseXml(xml)
+        self.stub.xmlstream.dispatch(element)
+        self.assertFalse(element.handled)
+
+
+    def test_message(self):
+        """
+        The from address is set to the full JID on message stanzas.
+        """
+        xml = """<message to='other@example.org'>
+                   <body>Hi!</body>
+                 </message>"""
+        element = parseXml(xml)
+        self.stub.xmlstream.dispatch(element)
+        self.assertEqual(u'test@example.org/Home',
+                         element.getAttribute('from'))
+
+
+    def test_iq(self):
+        """
+        The from address is set to the full JID on iq stanzas.
+        """
+        xml = """<iq type='get' id='g_1'>
+                   <query xmlns='jabber:iq:version'/>
+                 </iq>"""
+        element = parseXml(xml)
+        self.stub.xmlstream.dispatch(element)
+        self.assertEqual(u'test@example.org/Home',
+                         element.getAttribute('from'))

wokkel/test/test_generic.py

@@ -728 +728 @@
         name = u"example.com."
         result = generic.prepareIDNName(name)
         self.assertEqual(b"example.com.", result)
+
+
+
+class StanzaForwarderTest(unittest.TestCase):
+    """
+    Tests for L{generic.StanzaForwarder}.
+    """
+
+    def setUp(self):
+        class Avatar(object):
+            def __init__(self):
+                self.sent = []
+
+            def send(self, element):
+                self.sent.append(element)
+
+        self.stub = XmlStreamStub()
+        self.avatar = Avatar()
+        self.protocol = generic.StanzaForwarder()
+        self.protocol.makeConnection(self.stub.xmlstream)
+        self.protocol.xmlstream.avatar = self.avatar
+        self.protocol.xmlstream.namespace = u'jabber:client'
+        self.protocol.send = self.protocol.xmlstream.send
+
+
+    def test_onStanza(self):
+        """
+        An XML stanza is delivered at the stream avatar.
+        """
+        self.protocol.connectionInitialized()
+
+        element = domish.Element((u'jabber:client', u'message'))
+        element[u'to'] = u'other@example.org'
+        self.stub.send(element)
+
+        self.assertEqual(1, len(self.avatar.sent))
+        self.assertEqual(0, len(self.stub.output))
+
+
+    def test_onStanzaNoRecipient(self):
+        """
+        Stanzas without recipient are rejected.
+        """
+        self.protocol.connectionInitialized()
+
+        element = domish.Element((u'jabber:client', u'message'))
+        self.stub.send(element)
+
+        self.assertEqual(0, len(self.avatar.sent))
+        self.assertEqual(1, len(self.stub.output))
+
+
+    def test_onStanzaWrongNamespace(self):
+        """
+        If there is no xmlns on the stanza, it should still be delivered.
+        """
+        self.protocol.connectionInitialized()
+
+        element = domish.Element((u'testns', u'message'))
+        element[u'to'] = u'other@example.org'
+        self.stub.send(element)
+
+        self.assertEqual(0, len(self.avatar.sent))
+        self.assertEqual(0, len(self.stub.output))
+
+
+    def test_onStanzaAlreadyHandled(self):
+        """
+        If the stanza is marked as handled, ignore it.
+        """
+        self.protocol.connectionInitialized()
+
+        element = domish.Element((None, u'message'))
+        element[u'to'] = u'other@example.org'
+        element.handled = True
+        self.stub.send(element)
+
+        self.assertEqual(0, len(self.avatar.sent))
+        self.assertEqual(0, len(self.stub.output))
+
+
+    def test_onError(self):
+        """
+        A stream error is logged.
+        """
+        exc = error.StreamError('host-unknown')
+        self.stub.xmlstream.dispatch(exc, xmlstream.STREAM_ERROR_EVENT)
+        self.assertEqual(1, len(self.flushLoggedErrors(error.StreamError)))