def __init__(self):
from sipsimple.application import SIPApplication
if SIPApplication.storage is None:
raise RuntimeError(
"Cannot access the OTR cache before SIPApplication.storage is defined"
)
if ISIPSimpleApplicationDataStorage.providedBy(SIPApplication.storage):
self.key_file = os.path.join(SIPApplication.storage.directory,
'otr.key')
self.trusted_file = os.path.join(SIPApplication.storage.directory,
'otr.trusted')
try:
self.private_key = DSAPrivateKey.load(self.key_file)
if self.private_key.key_size != 1024:
raise ValueError
except (EnvironmentError, ValueError):
self.private_key = DSAPrivateKey.generate()
self.private_key.save(self.key_file)
try:
self.trusted_peers = pickle.load(open(self.trusted_file, 'rb'))
if not isinstance(self.trusted_peers,
OTRTrustedPeerSet) or not all(
isinstance(item, OTRTrustedPeer)
for item in self.trusted_peers):
raise ValueError("invalid OTR trusted peers file")
except Exception:
self.trusted_peers = OTRTrustedPeerSet()
self.save()
else:
self.key_file = self.trusted_file = None
self.private_key = DSAPrivateKey.generate()
self.trusted_peers = OTRTrustedPeerSet()
def __init__(self):
from sipsimple.application import SIPApplication
if SIPApplication.storage is None:
raise RuntimeError("Cannot access the OTR cache before SIPApplication.storage is defined")
if ISIPSimpleApplicationDataStorage.providedBy(SIPApplication.storage):
self.key_file = os.path.join(SIPApplication.storage.directory, 'otr.key')
self.trusted_file = os.path.join(SIPApplication.storage.directory, 'otr.trusted')
try:
self.private_key = DSAPrivateKey.load(self.key_file)
if self.private_key.key_size != 1024:
raise ValueError
except (EnvironmentError, ValueError):
self.private_key = DSAPrivateKey.generate()
self.private_key.save(self.key_file)
try:
self.trusted_peers = pickle.load(open(self.trusted_file, 'rb'))
if not isinstance(self.trusted_peers, OTRTrustedPeerSet) or not all(isinstance(item, OTRTrustedPeer) for item in self.trusted_peers):
raise ValueError("invalid OTR trusted peers file")
except Exception:
self.trusted_peers = OTRTrustedPeerSet()
self.save()
else:
self.key_file = self.trusted_file = None
self.private_key = DSAPrivateKey.generate()
self.trusted_peers = OTRTrustedPeerSet()
def _load(self):
if self.loaded:
return
from sipsimple.application import SIPApplication
if ISIPSimpleApplicationDataStorage.providedBy(SIPApplication.storage):
self.directory = SIPApplication.storage.directory
if self.directory is not None:
try:
with open(os.path.join(self.directory, self.__filename__), 'rb') as f:
data = pickle.loads(f.read())
except Exception:
data = {}
now = time.time()
for hash, entry in list(data.items()):
try:
mtime = os.path.getmtime(entry.filename)
except OSError:
data.pop(hash)
else:
if mtime != entry.mtime or now - mtime > self.__lifetime__:
data.pop(hash)
self.data.update(data)
self.loaded = True
def _load(self):
if self.loaded:
return
from sipsimple.application import SIPApplication
if ISIPSimpleApplicationDataStorage.providedBy(SIPApplication.storage):
self.directory = SIPApplication.storage.directory
if self.directory is not None:
try:
with open(os.path.join(self.directory, self.__filename__), 'rb') as f:
data = pickle.loads(f.read())
except Exception:
data = {}
now = time.time()
for hash, entry in data.items():
try:
mtime = os.path.getmtime(entry.filename)
except OSError:
data.pop(hash)
else:
if mtime != entry.mtime or now - mtime > self.__lifetime__:
data.pop(hash)
self.data.update(data)
self.loaded = True
def _initialize_subsystems(self):
notification_center = NotificationCenter()
with self._lock:
stop_pending = self._stop_pending
if stop_pending:
self.state = 'stopping'
if stop_pending:
notification_center.post_notification('SIPApplicationWillEnd',
sender=self)
# stop the subsystems we already started: threads, engine and reactor
self.engine.stop()
self.engine.join(timeout=5)
thread_manager = ThreadManager()
thread_manager.stop()
reactor.stop()
return
account_manager = AccountManager()
addressbook_manager = AddressbookManager()
dns_manager = DNSManager()
session_manager = SessionManager()
settings = SIPSimpleSettings()
xcap_client.DEFAULT_HEADERS = {'User-Agent': settings.user_agent}
# initialize TLS
self._initialize_tls()
# initialize PJSIP internal resolver
self.engine.set_nameservers(dns_manager.nameservers)
# initialize audio objects
alert_device = settings.audio.alert_device
if alert_device not in (
None, 'system_default'
) and alert_device not in self.engine.output_devices:
alert_device = 'system_default'
input_device = settings.audio.input_device
if input_device not in (
None, 'system_default'
) and input_device not in self.engine.input_devices:
input_device = 'system_default'
output_device = settings.audio.output_device
if output_device not in (
None, 'system_default'
) and output_device not in self.engine.output_devices:
output_device = 'system_default'
tail_length = settings.audio.echo_canceller.tail_length if settings.audio.echo_canceller.enabled else 0
voice_mixer = AudioMixer(input_device, output_device,
settings.audio.sample_rate, tail_length)
voice_mixer.muted = settings.audio.muted
self.voice_audio_device = AudioDevice(voice_mixer)
self.voice_audio_bridge = RootAudioBridge(voice_mixer)
self.voice_audio_bridge.add(self.voice_audio_device)
alert_mixer = AudioMixer(None, alert_device,
settings.audio.sample_rate, 0)
if settings.audio.silent:
alert_mixer.output_volume = 0
self.alert_audio_device = AudioDevice(alert_mixer)
self.alert_audio_bridge = RootAudioBridge(alert_mixer)
self.alert_audio_bridge.add(self.alert_audio_device)
settings.audio.input_device = voice_mixer.input_device
settings.audio.output_device = voice_mixer.output_device
settings.audio.alert_device = alert_mixer.output_device
# initialize video
self.video_device = VideoDevice(settings.video.device,
settings.video.resolution,
settings.video.framerate)
self.video_device.muted = settings.video.muted
settings.video.device = self.video_device.name
self.engine.set_video_options(settings.video.resolution,
settings.video.framerate,
settings.video.max_bitrate)
self.engine.set_h264_options(settings.video.h264.profile,
settings.video.h264.level)
# initialize instance id
if not settings.instance_id:
settings.instance_id = uuid4().urn
# initialize path for ZRTP cache file
if ISIPSimpleApplicationDataStorage.providedBy(self.storage):
self.engine.zrtp_cache = os.path.join(self.storage.directory,
'zrtp.db')
# save settings in case something was modified during startup
settings.save()
# initialize middleware components
dns_manager.start()
account_manager.start()
addressbook_manager.start()
session_manager.start()
notification_center.add_observer(self,
name='CFGSettingsObjectDidChange')
notification_center.add_observer(self, name='DNSNameserversDidChange')
notification_center.add_observer(self, name='SystemIPAddressDidChange')
notification_center.add_observer(self, name='SystemDidWakeUpFromSleep')
with self._lock:
self.state = 'started'
stop_pending = self._stop_pending
notification_center.post_notification('SIPApplicationDidStart',
sender=self)
if stop_pending:
self.stop()
