diff --git a/conference.ini.sample b/conference.ini.sample
index 02b8842..278a1cf 100644
--- a/conference.ini.sample
+++ b/conference.ini.sample
@@ -1,69 +1,48 @@
 ; SylkServer Conference application configuration file
 
 [Conference]
 
 ; Replay last chat messages after joining a room
 ; history_size = 20
 
 ; Directory for storing files transferred to rooms (a subdirectory for each
 ; room will be created)
 file_transfer_dir = /var/spool/sylkserver
 
 ; File transfer push support. If enabled files will be pushed to all active
 ; participants after receiving the file
 ; push_file_transfer = False
 
+; Directory where images used by the Screen Sharing functionality will be stored
+screensharing_images_dir = /var/spool/sylkserver/conference/screensharing
+
 ; Advertise XMPP support in conference URIs and welcome (text) message
 ; advertise_xmpp_support = True
 
 ; Comma separated list of PSTN numbers to advertise as a conference URI
 ; pstn_access_numbers =
 
 ; Automatically verify ZRTP endpoints if the following conditions are met:
 ;  - The session also has a chat stream with no relay in between
 ;  - A MSRP message of type application/blink-zrtp-sas is received with the
 ;    remote SAS
 ;  - The remote and the local SAS match
 ; If this setting is set to True, SylkServer will send the ZRTP SAS to the
 ; connected endpoints via a private chat message
 ; zrtp_auto_verify = True
 
 ; Access Lists Default Policy
 ; Apache-style access lists for the caller using SIP domains or SIP URIs
 ; https://httpd.apache.org/docs/2.2/mod/mod_authz_host.html#order
 ;
 ; access_policy = allow, deny
 ; allow = all
 ; deny = none
 
 ; Access Lists can be applied per room overriding the Default Policy
 ;
 ; [test@domain.com]
 ; access_policy = allow, deny
 ; allow = example.com, test@domain.com
 ; deny = all
 
-
-[ScreenSharing]
-
-; Directory where images used by the Screen Sharing functionality will be stored
-directory = /var/spool/sylkserver/screensharing
-
-; IP address used for serving Screen Sharing HTTP requests, empty string
-; means listen on interface used by the default route
-; local_ip =
-
-; Port where Screen Sharing HTTP server will listen on, set to 0 for random
-; local_port = 0
-
-; X.509 server certificate for HTTPS connections, the certificate private
-; key must be concatenated inside the same file, set to empty in order to
-; disable HTTPS
-; certificate = /etc/sylkserver/tls/default.crt
-
-; Hostname published in conference-info payload. Must match the common name
-; of server X.509 certificate set above, otherwise clients will raise
-; warning. If not set the listening IP address will be used
-; hostname =
-
-
diff --git a/sylk/applications/conference/__init__.py b/sylk/applications/conference/__init__.py
index 842352e..c54128d 100644
--- a/sylk/applications/conference/__init__.py
+++ b/sylk/applications/conference/__init__.py
@@ -1,422 +1,414 @@
 # Copyright (C) 2010-2011 AG Projects. See LICENSE for details
 #
 
 import os
 import re
 import shutil
 
 from application.notification import IObserver, NotificationCenter
 from application.python import Null
-from gnutls.interfaces.twisted import X509Credentials
 from sipsimple.account.bonjour import BonjourPresenceState
 from sipsimple.configuration.settings import SIPSimpleSettings
 from sipsimple.core import SIPURI, SIPCoreError
 from sipsimple.core import Header, FromHeader, ToHeader, SubjectHeader
 from sipsimple.lookup import DNSLookup
 from sipsimple.streams import MediaStreamRegistry
 from sipsimple.threading.green import run_in_green_thread
 from twisted.internet import reactor
 from zope.interface import implements
 
 from sylk.accounts import DefaultAccount
 from sylk.applications import SylkApplication
-from sylk.applications.conference.configuration import get_room_config, ConferenceConfig, ScreenSharingConfig
+from sylk.applications.conference.configuration import get_room_config, ConferenceConfig
 from sylk.applications.conference.logger import log
 from sylk.applications.conference.room import Room
-from sylk.applications.conference.web import ScreenSharingWebServer
+from sylk.applications.conference.web import ConferenceWeb
 from sylk.bonjour import BonjourService
 from sylk.configuration import ServerConfig, ThorNodeConfig
 from sylk.session import Session, IllegalStateError
-from sylk.tls import Certificate, PrivateKey
+from sylk.web import server as web_server
 
 
 class ACLValidationError(Exception): pass
 
 class RoomNotFoundError(Exception): pass
 
 
 class ConferenceApplication(SylkApplication):
     implements(IObserver)
 
     def __init__(self):
         self._rooms = {}
         self.invited_participants_map = {}
         self.bonjour_focus_service = Null
         self.bonjour_room_service = Null
-        self.screen_sharing_web_server = None
+        self.web = Null
 
     def start(self):
+        self.web = ConferenceWeb(self)
+        web_server.register_resource('conference', self.web.resource())
+
         # cleanup old files
-        for path in (ConferenceConfig.file_transfer_dir, ScreenSharingConfig.directory):
+        for path in (ConferenceConfig.file_transfer_dir, ConferenceConfig.screensharing_images_dir):
             try:
                 shutil.rmtree(path)
             except EnvironmentError:
                 pass
 
         if ServerConfig.enable_bonjour and ServerConfig.default_application == 'conference':
             self.bonjour_focus_service = BonjourService(service='sipfocus')
             self.bonjour_focus_service.start()
             log.msg("Bonjour publication started for service 'sipfocus'")
             self.bonjour_room_service = BonjourService(service='sipuri', name='Conference Room', uri_user='conference')
             self.bonjour_room_service.start()
             self.bonjour_room_service.presence_state = BonjourPresenceState('available', u'No participants')
             log.msg("Bonjour publication started for service 'sipuri'")
-        self.screen_sharing_web_server = ScreenSharingWebServer(ScreenSharingConfig.directory)
-        if os.path.isfile(ScreenSharingConfig.certificate):
-            cert = Certificate(ScreenSharingConfig.certificate.normalized)
-            key = PrivateKey(ScreenSharingConfig.certificate.normalized)
-            credentials = X509Credentials(cert, key)
-        else:
-            credentials = None
-        self.screen_sharing_web_server.start(ScreenSharingConfig.local_ip, ScreenSharingConfig.local_port, credentials)
-        log.msg("ScreenSharing listener started on %s" % self.screen_sharing_web_server.url)
 
     def stop(self):
         self.bonjour_focus_service.stop()
         self.bonjour_room_service.stop()
