def _NH_ChatStreamGotMessage(self, notification):
# Notification is sent by the MSRP stream
message = notification.data.message
content_type = message.content_type.lower()
if content_type not in ('text/plain', 'text/html'):
return
if content_type == 'text/plain':
html_body = None
body = message.content
else:
html_body = message.content
body = None
if self._sip_session_timer is not None and self._sip_session_timer.active(
):
self._sip_session_timer.reset(SESSION_TIMEOUT)
chunk = notification.data.chunk
if self.started:
self.xmpp_session.send_message(body,
html_body,
message_id=chunk.message_id)
if self.use_receipts:
self._pending_msrp_chunks[chunk.message_id] = chunk
else:
self.msrp_stream.msrp_session.send_report(chunk, 200, 'OK')
else:
sender = self.sip_identity
recipient_uri = FrozenURI.parse(message.recipients[0].uri)
recipient = Identity(recipient_uri,
message.recipients[0].display_name)
xmpp_manager = XMPPManager()
xmpp_manager.send_stanza(
ChatMessage(sender, recipient, body, html_body))
self.msrp_stream.msrp_session.send_report(chunk, 200, 'OK')
def end(self):
if self.ended:
return
notification_center = NotificationCenter()
if self._xmpp_muc_session is not None:
notification_center.remove_observer(self,
sender=self._xmpp_muc_session)
# Send indication that the user has been kicked from the room
sender = Identity(
FrozenURI(self.sip_identity.uri.user,
self.sip_identity.uri.host, self.nickname))
stanza = MUCAvailabilityPresence(sender,
self.xmpp_identity,
available=False)
stanza.jid = self.xmpp_identity
stanza.muc_statuses.append('307')
xmpp_manager = XMPPManager()
xmpp_manager.send_muc_stanza(stanza)
self._xmpp_muc_session.end()
self._xmpp_muc_session = None
if self._sip_session is not None:
notification_center.remove_observer(self, sender=self._sip_session)
self._sip_session.end()
self._sip_session = None
self.ended = True
notification_center.post_notification('X2SMucHandlerDidEnd',
sender=self)
def __init__(self, local_identity, remote_identity):
self.local_identity = local_identity
self.remote_identity = remote_identity
self.state = None
self.channel = coros.queue()
self._proc = None
from sylk.applications.xmppgateway.xmpp import XMPPManager
self.xmpp_manager = XMPPManager()
def _NH_ChatStreamDidDeliverMessage(self, notification):
# Echo back the message to the sender
stanza = self._pending_messages_map.pop(notification.data.message_id)
stanza.sender, stanza.recipient = stanza.recipient, stanza.sender
stanza.sender.uri = FrozenURI(stanza.sender.uri.user,
stanza.sender.uri.host, self.nickname)
xmpp_manager = XMPPManager()
xmpp_manager.send_muc_stanza(stanza)
def _NH_ChatStreamDidNotSetNickname(self, notification):
# Notification is sent by the MSRP stream
nickname, stanza = self._pending_nicknames_map.pop(
notification.data.message_id)
error_stanza = MUCErrorPresence.from_stanza(stanza, 'cancel',
[('conflict', STANZAS_NS)])
xmpp_manager = XMPPManager()
xmpp_manager.send_muc_stanza(error_stanza)
def __init__(self):
self.xmpp_manager = XMPPManager()
self.pending_sessions = {}
self.chat_sessions = set()
self.media_sessions = set()
self.s2x_muc_sessions = {}
self.x2s_muc_sessions = {}
self.s2x_presence_subscriptions = {}
self.x2s_presence_subscriptions = {}
self.s2x_muc_add_participant_handlers = {}
self.x2s_muc_add_participant_handlers = {}
def start(self):
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=self.session)
stanza = OutgoingInvitationMessage(self.sender,
self.recipient,
self.inviter,
id='MUC.' + uuid.uuid4().hex)
xmpp_manager = XMPPManager()
xmpp_manager.send_muc_stanza(stanza)
self._timer = reactor.callLater(90, self._timeout)
notification_center.post_notification(
'S2XMucInvitationHandlerDidStart', sender=self)
def _start_outgoing_jingle_session(self, streams):
if self.xmpp_identity.uri.resource is not None:
self.sip_session.reject()
return
xmpp_manager = XMPPManager()
local_jid = self.sip_identity.uri.as_xmpp_jid()
remote_jid = self.xmpp_identity.uri.as_xmpp_jid()
# If this was an invitation to a conference, use the information in the Referred-By header
if self.sip_identity.uri.host in xmpp_manager.muc_domains and self.sip_session.transfer_info and self.sip_session.transfer_info.referred_by:
try:
referred_by_uri = SIPURI.parse(self.sip_session.transfer_info.referred_by)
except SIPCoreError:
self.sip_session.reject(488)
return
else:
inviter_uri = FrozenURI(referred_by_uri.user, referred_by_uri.host)
local_jid = inviter_uri.as_xmpp_jid()
# Use disco to gather potential JIDs to call
d = xmpp_manager.disco_client_protocol.requestItems(remote_jid, sender=local_jid)
try:
items = block_on(d)
except Exception:
items = []
if not items:
self.sip_session.reject(480)
return
# Check which items support Jingle
valid = []
for item in items:
d = xmpp_manager.disco_client_protocol.requestInfo(item.entity, nodeIdentifier=item.nodeIdentifier, sender=local_jid)
try:
info = block_on(d)
except Exception:
continue
if jingle.NS_JINGLE in info.features and jingle.NS_JINGLE_APPS_RTP in info.features:
valid.append(item.entity)
if not valid:
self.sip_session.reject(480)
return
# TODO: start multiple sessions?
self._xmpp_identity = Identity(FrozenURI.parse(valid[0]))
notification_center = NotificationCenter()
if self.sip_identity.uri.host in xmpp_manager.muc_domains:
self.jingle_session = JingleSession(xmpp_manager.jingle_coin_protocol)
else:
self.jingle_session = JingleSession(xmpp_manager.jingle_protocol)
notification_center.add_observer(self, sender=self.jingle_session)
self.jingle_session.connect(self.sip_identity, self.xmpp_identity, streams, is_focus=self.sip_session.remote_focus)
def _NH_SIPSessionGotConferenceInfo(self, notification):
# Translate to XMPP payload
xmpp_manager = XMPPManager()
own_uri = FrozenURI(self.xmpp_identity.uri.user,
self.xmpp_identity.uri.host)
conference_info = notification.data.conference_info
new_participants = set()
for user in conference_info.users:
user_uri = FrozenURI.parse(user.entity if user.entity.startswith((
'sip:', 'sips:')) else 'sip:' + user.entity)
nickname = user.display_text.value if user.display_text else user.entity
new_participants.add((user_uri, nickname))
# Remove participants that are no longer in the room
for uri, nickname in self._participants - new_participants:
sender = Identity(
FrozenURI(self.sip_identity.uri.user,
self.sip_identity.uri.host, nickname))
stanza = MUCAvailabilityPresence(sender,
self.xmpp_identity,
available=False)
xmpp_manager.send_muc_stanza(stanza)
# Send presence for current participants
for uri, nickname in new_participants:
if uri == own_uri:
continue
sender = Identity(
FrozenURI(self.sip_identity.uri.user,
self.sip_identity.uri.host, nickname))
stanza = MUCAvailabilityPresence(sender,
self.xmpp_identity,
available=True)
stanza.jid = Identity(uri)
xmpp_manager.send_muc_stanza(stanza)
self._participants = new_participants
# Send own status last
sender = Identity(
FrozenURI(self.sip_identity.uri.user, self.sip_identity.uri.host,
self.nickname))
stanza = MUCAvailabilityPresence(sender,
self.xmpp_identity,
available=True)
stanza.jid = self.xmpp_identity
stanza.muc_statuses.append('110')
xmpp_manager.send_muc_stanza(stanza)
def _NH_SIPSessionDidStart(self, notification):
log.info("SIP session %s started" % self.sip_session.call_id)
self._sip_session_timer = reactor.callLater(SESSION_TIMEOUT,
self._inactivity_timeout)
if self.sip_session.direction == 'outgoing':
# Time to set sip_identity and create the XMPPChatSession
contact_uri = self.sip_session._invitation.remote_contact_header.uri
if contact_uri.parameters.get('gr') is not None:
sip_leg_uri = FrozenURI(contact_uri.user, contact_uri.host,
contact_uri.parameters.get('gr'))
else:
tmp = self.sip_session.remote_identity.uri
sip_leg_uri = FrozenURI(tmp.user, tmp.host,
generate_sylk_resource())
self.sip_identity = Identity(
sip_leg_uri, self.sip_session.remote_identity.display_name)
session = XMPPChatSession(local_identity=self.sip_identity,
remote_identity=self.xmpp_identity)
self.xmpp_session = session
# Session is now established on both ends
self.started = True
# Try to wakeup XMPP clients
self.xmpp_session.send_composing_indication('active')
self.xmpp_session.send_message(' ', 'text/plain')
else:
if self.xmpp_session is not None:
# Session is now established on both ends
self.started = True
# Try to wakeup XMPP clients
self.xmpp_session.send_composing_indication('active')
self.xmpp_session.send_message(' ', 'text/plain')
else:
# Try to wakeup XMPP clients
sender = self.sip_identity
tmp = self.sip_session.local_identity.uri
recipient_uri = FrozenURI(tmp.user, tmp.host)
recipient = Identity(recipient_uri)
xmpp_manager = XMPPManager()
xmpp_manager.send_stanza(
ChatMessage(sender, recipient, ' ', 'text/plain'))
# Send queued messages
self._send_queued_messages()
