def stop(self):
old_slot = self.consumer_slot
self._recording_wave_file.stop()
self._recording_wave_file = None
notification_center = NotificationCenter()
notification_center.post_notification('AudioPortDidChangeSlots', sender=self, data=NotificationData(consumer_slot_changed=True, producer_slot_changed=False,
old_consumer_slot=old_slot, new_consumer_slot=None))
def initialize(self, session, streams, new_session=True):
self.session = session
self.streams = streams
self.new_session = new_session
notification_center = NotificationCenter()
notification_center.post_notification('IncomingRequestReceived', sender=self)
def activate(self):
if not self.started:
raise RuntimeError("not started")
self.active = True
self._command_channel.send(Command('publish', state=self.state))
notification_center = NotificationCenter()
notification_center.post_notification(self.__class__.__name__ + 'DidActivate', sender=self)
def _NH_SIPApplicationDidStart(self, notification):
account_manager = AccountManager()
self.xcap_manager = XCAPManager(account_manager.default_account)
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=self.xcap_manager)
self.xcap_manager.load(os.path.realpath('xcap-cache'))
self.xcap_manager.start()
def _NH_SIPSessionDidEnd(self, notification):
log.msg('Session ended')
session = notification.sender
chat_stream = session.streams[0]
notification_center = NotificationCenter()
notification_center.remove_observer(self, sender=chat_stream)
notification_center.remove_observer(self, sender=session)
def _NH_SIPRequestDidSucceed(self, notification):
request = notification.sender
notification_center = NotificationCenter()
with self._lock:
if request is not self._current_request:
return
self._current_request = None
if self._unregistering:
if self._last_request is not None:
self._last_request.end()
self._last_request = None
notification_center.post_notification("SIPRegistrationDidEnd", sender=self,
data=TimestampedNotificationData(expired=False))
else:
self._last_request = request
try:
contact_header_list = notification.data.headers["Contact"]
except KeyError:
contact_header_list = []
notification_center.post_notification("SIPRegistrationDidSucceed", sender=self,
data=TimestampedNotificationData(code=notification.data.code,
reason=notification.data.reason,
contact_header=request.contact_header,
contact_header_list=contact_header_list,
expires_in=notification.data.expires,
route_header=request.route_header))
def _CH_update_registrations(self, command):
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
if self._update_timer is not None and self._update_timer.active():
self._update_timer.cancel()
self._update_timer = None
available_transports = settings.sip.transport_list
old_files = []
for file in (f for f in self._files[:] if isinstance(f, BonjourRegistrationFile) and f.transport not in available_transports):
old_files.append(file)
self._files.remove(file)
self._select_proc.kill(RestartSelect)
for file in old_files:
file.close()
update_failure = False
for file in (f for f in self._files if isinstance(f, BonjourRegistrationFile)):
try:
contact_uri, txtdata = self._build_txtdata(file.transport)
if txtdata is None:
raise KeyError('error processing %s transport' % file.transport)
_bonjour.DNSServiceUpdateRecord(file.file, None, flags=0, rdata=_bonjour.TXTRecord(items=txtdata), ttl=0)
except (_bonjour.BonjourError, KeyError), e:
notification_center.post_notification('BonjourServiceRegistrationUpdateDidFail', sender=self,
data=NotificationData(reason=str(e), transport=file.transport))
update_failure = True
def init(self):
self = super(DebugWindow, self).init()
NSBundle.loadNibNamed_owner_("DebugWindow", self)
for textView in [self.activityTextView, self.sipTextView, self.rtpTextView, self.msrpTextView, self.xcapTextView, self.pjsipTextView]:
textView.setString_("")
for label in [self.activityInfoLabel, self.sipInfoLabel, self.rtpInfoLabel, self.msrpInfoLabel, self.xcapInfoLabel, self.notificationsInfoLabel, self.pjsipInfoLabel]:
label.setStringValue_('')
BlinkLogger().set_gui_logger(self.renderActivity)
NSNotificationCenter.defaultCenter().addObserver_selector_name_object_(self, "userDefaultsDidChange:", "NSUserDefaultsDidChangeNotification", NSUserDefaults.standardUserDefaults())
notification_center = NotificationCenter()
notification_center.add_observer(self, name="SIPSessionDidStart")
notification_center.add_observer(self, name="SIPSessionDidRenegotiateStreams")
userdef = NSUserDefaults.standardUserDefaults()
self.sipRadio.selectCellWithTag_(userdef.integerForKey_("SIPTrace") or Disabled)
self.msrpRadio.selectCellWithTag_(userdef.integerForKey_("MSRPTrace") or Disabled)
self.xcapRadio.selectCellWithTag_(userdef.integerForKey_("XCAPTrace") or Disabled)
self.pjsipCheckBox.setState_(NSOnState if userdef.boolForKey_("EnablePJSIPTrace") else NSOffState)
self.userDefaultsDidChange_(None)
return self
def accept(self):
if self._done:
return
self.accepted_streams = [next(stream for stream in self.streams if stream.type=='audio')]
notification_center = NotificationCenter()
notification_center.post_notification('IncomingRequestAccepted', sender=self)
self._done = True
def _make_and_send_request(self, contact_header, route_header, timeout, do_register):
notification_center = NotificationCenter()
prev_request = self._current_request or self._last_request
if prev_request is not None:
call_id = prev_request.call_id
cseq = prev_request.cseq + 1
else:
call_id = None
cseq = 1
extra_headers = []
extra_headers.append(Header("Expires", str(int(self.duration) if do_register else 0)))
extra_headers.extend(self.extra_headers)
request = Request("REGISTER", SIPURI(self.from_header.uri.host), self.from_header, ToHeader.new(self.from_header), route_header,
credentials=self.credentials, contact_header=contact_header, call_id=call_id,
cseq=cseq, extra_headers=extra_headers)
notification_center.add_observer(self, sender=request)
if self._current_request is not None:
# we are trying to send something already, cancel whatever it is
self._current_request.end()
self._current_request = None
try:
request.send(timeout=timeout)
except:
notification_center.remove_observer(self, sender=request)
raise
self._unregistering = not do_register
self._current_request = request
def register(self, contact_header, route_header, timeout=None):
with self._lock:
try:
self._make_and_send_request(contact_header, route_header, timeout, True)
except SIPCoreError, e:
notification_center = NotificationCenter()
notification_center.post_notification('SIPRegistrationDidFail', sender=self, data=NotificationData(code=0, reason=e.args[0], route_header=route_header))
def stop(self):
self._deactivate()
notification_center = NotificationCenter()
notification_center.remove_observer(self, name='SystemIPAddressDidChange')
notification_center.remove_observer(self, name='SystemDidWakeUpFromSleep')
self._select_proc.kill()
self._command_channel.send_exception(api.GreenletExit)
def start(self):
notification_center = NotificationCenter()
notification_center.add_observer(self, name='SystemIPAddressDidChange')
notification_center.add_observer(self, name='SystemDidWakeUpFromSleep')
self._select_proc = proc.spawn(self._process_files)
proc.spawn(self._handle_commands)
self._activate()
def _start_incoming_sip_session(self, session):
self.sip_session = session
self.msrp_stream = next(stream for stream in session.proposed_streams if stream.type=='chat')
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=self.sip_session)
notification_center.add_observer(self, sender=self.msrp_stream)
self.sip_session.accept([self.msrp_stream])
def lookup_xcap_server(self, uri, timeout=3.0, lifetime=15.0):
"""
Performs a TXT query against xcap.<uri.host> and returns all results
that look like HTTP URIs.
"""
log_context = dict(context='lookup_xcap_server', uri=uri)
notification_center = NotificationCenter()
try:
# If the host part of the URI is an IP address, we cannot not do any lookup
if re.match("^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$", uri.host):
raise DNSLookupError("Cannot perform DNS query because the host is an IP address")
resolver = DNSResolver()
resolver.cache = self.cache
resolver.timeout = timeout
resolver.lifetime = lifetime
record_name = 'xcap.%s' % uri.host
results = []
try:
answer = resolver.query(record_name, rdatatype.TXT)
except dns.resolver.Timeout, e:
notification_center.post_notification('DNSLookupTrace', sender=self, data=NotificationData(query_type='TXT', query_name=str(record_name), nameservers=resolver.nameservers, answer=None, error=e, **log_context))
raise
except exception.DNSException, e:
notification_center.post_notification('DNSLookupTrace', sender=self, data=NotificationData(query_type='TXT', query_name=str(record_name), nameservers=resolver.nameservers, answer=None, error=e, **log_context))
def busy(self):
if self._done:
return
self.reject_mode = 'busy'
notification_center = NotificationCenter()
notification_center.post_notification('IncomingRequestRejected', sender=self)
self._done = True
def wrapper(obj, *args, **kwargs):
notification_center = NotificationCenter()
try:
result = func(obj, *args, **kwargs)
except DNSLookupError, e:
notification_center.post_notification('DNSLookupDidFail', sender=obj, data=NotificationData(error=str(e)))
raise
def _CH_register(self, command):
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
if self._register_timer is not None and self._register_timer.active():
self._register_timer.cancel()
self._register_timer = None
supported_transports = set(transport for transport in settings.sip.transport_list if transport!='tls' or self.account.tls.certificate is not None)
registered_transports = set(file.transport for file in self._files if isinstance(file, BonjourRegistrationFile))
missing_transports = supported_transports - registered_transports
added_transports = set()
for transport in missing_transports:
notification_center.post_notification('BonjourAccountWillRegister', sender=self.account, data=NotificationData(transport=transport))
try:
contact = self.account.contact[NoGRUU, transport]
instance_id = str(uuid.UUID(settings.instance_id))
txtdata = dict(txtvers=1, name=self.account.display_name.encode('utf-8'), contact="<%s>" % str(contact), instance_id=instance_id)
state = self.account.presence_state
if self.account.presence.enabled and state is not None:
txtdata['state'] = state.state
txtdata['note'] = state.note.encode('utf-8')
file = _bonjour.DNSServiceRegister(name=str(contact),
regtype="_sipuri._%s" % (transport if transport == 'udp' else 'tcp'),
port=contact.port,
callBack=self._register_cb,
txtRecord=_bonjour.TXTRecord(items=txtdata))
except (_bonjour.BonjourError, KeyError), e:
notification_center.post_notification('BonjourAccountRegistrationDidFail', sender=self.account, data=NotificationData(reason=str(e), transport=transport))
else:
self._files.append(BonjourRegistrationFile(file, transport))
added_transports.add(transport)
def _CH_register(self, command):
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
if self._register_timer is not None and self._register_timer.active():
self._register_timer.cancel()
self._register_timer = None
supported_transports = set(settings.sip.transport_list)
registered_transports = set(file.transport for file in self._files if isinstance(file, BonjourRegistrationFile))
missing_transports = supported_transports - registered_transports
added_transports = set()
for transport in missing_transports:
notification_center.post_notification('BonjourServiceWillRegister', sender=self, data=NotificationData(transport=transport))
try:
contact_uri, txtdata = self._build_txtdata(transport)
if txtdata is None:
raise KeyError('error processing %s transport' % transport)
file = _bonjour.DNSServiceRegister(name=str(contact_uri),
regtype="_op2-phone._%s" % (transport if transport == 'udp' else 'tcp'),
port=contact_uri.port,
callBack=self._register_cb,
txtRecord=_bonjour.TXTRecord(items=txtdata))
except (_bonjour.BonjourError, KeyError), e:
notification_center.post_notification('BonjourServiceRegistrationDidFail', sender=self,
data=NotificationData(reason=str(e), transport=transport))
else:
self._files.append(BonjourRegistrationFile(file, transport))
added_transports.add(transport)
def _CH_update_registrations(self, command):
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
if self._update_timer is not None and self._update_timer.active():
self._update_timer.cancel()
self._update_timer = None
available_transports = settings.sip.transport_list
old_files = []
for file in (f for f in self._files[:] if isinstance(f, BonjourRegistrationFile) and f.transport not in available_transports):
old_files.append(file)
self._files.remove(file)
self._select_proc.kill(RestartSelect)
for file in old_files:
file.close()
update_failure = False
for file in (f for f in self._files if isinstance(f, BonjourRegistrationFile)):
try:
contact = self.account.contact[NoGRUU, file.transport]
instance_id = str(uuid.UUID(settings.instance_id))
txtdata = dict(txtvers=1, name=self.account.display_name.encode('utf-8'), contact="<%s>" % str(contact), instance_id=instance_id)
state = self.account.presence_state
if self.account.presence.enabled and state is not None:
txtdata['state'] = state.state
txtdata['note'] = state.note.encode('utf-8')
_bonjour.DNSServiceUpdateRecord(file.file, None, flags=0, rdata=_bonjour.TXTRecord(items=txtdata), ttl=0)
except (_bonjour.BonjourError, KeyError), e:
notification_center.post_notification('BonjourAccountRegistrationUpdateDidFail', sender=self.account, data=NotificationData(reason=str(e), transport=file.transport))
update_failure = True
def _start_outgoing_sip_session(self, streams):
notification_center = NotificationCenter()
# self.xmpp_identity is our local identity on the SIP side
from_uri = self.xmpp_identity.uri.as_sip_uri()
from_uri.parameters.pop('gr', None) # no GRUU in From header
to_uri = self.sip_identity.uri.as_sip_uri()
to_uri.parameters.pop('gr', None) # no GRUU in To header
# TODO: need to fix GRUU in the proxy
#contact_uri = self.xmpp_identity.uri.as_sip_uri()
#contact_uri.parameters['gr'] = encode_resource(contact_uri.parameters['gr'].decode('utf-8'))
lookup = DNSLookup()
settings = SIPSimpleSettings()
account = DefaultAccount()
if account.sip.outbound_proxy is not None:
uri = SIPURI(host=account.sip.outbound_proxy.host,
port=account.sip.outbound_proxy.port,
parameters={'transport': account.sip.outbound_proxy.transport})
else:
uri = to_uri
try:
routes = lookup.lookup_sip_proxy(uri, settings.sip.transport_list).wait()
except DNSLookupError:
log.warning('DNS lookup error while looking for %s proxy' % uri)
notification_center.post_notification('MedialSessionHandlerDidFail', sender=self, data=NotificationData(reason='DNS lookup error'))
return
route = routes.pop(0)
from_header = FromHeader(from_uri)
to_header = ToHeader(to_uri)
self.sip_session = Session(account)
notification_center.add_observer(self, sender=self.sip_session)
self.sip_session.connect(from_header, to_header, route=route, streams=streams)
def _browse_cb(self, file, flags, interface_index, error_code, service_name, regtype, reply_domain):
notification_center = NotificationCenter()
file = BonjourDiscoveryFile.find_by_file(file)
service_description = BonjourServiceDescription(service_name, regtype, reply_domain)
if error_code != _bonjour.kDNSServiceErr_NoError:
error = _bonjour.BonjourError(error_code)
notification_center.post_notification('BonjourConferenceServicesDiscoveryDidFail', sender=self, data=NotificationData(reason=str(error), transport=file.transport))
removed_files = [file] + [f for f in self._files if isinstance(f, BonjourResolutionFile) and f.discovery_file==file]
for f in removed_files:
self._files.remove(f)
self._select_proc.kill(RestartSelect)
for f in removed_files:
f.close()
if self._discover_timer is None:
self._discover_timer = reactor.callLater(1, self._command_channel.send, Command('discover'))
return
if reply_domain != 'local.':
return
if flags & _bonjour.kDNSServiceFlagsAdd:
try:
resolution_file = (f for f in self._files if isinstance(f, BonjourResolutionFile) and f.discovery_file==file and f.service_description==service_description).next()
except StopIteration:
try:
resolution_file = _bonjour.DNSServiceResolve(0, interface_index, service_name, regtype, reply_domain, self._resolve_cb)
except _bonjour.BonjourError, e:
notification_center.post_notification('BonjourConferenceServicesDiscoveryFailure', sender=self, data=NotificationData(error=str(e), transport=file.transport))
else:
resolution_file = BonjourResolutionFile(resolution_file, discovery_file=file, service_description=service_description)
self._files.append(resolution_file)
self._select_proc.kill(RestartSelect)
class MusicApplications(object):
__metaclass__ = Singleton
is_resuming = False
is_pausing = False
def __init__(self):
self.notification_center = NotificationCenter()
self.must_pause = False
self.itunes = iTunesInterface(self)
self.spotify = SpotifyInterface(self)
# self.vlc = VLCInterface(self)
@run_in_thread("Music-interface")
def pause(self):
settings = SIPSimpleSettings()
if not settings.audio.pause_music:
return
self.is_pausing = True
self.itunes.pause()
# self.spotify.pause()
# self.vlc.pause()
self.is_pausing = False
self.notification_center.post_notification("MusicPauseDidExecute", sender=self)
@run_in_thread("Music-interface")
def resume(self):
settings = SIPSimpleSettings()
if not settings.audio.pause_music:
return
self.must_pause = False
self.is_resuming = True
self.itunes.resume()
# self.spotify.resume()
# self.vlc.resume()
self.is_resuming = False
def _NH_IncomingFileTransferHandlerDidEnd(self, sender, data):
notification_center = NotificationCenter()
if not self.finished_transfer:
self.log_info(u"Removing incomplete file %s" % self.file_path)
os.remove(self.file_path)
self.fail_reason = "Interrupted"
else:
local_hash = 'sha1:' + ':'.join(re.findall(r'..', self.hash.hexdigest()))
remote_hash = self.file_selector.hash.lower()
if local_hash == remote_hash:
oname = self.file_path
self.file_path = self.file_path[:-len(".download")]
self.log_info(u"Renaming transferred file to %s" % self.file_path)
os.rename(oname, self.file_path)
else:
self.error = True
self.fail_reason = "File hash mismatch"
self.log_info(u"Removing corrupted file %s" % self.file_path)
os.remove(self.file_path)
self.log_info("Incoming File Transfer ended (%i of %i bytes transferred)" % (self.file_pos, self.file_size))
self.end_time = datetime.datetime.now()
if self.finished_transfer and not self.error:
self.status = "Completed in %s %s %s" % (format_duration(self.end_time-self.start_time), unichr(0x2014), format_size(self.file_size))
self.ft_info.status = "completed"
self.ft_info.bytes_transfered = self.file_size
notification_center.post_notification("BlinkFileTransferDidEnd", sender=self, data=NotificationData(file_path=self.file_path))
else:
self.status = self.fail_reason
self.ft_info.status = "failed"
self.ft_info.bytes_transfered = self.file_pos
notification_center.post_notification("BlinkFileTransferDidFail", sender=self)
def _NH_DNSLookupDidSucceed(self, sender, data):
notification_center = NotificationCenter()
notification_center.remove_observer(self, sender=sender)
if self.interrupted:
notification_center.post_notification("BlinkFileTransferDidFail", sender=self)
return
self.session.connect(ToHeader(self.target_uri), data.result, [self.stream])
def _NH_FileTransferStreamDidDeliverChunk(self, sender, data):
self.file_pos = data.transferred_bytes
self.update_transfer_rate()
self.status = self.format_progress()
notification_center = NotificationCenter()
notification_center.post_notification("BlinkFileTransferUpdate", sender=self)
def stop(self):
# stop the thread processing the notifications
self._event_queue.stop()
self._event_queue.join()
# close sip trace file
if self._siptrace_file is not None:
self._siptrace_file.close()
self._siptrace_file = None
# close msrp trace file
if self._msrptrace_file is not None:
self._msrptrace_file.close()
self._msrptrace_file = None
# close pjsip trace file
if self._pjsiptrace_file is not None:
self._pjsiptrace_file.close()
self._pjsiptrace_file = None
# close notifications trace file
if self._notifications_file is not None:
self._notifications_file.close()
self._notifications_file = None
# unregister from receiving notifications
notification_center = NotificationCenter()
notification_center.remove_observer(self)
def deactivate(self):
if not self.started:
raise RuntimeError("not started")
self.active = False
self._command_channel.send(Command('unsubscribe'))
notification_center = NotificationCenter()
notification_center.post_notification(self.__class__.__name__ + 'DidDeactivate', sender=self)
def __init__(self, parent=None):
super(FileTransferWindow, self).__init__(parent)
with Resources.directory:
self.setupUi(self)
self.model = FileTransferModel(self)
self.listview.setModel(self.model)
self.listview.setItemDelegate(FileTransferDelegate(self.listview))
self.listview.customContextMenuRequested.connect(self._SH_ContextMenuRequested)
self.context_menu = QMenu(self.listview)
self.actions = ContextMenuActions()
self.actions.open_file = QAction("Open", self, triggered=self._AH_OpenFile)
self.actions.open_file_folder = QAction("Open File Folder", self, triggered=self._AH_OpenFileFolder)
self.actions.cancel_transfer = QAction("Cancel", self, triggered=self._AH_CancelTransfer)
self.actions.retry_transfer = QAction("Retry", self, triggered=self._AH_RetryTransfer)
self.actions.remove_entry = QAction("Remove From List", self, triggered=self._AH_RemoveEntry)
self.actions.open_downloads_folder = QAction("Open Transfers Folder", self, triggered=self._AH_OpenTransfersFolder)
self.actions.clear_list = QAction("Clear List", self, triggered=self._AH_ClearList)
self.model.itemAdded.connect(self.update_status)
self.model.itemRemoved.connect(self.update_status)
self.model.modelReset.connect(self.update_status)
notification_center = NotificationCenter()
notification_center.add_observer(self, name='BlinkFileTransferWillRetry')
notification_center.add_observer(self, name='BlinkFileTransferDidEnd')
def _start_outgoing_sip_session(self, target_uri):
notification_center = NotificationCenter()
# self.xmpp_identity is our local identity
from_uri = self.xmpp_identity.uri.as_sip_uri()
del from_uri.parameters['gr'] # no GRUU in From header
contact_uri = self.xmpp_identity.uri.as_sip_uri()
contact_uri.parameters['gr'] = encode_resource(contact_uri.parameters['gr'].decode('utf-8'))
to_uri = target_uri.as_sip_uri()
lookup = DNSLookup()
settings = SIPSimpleSettings()
account = DefaultAccount()
if account.sip.outbound_proxy is not None:
uri = SIPURI(host=account.sip.outbound_proxy.host,
port=account.sip.outbound_proxy.port,
parameters={'transport': account.sip.outbound_proxy.transport})
else:
uri = to_uri
try:
routes = lookup.lookup_sip_proxy(uri, settings.sip.transport_list).wait()
except DNSLookupError:
log.warning('DNS lookup error while looking for %s proxy' % uri)
notification_center.post_notification('ChatSessionDidFail', sender=self, data=NotificationData(reason='DNS lookup error'))
return
self.msrp_stream = MediaStreamRegistry().get('chat')()
route = routes.pop(0)
from_header = FromHeader(from_uri)
to_header = ToHeader(to_uri)
contact_header = ContactHeader(contact_uri)
self.sip_session = Session(account)
notification_center.add_observer(self, sender=self.sip_session)
notification_center.add_observer(self, sender=self.msrp_stream)
self.sip_session.connect(from_header, to_header, contact_header=contact_header, route=route, streams=[self.msrp_stream])
def _NH_SIPIncomingSubscriptionDidEnd(self, notification):
subscription = notification.sender
notification_center = NotificationCenter()
notification_center.remove_observer(self, sender=subscription)
self.subscriptions.remove(subscription)
def start(self):
notification_center = NotificationCenter()
notification_center.add_observer(self, name='SIPAccountWillActivate')
notification_center.add_observer(self, name='SIPAccountWillDeactivate')
notification_center.add_observer(self, name='SIPAccountGotPresenceState')
notification_center.add_observer(self, name='SIPAccountGotPresenceWinfo')
def mouseDown_(self, event):
NotificationCenter().post_notification(
"BlinkTableViewSelectionChaged",
sender=self,
data=TimestampedNotificationData())
NSTableView.mouseDown_(self, event)
def _CH_discover(self, command):
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
if self._discover_timer is not None and self._discover_timer.active():
self._discover_timer.cancel()
self._discover_timer = None
supported_transports = set(
transport for transport in settings.sip.transport_list
if transport != 'tls' or self.account.tls.certificate is not None)
discoverable_transports = set(
'tcp' if transport == 'tls' else transport
for transport in supported_transports)
old_files = []
for file in (
f for f in self._files[:]
if isinstance(f, (BonjourDiscoveryFile, BonjourResolutionFile))
and f.transport not in discoverable_transports):
old_files.append(file)
self._files.remove(file)
self._select_proc.kill(RestartSelect)
for file in old_files:
file.close()
for service_description in [
service for service, record in list(self._neighbours.items())
if record.uri.transport not in supported_transports
]:
record = self._neighbours.pop(service_description)
notification_center.post_notification(
'BonjourAccountDidRemoveNeighbour',
sender=self.account,
data=NotificationData(neighbour=service_description,
record=record))
discovered_transports = set(file.transport for file in self._files
if isinstance(file, BonjourDiscoveryFile))
missing_transports = discoverable_transports - discovered_transports
added_transports = set()
for transport in missing_transports:
notification_center.post_notification(
'BonjourAccountWillInitiateDiscovery',
sender=self.account,
data=NotificationData(transport=transport))
try:
file = _bonjour.DNSServiceBrowse(regtype="_sipuri._%s" %
transport,
callBack=self._browse_cb)
except _bonjour.BonjourError as e:
notification_center.post_notification(
'BonjourAccountDiscoveryDidFail',
sender=self.account,
data=NotificationData(reason=str(e), transport=transport))
else:
self._files.append(BonjourDiscoveryFile(file, transport))
added_transports.add(transport)
if added_transports:
self._select_proc.kill(RestartSelect)
if added_transports != missing_transports:
self._discover_timer = reactor.callLater(
1, self._command_channel.send,
Command('discover', command.event))
else:
command.signal()
def action(self, user, channel, data):
if channel.strip('#') == self.factory.channel:
username = user.split('!', 1)[0]
data = NotificationData(user=username, action=data)
NotificationCenter().post_notification('IRCBotUserAction', self.factory, data)
def userKicked(self, kickee, channel, kicker, message):
if channel.strip('#') == self.factory.channel:
data = NotificationData(kickee=kickee, kicker=kicker, reason=message)
NotificationCenter().post_notification('IRCBotUserKicked', self.factory, data)
def userLeft(self, user, channel):
if channel.strip('#') == self.factory.channel:
data = NotificationData(user=user)
NotificationCenter().post_notification('IRCBotUserLeft', self.factory, data)
def joined(self, channel):
log.msg('Logged into %s channel' % channel)
NotificationCenter().post_notification('IRCBotJoinedChannel', self.factory, NotificationData(channel=self.factory.channel))
def connectionMade(self):
irc.IRCClient.connectionMade(self)
log.msg('Connection to IRC has been established')
NotificationCenter().post_notification('IRCBotGotConnected', self.factory, NotificationData(protocol=self))
def _NH_SIPPublicationDidFail(self, notification):
log.info('PUBLISH for xcap-diff event failed to %s for %s' %
(notification.data.route_header.uri,
notification.sender.from_header.uri))
NotificationCenter().remove_observer(self, sender=notification.sender)
def _NH_SIPPublicationDidEnd(self, notification):
log.info('PUBLISH for xcap-diff event ended for %s' %
notification.sender.from_header.uri)
NotificationCenter().remove_observer(self, sender=notification.sender)
def __init__(self, *args, **kw):
super(SylkWebSocketServerFactory, self).__init__(*args, **kw)
notification_center = NotificationCenter()
notification_center.add_observer(self, name='JanusBackendDisconnected')
def incoming_chat_session(self, session):
# Check if this session is really an invitation to add a participant to a conference room / muc
if session.remote_identity.uri.host in self.xmpp_manager.muc_domains and 'isfocus' in session._invitation.remote_contact_header.parameters:
try:
referred_by_uri = SIPURI.parse(
session.transfer_info.referred_by)
except SIPCoreError:
log.info(
"SIP multiparty session invitation %s failed: invalid Referred-By header"
% session.call_id)
session.reject(488)
return
muc_uri = FrozenURI(session.remote_identity.uri.user,
session.remote_identity.uri.host)
inviter_uri = FrozenURI(referred_by_uri.user, referred_by_uri.host)
recipient_uri = FrozenURI(session.local_identity.uri.user,
session.local_identity.uri.host)
sender = Identity(muc_uri)
recipient = Identity(recipient_uri)
inviter = Identity(inviter_uri)
try:
handler = self.s2x_muc_add_participant_handlers[(
muc_uri, recipient_uri)]
except KeyError:
handler = S2XMucInvitationHandler(session, sender, recipient,
inviter)
self.s2x_muc_add_participant_handlers[(
muc_uri, recipient_uri)] = handler
NotificationCenter().add_observer(self, sender=handler)
handler.start()
else:
log.info(
"SIP multiparty session invitation %s failed: there is another invitation in progress from %s to %s"
% (session.call_id, format_uri(inviter_uri, 'sip'),
format_uri(recipient_uri, 'xmpp')))
session.reject(480)
return
# Check domain
if session.remote_identity.uri.host not in XMPPGatewayConfig.domains:
log.info(
'Session rejected: From domain is not a local XMPP domain')
session.reject(606, 'Not Acceptable')
return
# Get URI representing the SIP side
contact_uri = 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 = session.remote_identity.uri
sip_leg_uri = FrozenURI(tmp.user, tmp.host,
generate_sylk_resource())
# Get URI representing the XMPP side
request_uri = session.request_uri
remote_resource = request_uri.parameters.get('gr', None)
if remote_resource is not None:
try:
remote_resource = decode_resource(remote_resource)
except (TypeError, UnicodeError):
remote_resource = None
xmpp_leg_uri = FrozenURI(request_uri.user, request_uri.host,
remote_resource)
try:
handler = self.pending_sessions[(sip_leg_uri, xmpp_leg_uri)]
except KeyError:
pass
else:
# There is another pending session with same identifiers, can't accept this one
log.info(
'Session rejected: other session with same identifiers in progress'
)
session.reject(488)
return
sip_identity = Identity(sip_leg_uri,
session.remote_identity.display_name)
handler = ChatSessionHandler.new_from_sip_session(
sip_identity, session)
NotificationCenter().add_observer(self, sender=handler)
key = (sip_leg_uri, xmpp_leg_uri)
self.pending_sessions[key] = handler
if xmpp_leg_uri.resource is not None:
# Incoming session target contained GRUU, so create XMPPChatSession immediately
xmpp_session = XMPPChatSession(
local_identity=handler.sip_identity,
remote_identity=Identity(xmpp_leg_uri))
handler.xmpp_identity = xmpp_session.remote_identity
handler.xmpp_session = xmpp_session
def _NH_XMPPGotChatMessage(self, notification):
# This notification is only processed here untill the ChatSessionHandler
# has both (SIP and XMPP) sessions established
message = notification.data.message
sender = message.sender
recipient = message.recipient
if XMPPGatewayConfig.use_msrp_for_chat:
if recipient.uri.resource is None:
# If recipient resource is not set the session is started from
# the XMPP side
sip_leg_uri = FrozenURI.new(recipient.uri)
xmpp_leg_uri = FrozenURI.new(sender.uri)
try:
handler = self.pending_sessions[(sip_leg_uri,
xmpp_leg_uri)]
handler.enqueue_xmpp_message(message)
except KeyError:
# Check if we have any already open chat session and dispatch it there
try:
handler = next(
h for h in self.chat_sessions
if h.xmpp_identity.uri.user == xmpp_leg_uri.user
and h.xmpp_identity.uri.host == xmpp_leg_uri.host
and h.sip_identity.uri.user == sip_leg_uri.user
and h.sip_identity.uri.host == sip_leg_uri.host)
except StopIteration:
# Not found, need to create a new handler and a outgoing SIP session
xmpp_identity = Identity(xmpp_leg_uri)
handler = ChatSessionHandler.new_from_xmpp_stanza(
xmpp_identity, sip_leg_uri)
key = (sip_leg_uri, xmpp_leg_uri)
self.pending_sessions[key] = handler
NotificationCenter().add_observer(self, sender=handler)
handler.enqueue_xmpp_message(message)
else:
# Find handler pending XMPP confirmation
sip_leg_uri = FrozenURI.new(recipient.uri)
xmpp_leg_uri = FrozenURI(sender.uri.user, sender.uri.host)
try:
handler = self.pending_sessions[(sip_leg_uri,
xmpp_leg_uri)]
except KeyError:
# Find handler pending XMPP confirmation
sip_leg_uri = FrozenURI(recipient.uri.user,
recipient.uri.host)
xmpp_leg_uri = FrozenURI.new(sender.uri)
try:
handler = self.pending_sessions[(sip_leg_uri,
xmpp_leg_uri)]
except KeyError:
# Try harder, maybe the XMPP client changed his from
try:
handler = next(
h for h in self.chat_sessions
if h.xmpp_identity.uri.user ==
xmpp_leg_uri.user and h.xmpp_identity.uri.host
== xmpp_leg_uri.host and
h.sip_identity.uri.user == sip_leg_uri.user and
h.sip_identity.uri.host == sip_leg_uri.host)
except StopIteration:
# It's a new XMPP session to a full JID, disregard the full JID and start a new SIP session to the bare JID
xmpp_identity = Identity(xmpp_leg_uri)
handler = ChatSessionHandler.new_from_xmpp_stanza(
xmpp_identity, sip_leg_uri)
key = (sip_leg_uri, xmpp_leg_uri)
self.pending_sessions[key] = handler
NotificationCenter().add_observer(self,
sender=handler)
handler.enqueue_xmpp_message(message)
else:
# Found handle, create XMPP session and establish session
session = XMPPChatSession(local_identity=recipient,
remote_identity=sender)
handler.enqueue_xmpp_message(message)
handler.xmpp_identity = session.remote_identity
handler.xmpp_session = session
else:
sip_message_sender = SIPMessageSender(message)
try:
sip_message_sender.send().wait()
except SIPMessageError as e:
# TODO report back an error stanza
log.error('Error sending SIP Message: %s' % e)
def connectionLost(self, failure):
irc.IRCClient.connectionLost(self, failure)
NotificationCenter().post_notification('IRCBotGotDisconnected', self.factory, NotificationData())
def smp_verify(self, secret, question=None):
if self.encrypted:
self.protocol.smp_verify(secret, question)
else:
notification_center = NotificationCenter()
notification_center.post_notification('OTRSessionSMPVerificationDidNotStart', sender=self, data=NotificationData(reason='not encrypted'))
def got_participants(self, nicks):
data = NotificationData(participants=nicks)
NotificationCenter().post_notification('IRCBotGotParticipantsList', self.factory, data)
def __init__(self):
if self:
notification_center = NotificationCenter()
notification_center.add_observer(
self, name="BlinkFileTransferNewOutgoing")
notification_center.add_observer(
self, name="BlinkFileTransferNewIncoming")
notification_center.add_observer(
self, name="BlinkFileTransferWillRestart")
notification_center.add_observer(self,
name="BlinkFileTransferDidEnd")
notification_center.add_observer(
self, name="BlinkFileTransferSpeedDidUpdate")
notification_center.add_observer(self, name="BlinkShouldTerminate")
NSBundle.loadNibNamed_owner_("FileTransferWindow", self)
self.transferSpeed.setStringValue_('')
self.load_transfers_from_history()
def userQuit(self, user, reason):
data = NotificationData(user=user, reason=reason)
NotificationCenter().post_notification('IRCBotUserQuit', self.factory, data)
def start(self):
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
download_folder = unicodedata.normalize(
'NFC',
NSSearchPathForDirectoriesInDomains(NSDownloadsDirectory,
NSUserDomainMask, True)[0])
for name in self.filename_generator(
os.path.join(download_folder, self.file_name)):
if not os.path.exists(name) and not os.path.exists(name +
".download"):
self.file_path = name + '.download'
break
self.ft_info = FileTransferInfo(
transfer_id=self.transfer_id,
direction='incoming',
local_uri=format_identity_to_string(self.account)
if self.account is not BonjourAccount() else 'bonjour',
file_size=self.file_size,
remote_uri=self.remote_identity,
file_path=self.file_path)
BlinkLogger().log_info(u"Will write file to %s" % self.file_path)
self.file_selector.fd = open(self.file_path, "w+")
self.ft_info.status = "preparing"
self.status = "Accepting File Transfer..."
notification_center.add_observer(self, sender=self)
notification_center.add_observer(self, sender=self.session)
notification_center.add_observer(self, sender=self.stream)
BlinkLogger().log_info("Initiating Incoming File Transfer")
notification_center.post_notification(
"BlinkFileTransferInitializing",
self,
data=TimestampedNotificationData())
notification_center.post_notification(
"BlinkFileTransferInitiated",
self,
data=TimestampedNotificationData())
def userRenamed(self, oldname, newname):
data = NotificationData(oldname=oldname, newname=newname)
NotificationCenter().post_notification('IRCBotUserRenamed', self.factory, data)
def stop(self):
notification_center = NotificationCenter()
notification_center.remove_observer(self,
name='NetworkConditionsDidChange')
self._select_proc.kill()
self._command_channel.send_exception(api.GreenletExit)
def initialize(self, session, direction):
self.greenlet = api.getcurrent()
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=self)
try:
self.session = session
self.transport = self.session.account.msrp.transport
outgoing = direction == 'outgoing'
logger = NotificationProxyLogger()
if self.session.account is BonjourAccount():
if outgoing:
self.msrp_connector = DirectConnector(logger=logger)
self.local_role = 'active'
else:
if self.transport == 'tls' and None in (
self.session.account.tls_credentials.cert,
self.session.account.tls_credentials.key):
raise MSRPStreamError(
"Cannot accept MSRP connection without a TLS certificate"
)
self.msrp_connector = DirectAcceptor(logger=logger)
self.local_role = 'passive'
else:
if self.session.account.msrp.connection_model == 'relay':
if not outgoing and self.remote_role in ('actpass',
'passive'):
# 'passive' not allowed by the RFC but play nice for interoperability. -Saul
self.msrp_connector = DirectConnector(
logger=logger, use_sessmatch=True)
self.local_role = 'active'
elif outgoing and not self.session.account.nat_traversal.use_msrp_relay_for_outbound:
self.msrp_connector = DirectConnector(
logger=logger, use_sessmatch=True)
self.local_role = 'active'
else:
if self.session.account.nat_traversal.msrp_relay is None:
relay_host = relay_port = None
else:
if self.transport != self.session.account.nat_traversal.msrp_relay.transport:
raise MSRPStreamError(
"MSRP relay transport conflicts with MSRP transport setting"
)
relay_host = self.session.account.nat_traversal.msrp_relay.host
relay_port = self.session.account.nat_traversal.msrp_relay.port
relay = MSRPRelaySettings(
domain=self.session.account.uri.host.decode(),
username=self.session.account.uri.user.decode(),
password=self.session.account.credentials.password.
decode(),
host=relay_host,
port=relay_port,
use_tls=self.transport == 'tls')
self.msrp_connector = RelayConnection(
relay,
'passive',
logger=logger,
use_sessmatch=True)
self.local_role = 'actpass' if outgoing else 'passive'
else:
if not outgoing and self.remote_role in ('actpass',
'passive'):
# 'passive' not allowed by the RFC but play nice for interoperability. -Saul
self.msrp_connector = DirectConnector(
logger=logger, use_sessmatch=True)
self.local_role = 'active'
else:
if not outgoing and self.transport == 'tls' and None in (
self.session.account.tls_credentials.cert,
self.session.account.tls_credentials.key):
raise MSRPStreamError(
"Cannot accept MSRP connection without a TLS certificate"
)
self.msrp_connector = DirectAcceptor(
logger=logger, use_sessmatch=True)
self.local_role = 'actpass' if outgoing else 'passive'
full_local_path = self.msrp_connector.prepare(local_uri=URI(
host=host.default_ip,
port=0,
use_tls=self.transport == 'tls',
credentials=self.session.account.tls_credentials))
self.local_media = self._create_local_media(full_local_path)
except (CertificateError, CertificateAuthorityError,
CertificateExpiredError, CertificateSecurityError,
CertificateRevokedError) as e:
reason = "%s for %s" % (e.error, e.certificate.subject.CN.lower())
notification_center.post_notification(
'MediaStreamDidNotInitialize',
sender=self,
data=NotificationData(reason=reason))
except Exception as e:
notification_center.post_notification(
'MediaStreamDidNotInitialize',
sender=self,
data=NotificationData(reason=str(e)))
else:
notification_center.post_notification('MediaStreamDidInitialize',
sender=self)
finally:
self._initialize_done = True
self.greenlet = None
def _browse_cb(self, file, flags, interface_index, error_code,
service_name, regtype, reply_domain):
notification_center = NotificationCenter()
file = BonjourDiscoveryFile.find_by_file(file)
service_description = BonjourServiceDescription(
service_name, regtype, reply_domain)
if error_code != _bonjour.kDNSServiceErr_NoError:
error = _bonjour.BonjourError(error_code)
notification_center.post_notification(
'BonjourAccountDiscoveryDidFail',
sender=self.account,
data=NotificationData(reason=str(error),
transport=file.transport))
removed_files = [file] + [
f for f in self._files if isinstance(f, BonjourResolutionFile)
and f.discovery_file == file
]
for f in removed_files:
self._files.remove(f)
self._select_proc.kill(RestartSelect)
for f in removed_files:
f.close()
if self._discover_timer is None:
self._discover_timer = reactor.callLater(
1, self._command_channel.send, Command('discover'))
return
if reply_domain != 'local.':
return
if flags & _bonjour.kDNSServiceFlagsAdd:
try:
resolution_file = next(
(f for f in self._files
if isinstance(f, BonjourResolutionFile)
and f.discovery_file == file
and f.service_description == service_description))
except StopIteration:
try:
resolution_file = _bonjour.DNSServiceResolve(
0, interface_index, service_name, regtype,
reply_domain, self._resolve_cb)
except _bonjour.BonjourError as e:
notification_center.post_notification(
'BonjourAccountDiscoveryFailure',
sender=self.account,
data=NotificationData(error=str(e),
transport=file.transport))
else:
resolution_file = BonjourResolutionFile(
resolution_file,
discovery_file=file,
service_description=service_description)
self._files.append(resolution_file)
self._select_proc.kill(RestartSelect)
else:
try:
resolution_file = next(
(f for f in self._files
if isinstance(f, BonjourResolutionFile)
and f.discovery_file == file
and f.service_description == service_description))
except StopIteration:
pass
else:
self._files.remove(resolution_file)
self._select_proc.kill(RestartSelect)
resolution_file.close()
service_description = resolution_file.service_description
if service_description in self._neighbours:
record = self._neighbours.pop(service_description)
notification_center.post_notification(
'BonjourAccountDidRemoveNeighbour',
sender=self.account,
data=NotificationData(neighbour=service_description,
record=record))
def initiate_file_transfer(self):
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=self)
self.file_selector = FileSelector.for_file(
self.file_path.encode('utf-8'), hash=None)
self.ft_info.file_size = self.file_size
# compute the file hash first
self.ft_info.status = "preparing"
self.status = "Computing checksum..."
hash = hashlib.sha1()
pos = progress = 0
chunk_size = limit(self.file_selector.size / 100,
min=65536,
max=1048576)
notification_center.post_notification(
'BlinkFileTransferHashUpdate',
sender=self,
data=TimestampedNotificationData(progress=0))
while not self.stop_event.isSet():
content = self.file_selector.fd.read(chunk_size)
if not content:
break
hash.update(content)
pos += len(content)
old_progress, progress = progress, int(
float(pos) / self.file_selector.size * 100)
if old_progress != progress:
notification_center.post_notification(
'BlinkFileTransferHashUpdate',
sender=self,
data=TimestampedNotificationData(progress=progress))
else:
notification_center.post_notification(
'BlinkFileTransferDidNotComputeHash', sender=self)
return
self.file_selector.fd.seek(0)
self.file_selector.hash = hash
notification_center.post_notification(
'BlinkFileTransferDidComputeHash',
sender=self,
data=TimestampedNotificationData())
def start(self):
notification_center = NotificationCenter()
notification_center.add_observer(self,
name='NetworkConditionsDidChange')
self._select_proc = proc.spawn(self._process_files)
proc.spawn(self._handle_commands)
def start(self):
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
download_folder = unicodedata.normalize(
'NFC',
NSSearchPathForDirectoriesInDomains(NSDownloadsDirectory,
NSUserDomainMask, True)[0])
for name in self.filename_generator(
os.path.join(download_folder, self.file_name)):
if not os.path.exists(name) and not os.path.exists(name +
".download"):
self.file_path = name + '.download'
break
BlinkLogger().log_info(u"File will be written to %s" % self.file_path)
self.file_selector.fd = open(self.file_path, "w+")
self.ft_info = FileTransferInfo(
transfer_id=self.transfer_id,
direction='incoming',
local_uri=format_identity_to_string(self.account)
if self.account is not BonjourAccount() else 'bonjour',
file_size=self.file_size,
remote_uri=self.remote_identity,
file_path=self.file_path)
BlinkLogger().log_info("Pull File Transfer Request started %s" %
self.file_path)
self.stream = FileTransferStream(self.account, self.file_selector,
'recvonly')
self.session = Session(self.account)
notification_center.add_observer(self, sender=self)
notification_center.add_observer(self, sender=self.session)
notification_center.add_observer(self, sender=self.stream)
self.status = "Requesting File..."
self.ft_info.status = "requesting"
BlinkLogger().log_info(u"Initiating DNS Lookup of %s to %s" %
(self.account, self.target_uri))
lookup = DNSLookup()
notification_center.add_observer(self, sender=lookup)
if isinstance(self.account,
Account) and self.account.sip.outbound_proxy is not None:
uri = SIPURI(host=self.account.sip.outbound_proxy.host,
port=self.account.sip.outbound_proxy.port,
parameters={
'transport':
self.account.sip.outbound_proxy.transport
})
BlinkLogger().log_info(
u"Initiating DNS Lookup for SIP routes of %s (through proxy %s)"
% (self.target_uri, uri))
elif isinstance(self.account,
Account) and self.account.sip.always_use_my_proxy:
uri = SIPURI(host=self.account.id.domain)
BlinkLogger().log_info(
u"Initiating DNS Lookup for SIP routes of %s (through account %s proxy)"
% (self.target_uri, self.account.id))
else:
uri = self.target_uri
BlinkLogger().log_info(
u"Initiating DNS Lookup for SIP routes of %s" %
self.target_uri)
notification_center.post_notification(
"BlinkFileTransferInitializing",
self,
data=TimestampedNotificationData())
notification_center.post_notification(
"BlinkFileTransferInitiated",
self,
data=TimestampedNotificationData())
lookup.lookup_sip_proxy(uri, settings.sip.transport_list)
def stop(self):
notification_center = NotificationCenter()
notification_center.remove_observer(self, name='SIPAccountWillActivate')
notification_center.remove_observer(self, name='SIPAccountWillDeactivate')
notification_center.remove_observer(self, name='SIPAccountDidDiscoverXCAPSupport')
notification_center.remove_observer(self, name='XCAPManagerDidReloadData')
notification_center.remove_observer(self, sender=BlinkSettings(), name='CFGSettingsObjectDidChange')
def stop(self):
notification_center = NotificationCenter()
notification_center.remove_observer(self, sender=self.xmpp_manager)
notification_center.add_observer(self, name='JingleSessionNewIncoming')
self.xmpp_manager.stop()
def __init__(self, parent=None):
super(AccountModel, self).__init__(parent)
self.accounts = []
notification_center = NotificationCenter()
notification_center.add_observer(self, name='CFGSettingsObjectDidChange')
notification_center.add_observer(self, name='SIPAccountWillRegister')
notification_center.add_observer(self, name='SIPAccountRegistrationDidSucceed')
notification_center.add_observer(self, name='SIPAccountRegistrationDidFail')
notification_center.add_observer(self, name='SIPAccountRegistrationDidEnd')
notification_center.add_observer(self, name='BonjourAccountWillRegister')
notification_center.add_observer(self, name='BonjourAccountRegistrationDidSucceed')
notification_center.add_observer(self, name='BonjourAccountRegistrationDidFail')
notification_center.add_observer(self, name='BonjourAccountRegistrationDidEnd')
notification_center.add_observer(self, sender=AccountManager())