-        self.screen_sharing_web_server.stop()
 
     def get_room(self, uri, create=False):
         room_uri = '%s@%s' % (uri.user, uri.host)
         try:
             room = self._rooms[room_uri]
         except KeyError:
             if create:
                 room = Room(room_uri)
                 self._rooms[room_uri] = room
                 return room
             else:
                 raise RoomNotFoundError
         else:
             return room
 
     def remove_room(self, uri):
         room_uri = '%s@%s' % (uri.user, uri.host)
         self._rooms.pop(room_uri, None)
 
     def validate_acl(self, room_uri, from_uri):
         room_uri = '%s@%s' % (room_uri.user, room_uri.host)
         cfg = get_room_config(room_uri)
         if cfg.access_policy == 'allow,deny':
             if cfg.allow.match(from_uri) and not cfg.deny.match(from_uri):
                 return
             raise ACLValidationError
         else:
             if cfg.deny.match(from_uri) and not cfg.allow.match(from_uri):
                 raise ACLValidationError
 
     def incoming_session(self, session):
         log.msg('New session from %s to %s' % (session.remote_identity.uri, session.local_identity.uri))
         audio_streams = [stream for stream in session.proposed_streams if stream.type=='audio']
         chat_streams = [stream for stream in session.proposed_streams if stream.type=='chat']
         transfer_streams = [stream for stream in session.proposed_streams if stream.type=='file-transfer']
         if not audio_streams and not chat_streams and not transfer_streams:
             log.msg(u'Session rejected: invalid media, only RTP audio and MSRP chat are supported')
             session.reject(488)
             return
         audio_stream = audio_streams[0] if audio_streams else None
         chat_stream = chat_streams[0] if chat_streams else None
         transfer_stream = transfer_streams[0] if transfer_streams else None
 
         try:
             self.validate_acl(session.request_uri, session.remote_identity.uri)
         except ACLValidationError:
             log.msg(u'Session rejected: unauthorized by access list')
             session.reject(403)
             return
 
         if transfer_stream is not None:
             try:
                 room = self.get_room(session.request_uri)
             except RoomNotFoundError:
                 log.msg(u'Session rejected: room not found')
                 session.reject(404)
                 return
             if transfer_stream.direction == 'sendonly':
                 # file transfer 'pull'
                 try:
                     file = next(file for file in room.files if file.hash == transfer_stream.file_selector.hash)
                 except StopIteration:
                     log.msg(u'Session rejected: requested file not found')
                     session.reject(404)
                     return
                 try:
                     transfer_stream.file_selector = file.file_selector
                 except EnvironmentError, e:
                     log.msg(u'Session rejected: error opening requested file: %s' % e)
                     session.reject(404)
                     return
             else:
                 transfer_stream.handler.save_directory = os.path.join(ConferenceConfig.file_transfer_dir.normalized, room.uri)
 
         NotificationCenter().add_observer(self, sender=session)
         if audio_stream:
             session.send_ring_indication()
         streams = [stream for stream in (audio_stream, chat_stream, transfer_stream) if stream]
         reactor.callLater(4 if audio_stream is not None else 0, self.accept_session, session, streams)
 
     def incoming_subscription(self, subscribe_request, data):
         from_header = data.headers.get('From', Null)
         to_header = data.headers.get('To', Null)
         if Null in (from_header, to_header):
             subscribe_request.reject(400)
             return
 
         if subscribe_request.event != 'conference':
             log.msg(u'Subscription rejected: only conference event is supported')
             subscribe_request.reject(489)
             return
 
         try:
             self.validate_acl(data.request_uri, from_header.uri)
         except ACLValidationError:
             try:
                 self.validate_acl(to_header.uri, from_header.uri)
             except ACLValidationError:
                 # Check if we need to skip the ACL because this was an invited participant
                 if not (str(from_header.uri) in self.invited_participants_map.get('%s@%s' % (data.request_uri.user, data.request_uri.host), {}) or
                         str(from_header.uri) in self.invited_participants_map.get('%s@%s' % (to_header.uri.user, to_header.uri.host), {})):
                     log.msg(u'Subscription rejected: unauthorized by access list')
                     subscribe_request.reject(403)
                     return
         try:
             room = self.get_room(data.request_uri)
         except RoomNotFoundError:
             try:
                 room = self.get_room(to_header.uri)
             except RoomNotFoundError:
                 log.msg(u'Subscription rejected: room not yet created')
                 subscribe_request.reject(480)
                 return
         if not room.started:
             log.msg(u'Subscription rejected: room not started yet')
             subscribe_request.reject(480)
         else:
             room.handle_incoming_subscription(subscribe_request, data)
 
     def incoming_referral(self, refer_request, data):
         from_header = data.headers.get('From', Null)
         to_header = data.headers.get('To', Null)
         refer_to_header = data.headers.get('Refer-To', Null)
         if Null in (from_header, to_header, refer_to_header):
             refer_request.reject(400)
             return
 
         log.msg(u'Room %s - join request from %s to %s' % ('%s@%s' % (to_header.uri.user, to_header.uri.host), from_header.uri, refer_to_header.uri))
 
         try:
             self.validate_acl(data.request_uri, from_header.uri)
         except ACLValidationError:
             log.msg(u'Room %s - invite participant request rejected: unauthorized by access list' % data.request_uri)
             refer_request.reject(403)
             return
         referral_handler = IncomingReferralHandler(refer_request, data)
         referral_handler.start()
 
     def incoming_message(self, message_request, data):
         log.msg(u'SIP MESSAGE is not supported, use MSRP media instead')
         message_request.answer(405)
 
     def accept_session(self, session, streams):
         if session.state == 'incoming':
             try:
                 session.accept(streams, is_focus=True)
             except IllegalStateError:
                 pass
 
     def add_participant(self, session, room_uri):
         # Keep track of the invited participants, we must skip ACL policy
         # for SUBSCRIBE requests
         room_uri_str = '%s@%s' % (room_uri.user, room_uri.host)
         log.msg(u'Room %s - outgoing session to %s started' % (room_uri_str, session.remote_identity.uri))
         d = self.invited_participants_map.setdefault(room_uri_str, {})
         d.setdefault(str(session.remote_identity.uri), 0)
         d[str(session.remote_identity.uri)] += 1
         NotificationCenter().add_observer(self, sender=session)
         room = self.get_room(room_uri, True)
         room.start()
         room.add_session(session)
 
     def remove_participant(self, participant_uri, room_uri):
         try:
             room = self.get_room(room_uri)
         except RoomNotFoundError:
             pass
         else:
             log.msg('Room %s - %s removed from conference' % (room_uri, participant_uri))
             room.terminate_sessions(participant_uri)
 
     def handle_notification(self, notification):
         handler = getattr(self, '_NH_%s' % notification.name, Null)
         handler(notification)
 
     def _NH_SIPSessionDidStart(self, notification):
         session = notification.sender
         room = self.get_room(session.request_uri, True)
         room.start()
         room.add_session(session)
 
     @run_in_green_thread
     def _NH_SIPSessionDidEnd(self, notification):
         session = notification.sender
         notification.center.remove_observer(self, sender=session)
         if session.direction == 'incoming':
             room_uri = session.request_uri
         else:
             # Clear invited participants mapping
             room_uri_str = '%s@%s' % (session.local_identity.uri.user, session.local_identity.uri.host)
             d = self.invited_participants_map[room_uri_str]
             d[str(session.remote_identity.uri)] -= 1
             if d[str(session.remote_identity.uri)] == 0:
                 del d[str(session.remote_identity.uri)]
             room_uri = session.local_identity.uri
         # We could get this notifiction even if we didn't get SIPSessionDidStart
         try:
             room = self.get_room(room_uri)
         except RoomNotFoundError:
             return
         if session in room.sessions:
             room.remove_session(session)
         if not room.stopping and room.empty:
             self.remove_room(room_uri)
             room.stop()
 
     def _NH_SIPSessionDidFail(self, notification):
         session = notification.sender
         notification.center.remove_observer(self, sender=session)
         log.msg(u'Session from %s failed: %s' % (session.remote_identity.uri, notification.data.reason))
 
 
 class IncomingReferralHandler(object):
     implements(IObserver)
 
     def __init__(self, refer_request, data):
         self._refer_request = refer_request
         self._refer_headers = data.headers
         self.room_uri = data.request_uri
         self.room_uri_str = '%s@%s' % (self.room_uri.user, self.room_uri.host)
         self.refer_to_uri = re.sub('<|>', '', data.headers.get('Refer-To').uri)
         self.method = data.headers.get('Refer-To').parameters.get('method', 'INVITE').upper()
         self.session = None
         self.streams = []
 
     def start(self):
         if not self.refer_to_uri.startswith(('sip:', 'sips:')):
             self.refer_to_uri = 'sip:%s' % self.refer_to_uri
         try:
             self.refer_to_uri = SIPURI.parse(self.refer_to_uri)
         except SIPCoreError:
             log.msg('Room %s - failed to add %s' % (self.room_uri_str, self.refer_to_uri))
             self._refer_request.reject(488)
             return
         notification_center = NotificationCenter()
         notification_center.add_observer(self, sender=self._refer_request)
         if self.method == 'INVITE':
             self._refer_request.accept()
             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 = self.refer_to_uri
             lookup = DNSLookup()
             notification_center.add_observer(self, sender=lookup)
             lookup.lookup_sip_proxy(uri, settings.sip.transport_list)
         elif self.method == 'BYE':
             log.msg('Room %s - %s removed %s from the room' % (self.room_uri_str, self._refer_headers.get('From').uri, self.refer_to_uri))
             self._refer_request.accept()
             conference_application = ConferenceApplication()
             conference_application.remove_participant(self.refer_to_uri, self.room_uri)
             self._refer_request.end(200)
         else:
             self._refer_request.reject(488)
 
     def handle_notification(self, notification):
         handler = getattr(self, '_NH_%s' % notification.name, Null)
         handler(notification)
 
     def _NH_DNSLookupDidSucceed(self, notification):
         notification_center = NotificationCenter()
         notification_center.remove_observer(self, sender=notification.sender)
         account = DefaultAccount()
         conference_application = ConferenceApplication()
         try:
             room = conference_application.get_room(self.room_uri)
         except RoomNotFoundError:
             log.msg('Room %s - failed to add %s' % (self.room_uri_str, self.refer_to_uri))
             self._refer_request.end(500)
             return
         active_media = set(room.active_media).intersection(('audio', 'chat'))
         if not active_media:
             log.msg('Room %s - failed to add %s' % (self.room_uri_str, self.refer_to_uri))
             self._refer_request.end(500)
             return
         registry = MediaStreamRegistry()
         for stream_type in active_media:
             self.streams.append(registry.get(stream_type)())
         self.session = Session(account)
         notification_center.add_observer(self, sender=self.session)
         original_from_header = self._refer_headers.get('From')
         if original_from_header.display_name:
             original_identity = "%s <%s@%s>" % (original_from_header.display_name, original_from_header.uri.user, original_from_header.uri.host)
         else:
             original_identity = "%s@%s" % (original_from_header.uri.user, original_from_header.uri.host)
         from_header = FromHeader(SIPURI.new(self.room_uri), u'Conference Call')
         to_header = ToHeader(self.refer_to_uri)
         extra_headers = []
         if self._refer_headers.get('Referred-By', None) is not None:
             extra_headers.append(Header.new(self._refer_headers.get('Referred-By')))
         else:
             extra_headers.append(Header('Referred-By', str(original_from_header.uri)))
         if ThorNodeConfig.enabled:
             extra_headers.append(Header('Thor-Scope', 'conference-invitation'))
         extra_headers.append(Header('X-Originator-From', str(original_from_header.uri)))
         extra_headers.append(SubjectHeader(u'Join conference request from %s' % original_identity))
         route = notification.data.result[0]
         self.session.connect(from_header, to_header, route=route, streams=self.streams, is_focus=True, extra_headers=extra_headers)
 
     def _NH_DNSLookupDidFail(self, notification):
         notification.center.remove_observer(self, sender=notification.sender)
 
     def _NH_SIPSessionGotRingIndication(self, notification):
         if self._refer_request is not None:
             self._refer_request.send_notify(180)
 
     def _NH_SIPSessionGotProvisionalResponse(self, notification):
         if self._refer_request is not None:
             self._refer_request.send_notify(notification.data.code, notification.data.reason)
 
     def _NH_SIPSessionDidStart(self, notification):
         notification.center.remove_observer(self, sender=notification.sender)
         if self._refer_request is not None:
             self._refer_request.end(200)
         conference_application = ConferenceApplication()
         conference_application.add_participant(self.session, self.room_uri)
         log.msg('Room %s - %s added %s' % (self.room_uri_str, self._refer_headers.get('From').uri, self.refer_to_uri))
         self.session = None
         self.streams = []
 
     def _NH_SIPSessionDidFail(self, notification):
         log.msg('Room %s - failed to add %s: %s' % (self.room_uri_str, self.refer_to_uri, notification.data.reason))
         notification.center.remove_observer(self, sender=notification.sender)
         if self._refer_request is not None:
             self._refer_request.end(notification.data.code or 500, notification.data.reason or  notification.data.code)
         self.session = None
         self.streams = []
 
     def _NH_SIPSessionDidEnd(self, notification):
         # If any stream fails to start we won't get SIPSessionDidFail, we'll get here instead
         log.msg('Room %s - failed to add %s' % (self.room_uri_str, self.refer_to_uri))
         notification.center.remove_observer(self, sender=notification.sender)
         if self._refer_request is not None:
             self._refer_request.end(200)
         self.session = None
         self.streams = []
 
     def _NH_SIPIncomingReferralDidEnd(self, notification):
         notification.center.remove_observer(self, sender=notification.sender)
         self._refer_request = None
 
 
