Page MenuHomePhabricator
Files F7159228

No OneTemporary
Actions

View Options

diff --git a/sylk/applications/xmppgateway/configuration.py b/sylk/applications/xmppgateway/configuration.py
index 8afe6ee..c8eda62 100644
--- a/sylk/applications/xmppgateway/configuration.py
+++ b/sylk/applications/xmppgateway/configuration.py
@@ -1,22 +1,25 @@
from application.system import host
from application.configuration import ConfigSection, ConfigSetting
from application.configuration.datatypes import StringList
from sipsimple.configuration.datatypes import NonNegativeInteger
from sylk.configuration.datatypes import IPAddress, Port
class XMPPGatewayConfig(ConfigSection):
__cfgfile__ = 'xmppgateway.ini'
__section__ = 'general'
local_ip = ConfigSetting(type=IPAddress, value=IPAddress(host.default_ip))
local_port = ConfigSetting(type=Port, value=5269)
trace_xmpp = False
log_presence = False
+ transport = ConfigSetting(type=str, value='tls')
+ ca_file = ConfigSetting(type=str, value='/etc/sylkserver/tls/ca.crt')
+ certificate = ConfigSetting(type=str, value='/etc/sylkserver/tls/default.crt')
domains = ConfigSetting(type=StringList, value=[])
muc_prefix = 'conference'
sip_session_timeout = ConfigSetting(type=NonNegativeInteger, value=86400)
use_msrp_for_chat = True
diff --git a/sylk/applications/xmppgateway/xmpp/__init__.py b/sylk/applications/xmppgateway/xmpp/__init__.py
index 0936249..9d3f7c4 100644
--- a/sylk/applications/xmppgateway/xmpp/__init__.py
+++ b/sylk/applications/xmppgateway/xmpp/__init__.py
@@ -1,330 +1,361 @@
+import os
+
from application.notification import IObserver, NotificationCenter, NotificationData
from application.python import Null
from application.python.types import Singleton
-from twisted.internet import reactor
+from twisted.internet import reactor, ssl
from wokkel.disco import DiscoClientProtocol
from wokkel.generic import FallbackHandler, VersionHandler
from wokkel.ping import PingHandler
from wokkel.server import ServerService, XMPPS2SServerFactory
from zope.interface import implements
+from sylk.configuration.datatypes import Path
from sylk import __version__ as SYLK_VERSION
from sylk.applications.xmppgateway.configuration import XMPPGatewayConfig
from sylk.applications.xmppgateway.datatypes import FrozenURI
from sylk.applications.xmppgateway.logger import log
from sylk.applications.xmppgateway.xmpp.jingle.session import JingleSession, JingleSessionManager
from sylk.applications.xmppgateway.xmpp.protocols import DiscoProtocol, JingleProtocol, MessageProtocol, MUCServerProtocol, MUCPresenceProtocol, PresenceProtocol
from sylk.applications.xmppgateway.xmpp.server import SylkInternalComponent, SylkRouter
from sylk.applications.xmppgateway.xmpp.session import XMPPChatSessionManager, XMPPMucSessionManager
from sylk.applications.xmppgateway.xmpp.subscription import XMPPSubscriptionManager
-
class XMPPManager(object):
__metaclass__ = Singleton
implements(IObserver)
def __init__(self):
config = XMPPGatewayConfig
self.stopped = False
self.domains = set(config.domains)
self.muc_domains = set('%s.%s' % (config.muc_prefix, domain) for domain in self.domains)
router = SylkRouter()
self._server_service = ServerService(router)
self._server_service.domains = self.domains | self.muc_domains
self._server_service.logTraffic = False # done manually
self._s2s_factory = XMPPS2SServerFactory(self._server_service)
self._s2s_factory.logTraffic = False # done manually
# Setup internal components
self._internal_component = SylkInternalComponent(router)
self._internal_component.domains = self.domains
self._internal_component.manager = self
self._muc_component = SylkInternalComponent(router)
self._muc_component.domains = self.muc_domains
self._muc_component.manager = self
# Setup protocols
self.message_protocol = MessageProtocol()
self.message_protocol.setHandlerParent(self._internal_component)
self.presence_protocol = PresenceProtocol()
self.presence_protocol.setHandlerParent(self._internal_component)
self.disco_protocol = DiscoProtocol()
self.disco_protocol.setHandlerParent(self._internal_component)
self.disco_client_protocol = DiscoClientProtocol()
self.disco_client_protocol.setHandlerParent(self._internal_component)
self.muc_protocol = MUCServerProtocol()
self.muc_protocol.setHandlerParent(self._muc_component)
self.muc_presence_protocol = MUCPresenceProtocol()
self.muc_presence_protocol.setHandlerParent(self._muc_component)
self.disco_muc_protocol = DiscoProtocol()
self.disco_muc_protocol.setHandlerParent(self._muc_component)
self.version_protocol = VersionHandler('SylkServer', SYLK_VERSION)
self.version_protocol.setHandlerParent(self._internal_component)
self.fallback_protocol = FallbackHandler()
self.fallback_protocol.setHandlerParent(self._internal_component)
self.fallback_muc_protocol = FallbackHandler()
self.fallback_muc_protocol.setHandlerParent(self._muc_component)
self.ping_protocol = PingHandler()
self.ping_protocol.setHandlerParent(self._internal_component)
self.jingle_protocol = JingleProtocol()
self.jingle_protocol.setHandlerParent(self._internal_component)
self.jingle_coin_protocol = JingleProtocol()
self.jingle_coin_protocol.setHandlerParent(self._muc_component)
self._s2s_listener = None
self.chat_session_manager = XMPPChatSessionManager()
self.muc_session_manager = XMPPMucSessionManager()
self.subscription_manager = XMPPSubscriptionManager()
self.jingle_session_manager = JingleSessionManager()
def start(self):
self.stopped = False
# noinspection PyUnresolvedReferences
- self._s2s_listener = reactor.listenTCP(XMPPGatewayConfig.local_port, self._s2s_factory, interface=XMPPGatewayConfig.local_ip)
+ interface = XMPPGatewayConfig.local_ip
+ port = XMPPGatewayConfig.local_port
+ cert_path = Path(XMPPGatewayConfig.certificate).normalized if XMPPGatewayConfig.certificate else None
+ cert_chain_path = Path(XMPPGatewayConfig.ca_file).normalized if XMPPGatewayConfig.ca_file else None
+
+ if XMPPGatewayConfig.transport == 'tls':
+ if cert_path is not None:
+ if not os.path.isfile(cert_path):
+ log.error('Certificate file %s could not be found' % cert_path)
+ return
+ try:
+ ssl_ctx_factory = ssl.DefaultOpenSSLContextFactory(cert_path, cert_path)
+ except Exception:
+ log.exception('Creating TLS context')
+ return
+ if cert_chain_path is not None:
+ if not os.path.isfile(cert_chain_path):
+ log.error('Certificate chain file %s could not be found' % cert_chain_path)
+ return
+ ssl_ctx = ssl_ctx_factory.getContext()
+ try:
+ ssl_ctx.use_certificate_chain_file(cert_chain_path)
+ except Exception:
+ log.exception('Setting TLS certificate chain file')
+ return
+ self._s2s_listener = reactor.listenSSL(port, self._s2s_factory, ssl_ctx_factory, interface=interface)
+ else:
+ self._s2s_listener = reactor.listenTCP(port, self._s2s_factory, interface=interface)
+
+ port = self._s2s_listener.getHost().port
listen_address = self._s2s_listener.getHost()
- log.info("XMPP listener started on %s:%d" % (listen_address.host, listen_address.port))
+ log.info("XMPP S2S component listening on %s:%d (%s)" % (listen_address.host, listen_address.port, XMPPGatewayConfig.transport.upper()))
self.chat_session_manager.start()
self.muc_session_manager.start()
self.subscription_manager.start()
self.jingle_session_manager.start()
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=self._internal_component)
notification_center.add_observer(self, sender=self._muc_component)
self._internal_component.startService()
self._muc_component.startService()
def stop(self):
self.stopped = True
self._s2s_listener.stopListening()
self.jingle_session_manager.stop()
self.subscription_manager.stop()
self.muc_session_manager.stop()
self.chat_session_manager.stop()
self._internal_component.stopService()
self._muc_component.stopService()
notification_center = NotificationCenter()
notification_center.remove_observer(self, sender=self._internal_component)
notification_center.remove_observer(self, sender=self._muc_component)
def send_stanza(self, stanza):
if self.stopped:
return
self._internal_component.send(stanza.to_xml_element())
def send_muc_stanza(self, stanza):
if self.stopped:
return
self._muc_component.send(stanza.to_xml_element())
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
# Process message stanzas
def _NH_XMPPGotChatMessage(self, notification):
message = notification.data.message
try:
session = self.chat_session_manager.sessions[(message.recipient.uri, message.sender.uri)]
except KeyError:
notification.center.post_notification('XMPPGotChatMessage', sender=self, data=notification.data)
else:
session.channel.send(message)
def _NH_XMPPGotNormalMessage(self, notification):
notification.center.post_notification('XMPPGotNormalMessage', sender=self, data=notification.data)
def _NH_XMPPGotComposingIndication(self, notification):
composing_indication = notification.data.composing_indication
try:
session = self.chat_session_manager.sessions[(composing_indication.recipient.uri, composing_indication.sender.uri)]
except KeyError:
notification.center.post_notification('XMPPGotComposingIndication', sender=self, data=notification.data)
else:
session.channel.send(composing_indication)
def _NH_XMPPGotErrorMessage(self, notification):
error_message = notification.data.error_message
try:
session = self.chat_session_manager.sessions[(error_message.recipient.uri, error_message.sender.uri)]
except KeyError:
notification.center.post_notification('XMPPGotErrorMessage', sender=self, data=notification.data)
else:
session.channel.send(error_message)
def _NH_XMPPGotReceipt(self, notification):
receipt = notification.data.receipt
try:
session = self.chat_session_manager.sessions[(receipt.recipient.uri, receipt.sender.uri)]
except KeyError:
pass
else:
session.channel.send(receipt)
# Process presence stanzas
def _NH_XMPPGotPresenceAvailability(self, notification):
stanza = notification.data.presence_stanza
if stanza.recipient.uri.resource is not None:
# Skip directed presence
return
sender_uri = stanza.sender.uri
sender_uri_bare = FrozenURI(sender_uri.user, sender_uri.host)
try:
subscription = self.subscription_manager.outgoing_subscriptions[(stanza.recipient.uri, sender_uri_bare)]
except KeyError:
# Ignore incoming presence stanzas if there is no subscription
pass
else:
subscription.channel.send(stanza)
def _NH_XMPPGotPresenceSubscriptionStatus(self, notification):
stanza = notification.data.presence_stanza
if stanza.sender.uri.resource is not None or stanza.recipient.uri.resource is not None:
# Skip directed presence
return
if stanza.type in ('subscribed', 'unsubscribed'):
try:
subscription = self.subscription_manager.outgoing_subscriptions[(stanza.recipient.uri, stanza.sender.uri)]
except KeyError:
pass
else:
subscription.channel.send(stanza)
elif stanza.type in ('subscribe', 'unsubscribe'):
try:
subscription = self.subscription_manager.incoming_subscriptions[(stanza.recipient.uri, stanza.sender.uri)]
except KeyError:
if stanza.type == 'subscribe':
notification.center.post_notification('XMPPGotPresenceSubscriptionRequest', sender=self, data=NotificationData(stanza=stanza))
else:
subscription.channel.send(stanza)
def _NH_XMPPGotPresenceProbe(self, notification):
stanza = notification.data.presence_stanza
if stanza.recipient.uri.resource is not None:
# Skip directed presence
return
sender_uri = stanza.sender.uri
sender_uri_bare = FrozenURI(sender_uri.user, sender_uri.host)
try:
subscription = self.subscription_manager.incoming_subscriptions[(stanza.recipient.uri, sender_uri_bare)]
except KeyError:
notification.center.post_notification('XMPPGotPresenceSubscriptionRequest', sender=self, data=NotificationData(stanza=stanza))
else:
subscription.channel.send(stanza)
# Process muc stanzas
def _NH_XMPPMucGotGroupChat(self, notification):
message = notification.data.message
muc_uri = FrozenURI(message.recipient.uri.user, message.recipient.uri.host)
try:
session = self.muc_session_manager.incoming[(muc_uri, message.sender.uri)]
except KeyError:
# Ignore groupchat messages if there was no session created
pass
else:
session.channel.send(message)
def _NH_XMPPMucGotSubject(self, notification):
message = notification.data.message
muc_uri = FrozenURI(message.recipient.uri.user, message.recipient.uri.host)
try:
session = self.muc_session_manager.incoming[(muc_uri, message.sender.uri)]
except KeyError:
# Ignore groupchat messages if there was no session created
pass
else:
session.channel.send(message)
def _NH_XMPPMucGotPresenceAvailability(self, notification):
stanza = notification.data.presence_stanza
if not stanza.sender.uri.resource:
return
muc_uri = FrozenURI(stanza.recipient.uri.user, stanza.recipient.uri.host)
try:
session = self.muc_session_manager.incoming[(muc_uri, stanza.sender.uri)]
except KeyError:
if stanza.available:
notification.center.post_notification('XMPPGotMucJoinRequest', sender=self, data=NotificationData(stanza=stanza))
else:
notification.center.post_notification('XMPPGotMucLeaveRequest', sender=self, data=NotificationData(stanza=stanza))
else:
session.channel.send(stanza)
def _NH_XMPPMucGotInvitation(self, notification):
invitation = notification.data.invitation
data = NotificationData(sender=invitation.sender, recipient=invitation.recipient, participant=invitation.invited_user)
notification.center.post_notification('XMPPGotMucAddParticipantRequest', sender=self, data=data)
# Jingle
def _NH_XMPPGotJingleSessionInitiate(self, notification):
stanza = notification.data.stanza
try:
self.jingle_session_manager.sessions[stanza.jingle.sid]
except KeyError:
session = JingleSession(notification.data.protocol)
session.init_incoming(stanza)
session.send_ring_indication()
def _NH_XMPPGotJingleSessionTerminate(self, notification):
stanza = notification.data.stanza
try:
session = self.jingle_session_manager.sessions[stanza.jingle.sid]
except KeyError:
return
session.handle_notification(notification)
def _NH_XMPPGotJingleSessionInfo(self, notification):
stanza = notification.data.stanza
try:
session = self.jingle_session_manager.sessions[stanza.jingle.sid]
except KeyError:
return
session.handle_notification(notification)
def _NH_XMPPGotJingleSessionAccept(self, notification):
stanza = notification.data.stanza
try:
session = self.jingle_session_manager.sessions[stanza.jingle.sid]
except KeyError:
return
session.handle_notification(notification)
def _NH_XMPPGotJingleDescriptionInfo(self, notification):
stanza = notification.data.stanza
try:
session = self.jingle_session_manager.sessions[stanza.jingle.sid]
except KeyError:
return
session.handle_notification(notification)
def _NH_XMPPGotJingleTransportInfo(self, notification):
stanza = notification.data.stanza
try:
session = self.jingle_session_manager.sessions[stanza.jingle.sid]
except KeyError:
return
session.handle_notification(notification)
diff --git a/xmppgateway.ini.sample b/xmppgateway.ini.sample
index 83a4c55..01cbd9c 100644
--- a/xmppgateway.ini.sample
+++ b/xmppgateway.ini.sample
@@ -1,39 +1,45 @@
; SylkServer XMPP gateway application configuration file
[general]
; Comma-separated list of Internet domains for which this server is
; responsible. Beside this setting, you must also add the xmpp-server records
; into the DNS server responsable for these Internet domains, e.g.:
; _xmpp-server._tcp.example.com. IN SRV 0 0 5269 sylkserver.example.com.
; At least one domain is required, replace the example below with your own domain:
domains = example.com
; The following settings are the default used by the software, uncomment
; them only if you want to make changes
; Prefix that will be appended to all Internet domains in the above setting,
; which will be used as a Multi User Chat (MUC) component. Beside this
; setting, you must also add the xmpp-server DNS records into the DNS server
; for the conference domains, e.g.:
; _xmpp-server._tcp.conference.example.com. IN SRV 0 0 5269 sylkserver.example.com.
; muc_prefix = conference
; IP address used for listening to XMPP connections; empty string or any means listen on interface used
; by the default route
; local_ip =
; local_port = 5269
+; transport can be tcp or tls
+
+; transport = tls
+; ca_file = /etc/sylkserver/tls/ca.crt
+; certificate = /etc/sylkserver/tls/default.crt
; If set to True (default) MSRP will be used to translate XMPP Instant Messaging, else SIP MESSAGE will be used
; Note: XMPP 'normal' messages (not chat messages) are always translated to SIP MESSAGE requests
; use_msrp_for_chat = True
; Timeout to terminate a SIP session if no chat traffic was received
; sip_session_timeout = 600
; Enable verbose logging of XMPP stantzas
; trace_xmpp = False
; Log presence activity (can get very verbose)
; log_presence = False
+

File Metadata

Mime Type
text/x-diff
Expires
Sat, Nov 23, 3:28 AM (14 h, 54 s)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
3408703
Default Alt Text
(19 KB)

Event Timeline