diff --git a/sylk/applications/conference/configuration.py b/sylk/applications/conference/configuration.py
index c1006dc..454c032 100644
--- a/sylk/applications/conference/configuration.py
+++ b/sylk/applications/conference/configuration.py
@@ -1,142 +1,131 @@
 # Copyright (C) 2010-2011 AG Projects. See LICENSE for details.
 #
 
 __all__ = ['ConferenceConfig', 'get_room_config']
 
 import os
 import re
 
 from application.configuration import ConfigFile, ConfigSection, ConfigSetting
-from application.configuration.datatypes import StringList, Hostname
-from application.system import host
+from application.configuration.datatypes import StringList
 
 from sylk.configuration import ServerConfig
-from sylk.configuration.datatypes import IPAddress, Path, Port
-from sylk.resources import Resources
+from sylk.configuration.datatypes import Path
 
 
 # Datatypes
 
 class AccessPolicyValue(str):
     allowed_values = ('allow,deny', 'deny,allow')
 
     def __new__(cls, value):
         value = re.sub('\s', '', value)
         if value not in cls.allowed_values:
             raise ValueError('invalid value, allowed values are: %s' % ' | '.join(cls.allowed_values))
         return str.__new__(cls, value)
 
 
 class Domain(str):
     domain_re = re.compile(r"^[a-zA-Z0-9\-_]+(\.[a-zA-Z0-9\-_]+)*$")
 
     def __new__(cls, value):
         value = str(value)
         if not cls.domain_re.match(value):
             raise ValueError("illegal domain: %s" % value)
         return str.__new__(cls, value)
 
 
 class SIPAddress(str):
     def __new__(cls, address):
         address = str(address)
         address = address.replace('@', '%40', address.count('@')-1)
         try:
             username, domain = address.split('@')
             Domain(domain)
         except ValueError:
             raise ValueError("illegal SIP address: %s, must be in user@domain format" % address)
         return str.__new__(cls, address)
 
 
 class PolicySettingValue(list):
     def __init__(self, value):
         if isinstance(value, (tuple, list)):
             l = [str(x) for x in value]
         elif isinstance(value, basestring):
             if value.lower() in ('none', ''):
                 return list.__init__(self, [])
             elif value.lower() in ('any', 'all', '*'):
                 return list.__init__(self, ['*'])
             else:
                 l = re.split(r'\s*,\s*', value)
         else:
             raise TypeError("value must be a string, list or tuple")
         values = []
         for item in l:
             if '@' in item:
                 values.append(SIPAddress(item))
             else:
                 values.append(Domain(item))
         return list.__init__(self, values)
 
     def match(self, uri):
         if self == ['*']:
             return True
         domain = uri.host
         uri = re.sub('^(sip:|sips:)', '', str(uri))
         return uri in self or domain in self
 
 
 # Configuration objects
 
 class ConferenceConfig(ConfigSection):
     __cfgfile__ = 'conference.ini'
     __section__ = 'Conference'
 
     history_size = 20
 
     access_policy = ConfigSetting(type=AccessPolicyValue, value=AccessPolicyValue('allow, deny'))
     allow = ConfigSetting(type=PolicySettingValue, value=PolicySettingValue('all'))
     deny = ConfigSetting(type=PolicySettingValue, value=PolicySettingValue('none'))
 
     file_transfer_dir = ConfigSetting(type=Path, value=Path(os.path.join(ServerConfig.spool_dir.normalized, 'conference', 'files')))
     push_file_transfer = False
 
+    screensharing_images_dir = ConfigSetting(type=Path, value=Path(os.path.join(ServerConfig.spool_dir.normalized, 'conference', 'screensharing')))
+
     advertise_xmpp_support = True
     pstn_access_numbers = ConfigSetting(type=StringList, value='')
 
     zrtp_auto_verify = True
 
 
-class ScreenSharingConfig(ConfigSection):
-    __cfgfile__ = 'conference.ini'
-    __section__ = 'ScreenSharing'
-
-    directory = ConfigSetting(type=Path, value=Path(os.path.join(ServerConfig.spool_dir.normalized, 'conference', 'screensharing')))
-    local_ip = ConfigSetting(type=IPAddress, value=IPAddress(host.default_ip))
-    local_port = ConfigSetting(type=Port, value=0)
-    hostname = ConfigSetting(type=Hostname, value=IPAddress(host.default_ip))
-    certificate = ConfigSetting(type=Path, value=Path(Resources.get('tls/default.crt')))
-
-
 class RoomConfig(ConfigSection):
     __cfgfile__ = 'conference.ini'
 
     access_policy = ConfigSetting(type=AccessPolicyValue, value=AccessPolicyValue('allow, deny'))
     allow = ConfigSetting(type=PolicySettingValue, value=PolicySettingValue('all'))
     deny = ConfigSetting(type=PolicySettingValue, value=PolicySettingValue('none'))
 
     pstn_access_numbers = ConferenceConfig.pstn_access_numbers
     advertise_xmpp_support = ConferenceConfig.advertise_xmpp_support
 
     zrtp_auto_verify = ConferenceConfig.zrtp_auto_verify
 
 
 class Configuration(object):
     def __init__(self, data):
         self.__dict__.update(data)
 
 
 def get_room_config(room):
     config_file = ConfigFile(RoomConfig.__cfgfile__)
     section = config_file.get_section(room)
     if section is not None:
         RoomConfig.read(section=room)
         config = Configuration(dict(RoomConfig))
         RoomConfig.reset()
     else:
         # Apply general policy
         config = Configuration(dict(RoomConfig))
     return config
 
diff --git a/sylk/applications/conference/room.py b/sylk/applications/conference/room.py
index 5b24f5f..d6d2b61 100644
--- a/sylk/applications/conference/room.py
+++ b/sylk/applications/conference/room.py
@@ -1,1075 +1,1075 @@
 # Copyright (C) 2010-2011 AG Projects. See LICENSE for details.
 #
 
 import os
 import random
 import shutil
 import string
 import weakref
 
 from collections import defaultdict, deque
 from glob import glob
 from itertools import chain, count, cycle
 
 from application.notification import IObserver, NotificationCenter
 from application.python import Null
 from application.system import makedirs
 from eventlib import api, coros, proc
 from sipsimple.account.bonjour import BonjourPresenceState
 from sipsimple.application import SIPApplication
 from sipsimple.audio import AudioConference, WavePlayer, WavePlayerError
 from sipsimple.configuration.settings import SIPSimpleSettings
 from sipsimple.core import SIPCoreError, SIPCoreInvalidStateError, SIPURI
 from sipsimple.core import Header, FromHeader, ToHeader, SubjectHeader
 from sipsimple.lookup import DNSLookup, DNSLookupError
 from sipsimple.payloads import conference
 from sipsimple.streams import MediaStreamRegistry
 from sipsimple.streams.applications.chat import CPIMIdentity, CPIMHeader, Namespace
 from sipsimple.streams.msrp import FileSelector
 from sipsimple.threading import run_in_thread, run_in_twisted_thread
 from sipsimple.threading.green import run_in_green_thread
 from sipsimple.util import ISOTimestamp
 from twisted.internet import reactor
 from zope.interface import implements
 
 from sylk.accounts import DefaultAccount
-from sylk.applications.conference.configuration import get_room_config, ConferenceConfig, ScreenSharingConfig
+from sylk.applications.conference.configuration import get_room_config, ConferenceConfig
 from sylk.applications.conference.logger import log
 from sylk.bonjour import BonjourService
 from sylk.configuration import ServerConfig, ThorNodeConfig
 from sylk.configuration.datatypes import URL
 from sylk.resources import Resources
 from sylk.session import Session, IllegalStateError
+from sylk.web import server as web_server
 
 
 def format_identity(identity):
     uri = identity.uri
     if identity.display_name:
         return u'%s <%s@%s>' % (identity.display_name, uri.user, uri.host)
     else:
         return u'%s@%s' % (uri.user, uri.host)
 
 
 class ScreenImage(object):
     def __init__(self, room, sender):
         self.room = weakref.ref(room)
         self.room_uri = room.uri
         self.sender = sender
-        self.filename = os.path.join(ScreenSharingConfig.directory, room.uri, '%s@%s_%s.jpg' % (sender.uri.user, sender.uri.host, ''.join(random.sample(string.letters+string.digits, 10))))
-        from sylk.applications.conference import ConferenceApplication
-        self.url = URL(ConferenceApplication().screen_sharing_web_server.url)
-        self.url.query_items['image'] = os.path.join(room.uri, os.path.basename(self.filename))
+        self.filename = os.path.join(ConferenceConfig.screensharing_images_dir, room.uri, '%s@%s_%s.jpg' % (sender.uri.user, sender.uri.host, ''.join(random.sample(string.letters+string.digits, 10))))
+        self.url = URL(web_server.url + '/conference/' + room.uri + '/screensharing')
+        self.url.query_items['image'] = os.path.basename(self.filename)
         self.state = None
         self.timer = None
 
     @property
     def active(self):
         return self.state == 'active'
 
     @property
     def idle(self):
         return self.state == 'idle'
 
     @run_in_thread('file-io')
     def save(self, image):
         makedirs(os.path.dirname(self.filename))
         tmp_filename = self.filename + '.tmp'
         try:
             with open(tmp_filename, 'wb') as file:
                 file.write(image)
         except EnvironmentError, e:
             log.msg('Room %s - cannot write screen sharing image: %s: %s' % (self.room_uri, self.filename, e))
         else:
             try:
                 os.rename(tmp_filename, self.filename)
             except EnvironmentError:
                 pass
             self.advertise()
 
     @run_in_twisted_thread
     def advertise(self):
         if self.state == 'active':
             self.timer.reset(10)
         else:
             if self.timer is not None and self.timer.active():
                 self.timer.cancel()
             self.state = 'active'
             self.timer = reactor.callLater(10, self.stop_advertising)
             room = self.room() or Null
             room.dispatch_conference_info()
             txt = 'Room %s - %s is sharing the screen at %s' % (self.room_uri, format_identity(self.sender), self.url)
             room.dispatch_server_message(txt)
             log.msg(txt)
 
     @run_in_twisted_thread
     def stop_advertising(self):
         if self.state != 'idle':
             if self.timer is not None and self.timer.active():
                 self.timer.cancel()
             self.state = 'idle'
             self.timer = None
             room = self.room() or Null
             room.dispatch_conference_info()
             txt = '%s stopped sharing the screen' % format_identity(self.sender)
             room.dispatch_server_message(txt)
             log.msg(txt)
 
 
 class Room(object):
     """
     Object representing a conference room, it will handle the message dispatching
     among all the participants.
     """
     implements(IObserver)
 
     def __init__(self, uri):
         self.config = get_room_config(uri)
         self.uri = uri
         self.identity = CPIMIdentity(SIPURI.parse('sip:%s' % self.uri), display_name='Conference Room')
         self.files = []
         self.screen_images = {}
         self.sessions = []
         self.subscriptions = []
         self.state = 'stopped'
         self.incoming_message_queue = coros.queue()
         self.message_dispatcher = None
         self.audio_conference = None
         self.moh_player = None
         self.conference_info_payload = None
         self.conference_info_version = count(1)
         self.bonjour_services = Null
         self.session_nickname_map = {}
         self.last_nicknames_map = {}
         self.participants_counter = defaultdict(lambda: 0)
         self.history = deque(maxlen=ConferenceConfig.history_size)
 
     @property
     def empty(self):
         return len(self.sessions) == 0
 
     @property
     def started(self):
         return self.state == 'started'
 
     @property
     def stopping(self):
         return self.state in ('stopping', 'stopped')
 
     @property
     def active_media(self):
         return set((stream.type for stream in chain(*(session.streams for session in self.sessions if session.streams))))
 
     @property
     def conference_info(self):
         if self.conference_info_payload is None:
             settings = SIPSimpleSettings()
             conference_description = conference.ConferenceDescription(display_text='Ad-hoc conference', free_text='Hosted by %s' % settings.user_agent)
             conference_description.conf_uris = conference.ConfUris()
             conference_description.conf_uris.add(conference.ConfUrisEntry('sip:%s' % self.uri, purpose='participation'))
             if self.config.advertise_xmpp_support:
                 conference_description.conf_uris.add(conference.ConfUrisEntry('xmpp:%s' % self.uri, purpose='participation'))
                 # TODO: add grouptextchat service uri
             for number in self.config.pstn_access_numbers:
                 conference_description.conf_uris.add(conference.ConfUrisEntry('tel:%s' % number, purpose='participation'))
             host_info = conference.HostInfo(web_page=conference.WebPage('http://sylkserver.com'))
             self.conference_info_payload = conference.Conference(self.identity.uri, conference_description=conference_description, host_info=host_info, users=conference.Users())
         self.conference_info_payload.version = next(self.conference_info_version)
         user_count = len(self.participants_counter.keys())
         self.conference_info_payload.conference_state = conference.ConferenceState(user_count=user_count, active=True)
         users = conference.Users()
         for session in (session for session in self.sessions if not (len(session.streams) == 1 and session.streams[0].type == 'file-transfer')):
             try:
                 user = next(user for user in users if user.entity == str(session.remote_identity.uri))
             except StopIteration:
                 display_text = self.last_nicknames_map.get(str(session.remote_identity.uri), session.remote_identity.display_name)
                 user = conference.User(str(session.remote_identity.uri), display_text=display_text)
                 user_uri = '%s@%s' % (session.remote_identity.uri.user, session.remote_identity.uri.host)
                 screen_image = self.screen_images.get(user_uri, None)
                 if screen_image is not None and screen_image.active:
                     user.screen_image_url = screen_image.url
                 users.add(user)
             joining_info = conference.JoiningInfo(when=session.start_time)
             holdable_streams = [stream for stream in session.streams if stream.hold_supported]
             session_on_hold = holdable_streams and all(stream.on_hold_by_remote for stream in holdable_streams)
             hold_status = conference.EndpointStatus('on-hold' if session_on_hold else 'connected')
             display_text = self.session_nickname_map.get(session, session.remote_identity.display_name)
             endpoint = conference.Endpoint(str(session._invitation.remote_contact_header.uri), display_text=display_text, joining_info=joining_info, status=hold_status)
             for stream in session.streams:
                 if stream.type == 'file-transfer':
                     continue
                 endpoint.add(conference.Media(id(stream), media_type=self.format_conference_stream_type(stream)))
             user.add(endpoint)
         self.conference_info_payload.users = users
         if self.files:
             files = conference.FileResources(conference.FileResource(os.path.basename(file.name), file.hash, file.size, file.sender, 'OK') for file in self.files)
             self.conference_info_payload.conference_description.resources = conference.Resources(files=files)
         return self.conference_info_payload.toxml()
 
     def start(self):
         if self.started:
             return
         if ServerConfig.enable_bonjour and self.identity.uri.user != 'conference':
             room_user = self.identity.uri.user
             self.bonjour_services = BonjourService(service='sipuri', name='Conference Room %s' % room_user, uri_user=room_user)
             self.bonjour_services.start()
         self.message_dispatcher = proc.spawn(self._message_dispatcher)
         self.audio_conference = AudioConference()
         self.audio_conference.hold()
         self.moh_player = MoHPlayer(self.audio_conference)
         self.moh_player.start()
         self.state = 'started'
 
     def stop(self):
         if not self.started:
             return
         self.state = 'stopping'
         self.bonjour_services.stop()
         self.bonjour_services = None
         self.incoming_message_queue.send_exception(api.GreenletExit)
         self.incoming_message_queue = None
         self.message_dispatcher.kill(proc.ProcExit)
         self.message_dispatcher = None
         self.moh_player.stop()
         self.moh_player = None
         self.audio_conference = None
         notification_center = NotificationCenter()
         for subscription in self.subscriptions:
             notification_center.remove_observer(self, sender=subscription)
             subscription.end()
         self.subscriptions = []
         self.cleanup_files()
         self.conference_info_payload = None
         self.state = 'stopped'
 
     @run_in_thread('file-io')
     def cleanup_files(self):
         path = os.path.join(ConferenceConfig.file_transfer_dir, self.uri)
         try:
             shutil.rmtree(path)
         except EnvironmentError:
             pass
-        path = os.path.join(ScreenSharingConfig.directory, self.uri)
+        path = os.path.join(ConferenceConfig.screensharing_images_dir, self.uri)
         try:
             shutil.rmtree(path)
         except EnvironmentError:
             pass
 
     def _message_dispatcher(self):
         """Read from self.incoming_message_queue and dispatch the messages to other participants"""
         while True:
             session, message_type, data = self.incoming_message_queue.wait()
             if message_type == 'message':
                 message = data.message
                 if message.sender.uri != session.remote_identity.uri:
                     continue
                 if message.body.startswith('?OTR:'):
                     continue
                 if message.timestamp is None:
                     message.timestamp = ISOTimestamp.utcnow()
                 message.sender.display_name = self.last_nicknames_map.get(str(session.remote_identity.uri), message.sender.display_name)
                 recipient = message.recipients[0]
                 private = len(message.recipients) == 1 and '%s@%s' % (recipient.uri.user, recipient.uri.host) != self.uri
                 if private:
                     self.dispatch_private_message(session, message)
                 else:
                     self.history.append(message)
                     self.dispatch_message(session, message)
             elif message_type == 'composing_indication':
                 if data.sender.uri != session.remote_identity.uri:
                     continue
                 recipient = data.recipients[0]
                 private = len(data.recipients) == 1 and '%s@%s' % (recipient.uri.user, recipient.uri.host) != self.uri
                 if private:
                     self.dispatch_private_iscomposing(session, data)
                 else:
                     self.dispatch_iscomposing(session, data)
 
     def dispatch_message(self, session, message):
         for s in (s for s in self.sessions if s is not session):
             try:
                 chat_stream = next(stream for stream in s.streams if stream.type == 'chat')
             except StopIteration:
                 continue
             chat_stream.send_message(message.body, message.content_type, sender=message.sender, recipients=[self.identity], timestamp=message.timestamp, additional_headers=message.additional_headers)
 
     def dispatch_private_message(self, session, message):
         # Private messages are delivered to all sessions matching the recipient but also to the sender,
         # for replication in clients
         recipient = message.recipients[0]
         for s in (s for s in self.sessions if s is not session and s.remote_identity.uri in (recipient.uri, session.remote_identity.uri)):
             try:
                 chat_stream = next(stream for stream in s.streams if stream.type == 'chat')
             except StopIteration:
                 continue
             chat_stream.send_message(message.body, message.content_type, sender=message.sender, recipients=[recipient], timestamp=message.timestamp, additional_headers=message.additional_headers)
 
     def dispatch_iscomposing(self, session, data):
         for s in (s for s in self.sessions if s is not session):
             try:
                 chat_stream = next(stream for stream in s.streams if stream.type == 'chat')
             except StopIteration:
                 continue
             identity = CPIMIdentity(session.remote_identity.uri, session.remote_identity.display_name)
             chat_stream.send_composing_indication(data.state, data.refresh, sender=identity, recipients=[self.identity])
 
     def dispatch_private_iscomposing(self, session, data):
         recipient_uri = data.recipients[0].uri
         for s in (s for s in self.sessions if s is not session and s.remote_identity.uri == recipient_uri):
             try:
                 chat_stream = next(stream for stream in s.streams if stream.type == 'chat')
             except StopIteration:
                 continue
             identity = CPIMIdentity(session.remote_identity.uri, session.remote_identity.display_name)
             chat_stream.send_composing_indication(data.state, data.refresh, sender=identity)
 
     def dispatch_server_message(self, body, content_type='text/plain', exclude=None):
         for session in (session for session in self.sessions if session is not exclude):
             try:
                 chat_stream = next(stream for stream in session.streams if stream.type == 'chat')
             except StopIteration:
                 continue
             ns = Namespace('urn:ag-projects:xml:ns:cpim', prefix='agp')
             message_type = CPIMHeader('Message-Type', ns, 'status')
             chat_stream.send_message(body, content_type, sender=self.identity, recipients=[self.identity], additional_headers=[message_type])
 
     def dispatch_conference_info(self):
         data = self.conference_info
         for subscription in (subscription for subscription in self.subscriptions if subscription.state == 'active'):
             try:
                 subscription.push_content(conference.ConferenceDocument.content_type, data)
             except (SIPCoreError, SIPCoreInvalidStateError):
                 pass
 
     def dispatch_file(self, file):
         sender_uri = file.sender.uri
         for uri in set(session.remote_identity.uri for session in self.sessions if str(session.remote_identity.uri) != str(sender_uri)):
             handler = FileTransferHandler(self)
             handler.init_outgoing(uri, file)
 
     def add_session(self, session):
         notification_center = NotificationCenter()
         notification_center.add_observer(self, sender=session)
         self.sessions.append(session)
         remote_uri = str(session.remote_identity.uri)
         self.participants_counter[remote_uri] += 1
         try:
             chat_stream = next(stream for stream in session.streams if stream.type == 'chat')
         except StopIteration:
             pass
         else:
             notification_center.add_observer(self, sender=chat_stream)
         try:
             audio_stream = next(stream for stream in session.streams if stream.type == 'audio')
         except StopIteration:
             pass
         else:
             notification_center.add_observer(self, sender=audio_stream)
             log.msg(u'Room %s - audio stream %s/%sHz, end-points: %s:%d <-> %s:%d' % (self.uri, audio_stream.codec, audio_stream.sample_rate,
                                                                                       audio_stream.local_rtp_address, audio_stream.local_rtp_port,
                                                                                       audio_stream.remote_rtp_address, audio_stream.remote_rtp_port))
             if audio_stream.encryption.type != 'ZRTP':
                 # We don't listen for stream notifications early enough
                 if audio_stream.encryption.active:
                     log.msg(u'Room %s - %s audio stream enabled %s encryption' % (self.uri,
                                                                                   format_identity(session.remote_identity),
                                                                                   audio_stream.encryption.type))
                 else:
                     log.msg(u'Room %s - %s audio stream did not enable encryption' % (self.uri,
                                                                                       format_identity(session.remote_identity)))
         try:
             transfer_stream = next(stream for stream in session.streams if stream.type == 'file-transfer')
         except StopIteration:
             pass
         else:
             transfer_handler = FileTransferHandler(self)
             transfer_handler.init_incoming(transfer_stream)
             if transfer_stream.direction == 'recvonly':
                 filename = os.path.basename(os.path.splitext(transfer_stream.file_selector.name)[0])
                 txt = u'Room %s - %s is uploading file %s (%s)' % (self.uri, format_identity(session.remote_identity), filename,self.format_file_size(transfer_stream.file_selector.size))
             else:
                 filename = os.path.basename(transfer_stream.file_selector.name)
                 txt = u'Room %s - %s requested file %s' % (self.uri, format_identity(session.remote_identity), filename)
             log.msg(txt)
             self.dispatch_server_message(txt)
             if len(session.streams) == 1:
                 return
 
         welcome_handler = WelcomeHandler(self, initial=True, session=session, streams=session.streams)
         welcome_handler.run()
         self.dispatch_conference_info()
 
         if len(self.sessions) == 1:
             log.msg(u'Room %s - started by %s with %s' % (self.uri, format_identity(session.remote_identity), self.format_stream_types(session.streams)))
         else:
             log.msg(u'Room %s - %s joined with %s' % (self.uri, format_identity(session.remote_identity), self.format_stream_types(session.streams)))
         if str(session.remote_identity.uri) not in set(str(s.remote_identity.uri) for s in self.sessions if s is not session):
             self.dispatch_server_message('%s has joined the room %s' % (format_identity(session.remote_identity), self.format_stream_types(session.streams)), exclude=session)
 
         if ServerConfig.enable_bonjour:
             self._update_bonjour_presence()
 
     def remove_session(self, session):
         notification_center = NotificationCenter()
         notification_center.remove_observer(self, sender=session)
         self.sessions.remove(session)
         self.session_nickname_map.pop(session, None)
         remote_uri = str(session.remote_identity.uri)
         self.participants_counter[remote_uri] -= 1
         if self.participants_counter[remote_uri] <= 0:
             del self.participants_counter[remote_uri]
             self.last_nicknames_map.pop(remote_uri, None)
         try:
             chat_stream = next(stream for stream in session.streams or [] if stream.type == 'chat')
         except StopIteration:
             pass
         else:
             notification_center.remove_observer(self, sender=chat_stream)
         try:
             audio_stream = next(stream for stream in session.streams or [] if stream.type == 'audio')
         except StopIteration:
             pass
         else:
             notification_center.remove_observer(self, sender=audio_stream)
             try:
                 self.audio_conference.remove(audio_stream)
             except ValueError:
                 # User may hangup before getting bridged into the conference
                 pass
             if len(self.audio_conference.streams) == 0:
                 self.moh_player.pause()
                 self.audio_conference.hold()
             elif len(self.audio_conference.streams) == 1:
                 self.moh_player.play()
         try:
             next(stream for stream in session.streams if stream.type == 'file-transfer')
         except StopIteration:
             pass
         else:
             if len(session.streams) == 1:
                 return
 
         self.dispatch_conference_info()
         log.msg(u'Room %s - %s left conference after %s' % (self.uri, format_identity(session.remote_identity), self.format_session_duration(session)))
         if not self.sessions:
             log.msg(u'Room %s - Last participant left conference' % self.uri)
         if str(session.remote_identity.uri) not in set(str(s.remote_identity.uri) for s in self.sessions if s is not session):
             self.dispatch_server_message('%s has left the room after %s' % (format_identity(session.remote_identity), self.format_session_duration(session)))
 
         if ServerConfig.enable_bonjour:
             self._update_bonjour_presence()
 
     def terminate_sessions(self, uri):
         if not self.started:
             return
         for session in (session for session in self.sessions if session.remote_identity.uri == uri):
             session.end()
 
     def handle_incoming_subscription(self, subscribe_request, data):
         log.msg('Room %s - subscription from %s' % (self.uri, data.headers['From'].uri))
         if subscribe_request.event != 'conference':
             log.msg('Room %s - Subscription rejected: only conference event is supported' % self.uri)
             subscribe_request.reject(489)
             return
         NotificationCenter().add_observer(self, sender=subscribe_request)
         self.subscriptions.append(subscribe_request)
         subscribe_request.accept(conference.ConferenceDocument.content_type, self.conference_info)
 
     def _accept_proposal(self, session, streams):
         try:
             session.accept_proposal(streams)
         except IllegalStateError:
             pass
         session.proposal_timer = None
 
     def add_file(self, file):
         self.dispatch_server_message('%s has uploaded file %s (%s)' % (format_identity(file.sender), os.path.basename(file.name), self.format_file_size(file.size)))
         self.files.append(file)
         self.dispatch_conference_info()
         if ConferenceConfig.push_file_transfer:
             self.dispatch_file(file)
 
     def add_screen_image(self, sender, image):
         sender_uri = '%s@%s' % (sender.uri.user, sender.uri.host)
         screen_image = self.screen_images.setdefault(sender_uri, ScreenImage(self, sender))
         screen_image.save(image)
 
     def _update_bonjour_presence(self):
         num = len(self.sessions)
         if num == 0:
             num_str = 'No'
         elif num == 1:
             num_str = 'One'
         elif num == 2:
             num_str = 'Two'
         else:
             num_str = str(num)
         txt = u'%s participant%s' % (num_str, '' if num==1 else 's')
         presence_state = BonjourPresenceState('available', txt)
         if self.bonjour_services is Null:
             # This is the room being published all the time
             from sylk.applications.conference import ConferenceApplication
             ConferenceApplication().bonjour_room_service.presence_state = presence_state
         else:
             self.bonjour_services.presence_state = presence_state
 
     @run_in_twisted_thread
     def handle_notification(self, notification):
         handler = getattr(self, '_NH_%s' % notification.name, Null)
         handler(notification)
 
     def _NH_RTPStreamDidEnableEncryption(self, notification):
         stream = notification.sender
         session = stream.session
         log.msg(u'Room %s - %s %s stream enabled %s encryption' % (self.uri,
                                                                    format_identity(session.remote_identity),
                                                                    stream.type,
                                                                    stream.encryption.type))
 
     def _NH_RTPStreamDidNotEnableEncryption(self, notification):
         stream = notification.sender
         session = stream.session
         log.msg(u'Room %s - %s %s stream did not enable encryption: %s' % (self.uri,
                                                                            format_identity(session.remote_identity),
                                                                            stream.type,
                                                                            notification.data.reason))
 
     def _NH_RTPStreamZRTPReceivedSAS(self, notification):
         if not self.config.zrtp_auto_verify:
             return
 
         stream = notification.sender
         session = stream.session
         sas = notification.data.sas
         # Send ZRTP SAS over the chat stream, if available
         try:
             chat_stream = next(stream for stream in session.streams if stream.type=='chat')
         except StopIteration:
             return
         # Only send the message if there are no relays in between
         secure_chat = chat_stream.transport == 'tls' and all(len(path)==1 for path in (chat_stream.msrp.full_local_path, chat_stream.msrp.full_remote_path))
         if secure_chat:
             txt = 'Received ZRTP Short Authentication String: %s' % sas
             # Don't set the remote identity, that way it will appear as a private message
             ns = Namespace('urn:ag-projects:xml:ns:cpim', prefix='agp')
             message_type = CPIMHeader('Message-Type', ns, 'status')
             chat_stream.send_message(txt, 'text/plain', sender=self.identity, additional_headers=[message_type])
 
     def _NH_RTPStreamDidTimeout(self, notification):
         stream = notification.sender
         if stream.type != 'audio':
             return
         session = stream.session
         log.msg(u'Room %s - audio stream for session %s timed out' % (self.uri, format_identity(session.remote_identity)))
         if session.streams == [stream]:
             session.end()
 
     def _NH_ChatStreamGotMessage(self, notification):
         stream = notification.sender
         data = notification.data
         session = notification.sender.session
         message = data.message
         content_type = message.content_type.lower()
         if content_type.startswith(('text/', 'image/')):
             stream.msrp_session.send_report(notification.data.chunk, 200, 'OK')
             self.incoming_message_queue.send((session, 'message', data))
         elif content_type == 'application/blink-screensharing':
             stream.msrp_session.send_report(notification.data.chunk, 200, 'OK')
             self.add_screen_image(message.sender, message.body)
         elif content_type == 'application/blink-zrtp-sas':
             if not self.config.zrtp_auto_verify:
                 stream.msrp_session.send_report(notification.data.chunk, 413, 'Unwanted message')
                 return
             try:
                 audio_stream = next(stream for stream in session.streams if stream.type=='audio' and stream.encryption.active and stream.encryption.type=='ZRTP')
             except StopIteration:
                 stream.msrp_session.send_report(notification.data.chunk, 413, 'Unwanted message')
                 return
             # Only trust it if there was a direct path and the transport is TLS
             secure_chat = stream.transport == 'tls' and all(len(path)==1 for path in (stream.msrp.full_local_path, stream.msrp.full_remote_path))
             remote_sas = str(message.body)
             if remote_sas == audio_stream.encryption.zrtp.sas and secure_chat:
                 audio_stream.encryption.zrtp.verified = True
                 stream.msrp_session.send_report(notification.data.chunk, 200, 'OK')
             else:
                 stream.msrp_session.send_report(notification.data.chunk, 413, 'Unwanted message')
         else:
             stream.msrp_session.send_report(notification.data.chunk, 413, 'Unwanted message')
 
     def _NH_ChatStreamGotComposingIndication(self, notification):
         stream = notification.sender
         stream.msrp_session.send_report(notification.data.chunk, 200, 'OK')
         data = notification.data
         session = notification.sender.session
         self.incoming_message_queue.send((session, 'composing_indication', data))
 
     def _NH_ChatStreamGotNicknameRequest(self, notification):
         nickname = notification.data.nickname
         session = notification.sender.session
         chunk = notification.data.chunk
         if nickname:
             if nickname in self.session_nickname_map.values() and (session not in self.session_nickname_map or self.session_nickname_map[session] != nickname):
                 notification.sender.reject_nickname(chunk, 425, 'Nickname reserved or already in use')
                 return
             self.session_nickname_map[session] = nickname
             self.last_nicknames_map[str(session.remote_identity.uri)] = nickname
         else:
             self.session_nickname_map.pop(session, None)
             self.last_nicknames_map.pop(str(session.remote_identity.uri), None)
         notification.sender.accept_nickname(chunk)
         self.dispatch_conference_info()
 
     def _NH_SIPIncomingSubscriptionDidEnd(self, notification):
         subscription = notification.sender
         try:
             self.subscriptions.remove(subscription)
         except ValueError:
             pass
         else:
             notification.center.remove_observer(self, sender=subscription)
 
     def _NH_SIPSessionDidChangeHoldState(self, notification):
         session = notification.sender
         if notification.data.originator == 'remote':
             if notification.data.on_hold:
                 log.msg(u'Room %s - %s has put the audio session on hold' % (self.uri, format_identity(session.remote_identity)))
             else:
                 log.msg(u'Room %s - %s has taken the audio session out of hold' % (self.uri, format_identity(session.remote_identity)))
             self.dispatch_conference_info()
 
     def _NH_SIPSessionNewProposal(self, notification):
         if notification.data.originator == 'remote':
             session = notification.sender
             audio_streams = [stream for stream in notification.data.proposed_streams if stream.type=='audio']
             chat_streams = [stream for stream in notification.data.proposed_streams if stream.type=='chat']
             if not audio_streams and not chat_streams:
                 session.reject_proposal()
                 return
             streams = [streams[0] for streams in (audio_streams, chat_streams) if streams]
             timer = reactor.callLater(3, self._accept_proposal, session, streams)
             old_timer = getattr(session, 'proposal_timer', None)
             assert old_timer is None
             session.proposal_timer = timer
 
     def _NH_SIPSessionProposalRejected(self, notification):
         if notification.data.originator == 'remote':
             session = notification.sender
             timer = getattr(session, 'proposal_timer', None)
             if timer is not None:
                 timer.cancel()
             session.proposal_timer = None
 
     def _NH_SIPSessionHadProposalFailure(self, notification):
         if notification.data.originator == 'remote':
             session = notification.sender
             timer = getattr(session, 'proposal_timer', None)
             assert timer is not None
             timer.cancel()
             session.proposal_timer = None
 
     def _NH_SIPSessionDidRenegotiateStreams(self, notification):
         session = notification.sender
         for stream in notification.data.added_streams:
             notification.center.add_observer(self, sender=stream)
             txt = u'%s has added %s' % (format_identity(session.remote_identity), stream.type)
             log.msg(u'Room %s - %s' % (self.uri, txt))
             self.dispatch_server_message(txt, exclude=session)
             if stream.type == 'audio':
                 log.msg(u'Room %s - audio stream %s/%sHz, end-points: %s:%d <-> %s:%d' % (self.uri, stream.codec, stream.sample_rate,
                                                                                           stream.local_rtp_address, stream.local_rtp_port,
                                                                                           stream.remote_rtp_address, stream.remote_rtp_port))
                 if stream.encryption.type != 'ZRTP':
                     # We don't listen for stream notifications early enough
                     if stream.encryption.active:
                         log.msg(u'Room %s - %s %s stream enabled %s encryption' % (self.uri,
                                                                                    format_identity(session.remote_identity),
                                                                                    stream.type,
                                                                                    stream.encryption.type))
                     else:
                         log.msg(u'Room %s - %s %s stream did not enable encryption' % (self.uri,
                                                                                        format_identity(session.remote_identity),
                                                                                        stream.type))
 
         if notification.data.added_streams:
             welcome_handler = WelcomeHandler(self, initial=False, session=session, streams=notification.data.added_streams)
             welcome_handler.run()
 
         for stream in notification.data.removed_streams:
             notification.center.remove_observer(self, sender=stream)
             txt = u'%s has removed %s' % (format_identity(session.remote_identity), stream.type)
             log.msg(u'Room %s - %s' % (self.uri, txt))
             self.dispatch_server_message(txt, exclude=session)
             if stream.type == 'audio':
                 try:
                     self.audio_conference.remove(stream)
                 except ValueError:
                     # User may hangup before getting bridged into the conference
                     pass
                 if len(self.audio_conference.streams) == 0:
                     self.moh_player.pause()
                     self.audio_conference.hold()
                 elif len(self.audio_conference.streams) == 1:
                     self.moh_player.play()
             if not session.streams:
                 log.msg(u'Room %s - %s has removed all streams, session will be terminated' % (self.uri, format_identity(session.remote_identity)))
                 session.end()
         self.dispatch_conference_info()
 
     def _NH_SIPSessionTransferNewIncoming(self, notification):
         log.msg(u'Room %s - Call transfer request rejected, REFER must be out of dialog (RFC4579 5.5)' % self.uri)
         notification.sender.reject_transfer(403)
 
     def _NH_SIPSessionWillEnd(self, notification):
         session = notification.sender
         timer = getattr(session, 'proposal_timer', None)
         if timer is not None and timer.isActive():
             timer.cancel()
         session.proposal_timer = None
 
     @staticmethod
     def format_stream_types(streams):
         if not streams:
             return ''
         if len(streams) == 1:
             txt = 'with %s' % streams[0].type
         else:
             txt = 'with %s' % ','.join(stream.type for stream in streams[:-1])
             txt += ' and %s' % streams[-1:][0].type
         return txt
 
     @staticmethod
     def format_conference_stream_type(stream):
         if stream.type == 'chat':
             return 'message'
         return stream.type
 
     @staticmethod
     def format_session_duration(session):
         if session.start_time:
             duration = session.end_time - session.start_time
             seconds = duration.seconds if duration.microseconds < 500000 else duration.seconds+1
             minutes, seconds = seconds / 60, seconds % 60
             hours, minutes = minutes / 60, minutes % 60
             hours += duration.days*24
             if not minutes and not hours:
                 duration_text = '%d seconds' % seconds
             elif not hours:
                 duration_text = '%02d:%02d' % (minutes, seconds)
             else:
                 duration_text = '%02d:%02d:%02d' % (hours, minutes, seconds)
         else:
             duration_text = '0s'
         return duration_text
 
     @staticmethod
     def format_file_size(size):
         infinite = float('infinity')
         boundaries = [(             1024, '%d bytes',               1),
                         (          10*1024, '%.2f KB',           1024.0),  (     1024*1024, '%.1f KB',           1024.0),
                         (     10*1024*1024, '%.2f MB',      1024*1024.0),  (1024*1024*1024, '%.1f MB',      1024*1024.0),
                         (10*1024*1024*1024, '%.2f GB', 1024*1024*1024.0),  (      infinite, '%.1f GB', 1024*1024*1024.0)]
         for boundary, format, divisor in boundaries:
             if size < boundary:
                 return format % (size/divisor,)
         else:
             return "%d bytes" % size
 
 
 class MoHPlayer(object):
     implements(IObserver)
 
     def __init__(self, conference):
         self.conference = conference
         self.files = None
         self.paused = None
         self._player = None
 
     def start(self):
         files = glob('%s/*.wav' % Resources.get('sounds/moh'))
         if not files:
             log.error(u'No files found, MoH is disabled')
             return
         random.shuffle(files)
         self.files = cycle(files)
         self._player = WavePlayer(SIPApplication.voice_audio_mixer, '', pause_time=1, initial_delay=1, volume=20)
         self.paused = True
         self.conference.bridge.add(self._player)
         NotificationCenter().add_observer(self, sender=self._player)
 
     def stop(self):
         if self._player is None:
             return
         NotificationCenter().remove_observer(self, sender=self._player)
         self._player.stop()
         self.paused = True
         self.conference.bridge.remove(self._player)
         self.conference = None
 
     def play(self):
         if self._player is not None and self.paused:
             self.paused = False
             self._play_next_file()
 
     def pause(self):
         if self._player is not None and not self.paused:
             self.paused = True
             self._player.stop()
 
     def _play_next_file(self):
         self._player.filename = next(self.files)
         self._player.play()
 
     @run_in_twisted_thread
     def handle_notification(self, notification):
         handler = getattr(self, '_NH_%s' % notification.name, Null)
         handler(notification)
 
     def _NH_WavePlayerDidFail(self, notification):
         if not self.paused:
             self._play_next_file()
 
     _NH_WavePlayerDidEnd = _NH_WavePlayerDidFail
 
 
 class WelcomeHandler(object):
     implements(IObserver)
 
     def __init__(self, room, initial, session, streams):
         self.room = room
         self.initial = initial
         self.session = session
         self.streams = streams
         self.procs = proc.RunningProcSet()
 
     @run_in_green_thread
     def run(self):
         notification_center = NotificationCenter()
         notification_center.add_observer(self, sender=self.session)
 
         for stream in self.streams:
             if stream.type == 'audio':
                 self.procs.spawn(self.audio_welcome, stream)
             elif stream.type == 'chat':
                 self.procs.spawn(self.chat_welcome, stream)
         self.procs.waitall()
 
         notification_center.remove_observer(self, sender=self.session)
         self.session = None
         self.streams = None
         self.room = None
         self.procs = None
 
     def play_file_in_player(self, player, file, delay):
         player.filename = file
         player.pause_time = delay
         try:
             player.play().wait()
         except WavePlayerError, e:
             log.warning(u"Error playing file %s: %s" % (file, e))
 
     def audio_welcome(self, stream):
         player = WavePlayer(stream.mixer, '', pause_time=1, initial_delay=1, volume=50)
         stream.bridge.add(player)
         try:
             if self.initial:
                 file = Resources.get('sounds/co_welcome_conference.wav')
                 self.play_file_in_player(player, file, 1)
             user_count = len(set(str(s.remote_identity.uri) for s in self.room.sessions if any(stream for stream in s.streams if stream.type == 'audio')) - set([str(self.session.remote_identity.uri)]))
             if user_count == 0:
                 file = Resources.get('sounds/co_only_one.wav')
                 self.play_file_in_player(player, file, 0.5)
             elif user_count == 1:
                 file = Resources.get('sounds/co_there_is_one.wav')
                 self.play_file_in_player(player, file, 0.5)
             elif user_count < 100:
                 file = Resources.get('sounds/co_there_are.wav')
                 self.play_file_in_player(player, file, 0.2)
                 if user_count <= 24:
                     file = Resources.get('sounds/bi_%d.wav' % user_count)
                     self.play_file_in_player(player, file, 0.1)
                 else:
                     file = Resources.get('sounds/bi_%d0.wav' % (user_count / 10))
                     self.play_file_in_player(player, file, 0.1)
                     file = Resources.get('sounds/bi_%d.wav' % (user_count % 10))
                     self.play_file_in_player(player, file, 0.1)
                 file = Resources.get('sounds/co_more_participants.wav')
                 self.play_file_in_player(player, file, 0)
             file = Resources.get('sounds/connected_tone.wav')
             self.play_file_in_player(player, file, 0.1)
         except proc.ProcExit:
             # No need to remove the bridge from the stream, it's done automatically
             pass
         else:
             stream.bridge.remove(player)
             self.room.audio_conference.add(stream)
             self.room.audio_conference.unhold()
             if len(self.room.audio_conference.streams) == 1:
                 self.room.moh_player.play()
             else:
                 self.room.moh_player.pause()
         finally:
             player.stop()
 
     def chat_welcome(self, stream):
         if self.initial:
             txt = 'Welcome to SylkServer!'
         else:
             txt = ''
         user_count = len(set(str(s.remote_identity.uri) for s in self.room.sessions) - set([str(self.session.remote_identity.uri)]))
         if user_count == 0:
             txt += ' You are the first participant'
         else:
             if user_count == 1:
                 txt += ' There is one more participant'
             else:
                 txt += ' There are %s more participants' % user_count
         txt +=  ' in this conference room.'
         if not ServerConfig.enable_bonjour:
             if self.room.config.advertise_xmpp_support or self.room.config.pstn_access_numbers:
                 txt += '\n\nOther participants can join at these addresses:\n\n'
                 if self.room.config.pstn_access_numbers:
                     if len(self.room.config.pstn_access_numbers) == 1:
                         nums = self.room.config.pstn_access_numbers[0]
                     else:
                         nums = ', '.join(self.room.config.pstn_access_numbers[:-1]) + ' or %s' % self.room.config.pstn_access_numbers[-1]
                     txt += '    - Using a landline or mobile phone, dial %s (audio)\n' % nums
                 if self.room.config.advertise_xmpp_support:
                     txt += '    - Using an XMPP client, connect to group chat room %s (chat)\n' % self.room.uri
                     txt += '    - Using an XMPP Jingle capable client, add contact %s and call it (audio)\n' % self.room.uri
                 txt += '    - Using a SIP client, initiate a session to %s (audio and chat)\n' % self.room.uri
         stream.send_message(txt, 'text/plain', sender=self.room.identity, recipients=[self.room.identity])
         for msg in self.room.history:
             stream.send_message(msg.body, msg.content_type, sender=msg.sender, recipients=[self.room.identity], timestamp=msg.timestamp)
 
         # Send ZRTP SAS over the chat stream, if applicable
         if self.room.config.zrtp_auto_verify:
             session = stream.session
             try:
                 audio_stream = next(stream for stream in session.streams if stream.type=='audio')
             except StopIteration:
                 pass
             else:
                 if audio_stream.encryption.type == 'ZRTP' and audio_stream.encryption.active:
                     # Only send the message if there are no relays in between
                     secure_chat = stream.transport == 'tls' and all(len(path)==1 for path in (stream.msrp.full_local_path, stream.msrp.full_remote_path))
                     sas = audio_stream.encryption.zrtp.sas
                     if sas is not None and secure_chat:
                         txt = 'Received ZRTP Short Authentication String: %s' % sas
                         # Don't set the remote identity, that way it will appear as a private message
                         ns = Namespace('urn:ag-projects:xml:ns:cpim', prefix='agp')
                         message_type = CPIMHeader('Message-Type', ns, 'status')
                         stream.send_message(txt, 'text/plain', sender=self.room.identity, additional_headers=[message_type])
 
     def handle_notification(self, notification):
         handler = getattr(self, '_NH_%s' % notification.name, Null)
         handler(notification)
 
     def _NH_SIPSessionWillEnd(self, notification):
         self.procs.killall()
 
 
 class RoomFile(object):
     def __init__(self, name, hash, size, sender):
         self.name = name
         self.hash = hash
         self.size = size
         self.sender = sender
 
     @property
     def file_selector(self):
         return FileSelector.for_file(self.name, hash=self.hash)
 
 
 class FileTransferHandler(object):
     implements(IObserver)
 
     def __init__(self, room):
         self.room = weakref.ref(room)
         self.session = None
         self.stream = None
         self.handler = None
         self.direction = None
 
     def init_incoming(self, stream):
         self.direction = 'incoming'
         self.stream = stream
         self.session = stream.session
         self.handler = stream.handler
         notification_center = NotificationCenter()
         notification_center.add_observer(self, sender=self.stream)
         notification_center.add_observer(self, sender=self.handler)
 
     @run_in_green_thread
     def init_outgoing(self, destination, file):
         self.direction = 'outgoing'
 
         room = self.room()
         if room is None:
             return
 
         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 = SIPURI.new(destination)
         lookup = DNSLookup()
         try:
             route = lookup.lookup_sip_proxy(uri, settings.sip.transport_list).wait()[0]
         except (DNSLookupError, IndexError):
             return
 
         self.session = Session(account)
         self.stream = MediaStreamRegistry().get('file-transfer')(file.file_selector, 'sendonly')
         self.handler = self.stream.handler
         notification_center = NotificationCenter()
         notification_center.add_observer(self, sender=self.stream)
         notification_center.add_observer(self, sender=self.handler)
 
         from_header = FromHeader(SIPURI.new(room.identity.uri), u'Conference File Transfer')
         to_header = ToHeader(SIPURI.new(destination))
         extra_headers = []
         if ThorNodeConfig.enabled:
             extra_headers.append(Header('Thor-Scope', 'conference-invitation'))
         extra_headers.append(Header('X-Originator-From', str(file.sender.uri)))
         extra_headers.append(SubjectHeader(u'File uploaded by %s' % file.sender))
         self.session.connect(from_header, to_header, route=route, streams=[self.stream], is_focus=True, extra_headers=extra_headers)
 
     def _terminate(self, failure_reason=None):
         notification_center = NotificationCenter()
         notification_center.remove_observer(self, sender=self.stream)
         notification_center.remove_observer(self, sender=self.handler)
 
         room = self.room()
         if room is not None:
             if failure_reason is None:
                 if self.direction == 'incoming' and self.stream.direction == 'recvonly':
                     sender = CPIMIdentity(self.session.remote_identity.uri, self.session.remote_identity.display_name)
                     file = RoomFile(self.stream.file_selector.name, self.stream.file_selector.hash, self.stream.file_selector.size, sender)
                     room.add_file(file)
             else:
                 room.dispatch_server_message('File transfer for %s failed: %s' % (os.path.basename(self.stream.file_selector.name), failure_reason))
 
         self.session = None
         self.stream = None
         self.handler = None
 
     @run_in_twisted_thread
     def handle_notification(self, notification):
         handler = getattr(self, '_NH_%s' % notification.name, Null)
         handler(notification)
 
     def _NH_MediaStreamDidNotInitialize(self, notification):
         self._terminate(failure_reason=notification.data.reason)
 
     def _NH_FileTransferHandlerDidEnd(self, notification):
         if self.direction == 'incoming':
             if self.stream.direction == 'sendonly':
                 reactor.callLater(3, self.session.end)
             else:
                 reactor.callLater(1, self.session.end)
         else:
             self.session.end()
         self._terminate(failure_reason=notification.data.reason)
 
diff --git a/sylk/applications/conference/web.py b/sylk/applications/conference/web.py
index b95b74d..d11b177 100644
--- a/sylk/applications/conference/web.py
+++ b/sylk/applications/conference/web.py
@@ -1,106 +1,85 @@
 # Copyright (C) 2011 AG Projects. See LICENSE for details
 #
 
-__all__ = ['ScreenSharingWebServer']
-
 import os
 import urllib
 
-from twisted.web import server, static, resource
-from twisted.internet import reactor
-
-
-html_template = """
-<html>
-<head>
-    <title>SylkServer Screen Sharing</title>
-</head>
-
-<script type="text/javascript">
-    var today = new Date();
-    var c = today.getTime();
-
-    function reloadScreen()
-    {
-        document.screenImage.src = "%(image)s" + "?" + c;
-        c = c + 1;
-    }
-
-    function startTimer()
-    {
-        setTimeout('reloadScreen()', 1000);
-    }
-</script>
-
-<body bgcolor="#999999">
-    <div>
-        <img src='%(image)s' name='screenImage' onload='startTimer()' style='position: relative; top: 0px; margin: 0px 0px 0px 0px; clear: both; float: left; %(width)s' />
-    </div>
-</body>
-
-</html>
-
-"""
-
-
-class ScreenSharingWebsite(resource.Resource):
-    isLeaf = True
-
-    def __init__(self, path):
-        self.base_path = os.path.realpath(path)
-        resource.Resource.__init__(self)
-
-    def render_GET(self, request):
+from application.python.types import Singleton
+from twisted.web.resource import ErrorPage, NoResource
+from twisted.web.static import File
+
+from sylk.applications.conference.configuration import ConferenceConfig
+from sylk.web import Klein
+
+
+class ConferenceWeb(object):
+    __metaclass__ = Singleton
+
+    app = Klein()
+
+    screensharing_template = """
+        <html>
+        <head>
+            <title>SylkServer Screen Sharing</title>
+        </head>
+        <script type="text/javascript">
+            var today = new Date();
+            var c = today.getTime();
+
+            function reloadScreen() {
+                document.screenImage.src = "%(image)s" + "?" + c;
+                c = c + 1;
+            }
+
+            function startTimer() {
+                setTimeout('reloadScreen()', 1000);
+            }
+        </script>
+        <body bgcolor="#999999">
+            <div>
+                <img src='%(image)s' name='screenImage' onload='startTimer()' style='position: relative; top: 0px; margin: 0px 0px 0px 0px; clear: both; float: left; %(width)s' />
+            </div>
+        </body>
+        </html>
+    """
+
+    def __init__(self, conference):
+        self.conference = conference
+
+    def resource(self):
+        return self.app.resource()
+
+    @app.route('/')
+    def home(self, request):
+        return NoResource('Nothing to see here, move along.')
+
+    @app.route('/<string:room_uri>')
+    def room(self, request, room_uri):
+        return NoResource('Nothing to see here, move along.')
+
+    @app.route('/<string:room_uri>/screensharing')
+    def scheensharing(self, request, room_uri):
+        try:
+            room = self.conference._rooms[room_uri]
+        except KeyError:
+            return NoResource('Room not found')
+        request.setHeader('Content-Type', 'text/html; charset=utf-8')
         if 'image' not in request.args or not request.args.get('image', [''])[0].endswith('jpg'):
-            return "<html><body>Screenshot image not provided</body></html>"
-        image_path = urllib.unquote(request.args['image'][0])
-        if os.path.commonprefix([os.path.realpath(os.path.join(self.base_path, image_path)), self.base_path]) != self.base_path:
-            return "<html><body>Screenshot image is not readable</body></html>"
-        if not os.path.isfile(os.path.join(self.base_path, image_path)):
-            return "<html><body>Screenshot image is not readable</body></html>"
-        image = os.path.join('/img', image_path)
+            return ErrorPage(400, 'Bad Request', '\"image\" not provided')
+        images_path = os.path.join(ConferenceConfig.screensharing_images_dir, room.uri)
+        image_path = os.path.basename(urllib.unquote(request.args['image'][0]))
+        if not os.path.isfile(os.path.join(images_path, image_path)):
+            return NoResource('Image not found')
+        image = os.path.join('screensharing_img', image_path)
         width = 'width: 100%' if 'fit' in request.args else ''
-        return html_template % dict(image=image, width=width)
-
-
-class ScreenSharingWebServer(object):
-    def __init__(self, images_path):
-        root = resource.Resource()
-        home = ScreenSharingWebsite(images_path)
-        img_resource = static.File(images_path)
-        root.putChild('', home)
-        root.putChild('img', img_resource)
-
-        self.site = server.Site(root, logPath=os.devnull)
-        self.listener = None
-        self.scheme = None
-
-    @property
-    def url(self):
-        if self.listener is None:
-            return ''
-        return '%s://%s:%d' % (self.scheme, self.host, self.port)
-
-    @property
-    def host(self):
-        if self.listener is None:
-            return ''
-        return self.listener.getHost().host
-
-    @property
-    def port(self):
-        if self.listener is None:
-            return 0
-        return self.listener.getHost().port
-
-    def start(self, interface, port, credentials):
-        if credentials is None:
-            self.listener = reactor.listenTCP(port, self.site, interface=interface)
-            self.scheme = 'http'
-        else:
-            self.listener = reactor.listenTLS(port, self.site, credentials, interface=interface)
-            self.scheme = 'https'
-
-    def stop(self):
-        self.listener.stopListening()
+        return self.screensharing_template % dict(image=image, width=width)
+
+    @app.route('/<string:room_uri>/screensharing_img/<string:filename>')
+    def screensharing_image(self, request, room_uri, filename):
+        try:
+            room = self.conference._rooms[room_uri]
+        except KeyError:
+            return NoResource('Room not found')
+        images_path = os.path.join(ConferenceConfig.screensharing_images_dir, room.uri)
+        return File(os.path.join(images_path, os.path.basename(filename)))