diff --git a/sylk/applications/webrtcgateway/configuration.py b/sylk/applications/webrtcgateway/configuration.py
index b194b76..7dcf6dd 100644
--- a/sylk/applications/webrtcgateway/configuration.py
+++ b/sylk/applications/webrtcgateway/configuration.py
@@ -1,156 +1,156 @@
 
 import os
 import re
 
 from application.configuration import ConfigFile, ConfigSection, ConfigSetting
 from application.configuration.datatypes import NetworkAddress, StringList
 
 from sylk.configuration import ServerConfig
-from sylk.configuration.datatypes import Path, SIPProxyAddress, VideoBitrate, VideoCodec, URL
+from sylk.configuration.datatypes import Path, SIPProxyAddress, VideoBitrate, VideoCodec
 
 
 __all__ = 'GeneralConfig', 'JanusConfig', 'get_room_config'
 
 
 # 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 PolicyItem(object):
     def __new__(cls, item):
         lowercase_item = item.lower()
         if lowercase_item in ('none', ''):
             return 'none'
         elif lowercase_item in ('any', 'all', '*'):
             return 'all'
         elif '@' in item:
             return SIPAddress(item)
         else:
             return Domain(item)
 
 
 class PolicySettingValue(object):
     def __init__(self, value):
         if isinstance(value, (tuple, list)):
             items = [str(x) for x in value]
         elif isinstance(value, str):
             items = re.split(r'\s*,\s*', value)
         else:
             raise TypeError("value must be a string, list or tuple")
         self.items = {PolicyItem(item) for item in items}
         self.items.discard('none')
 
     def __repr__(self):
         return '{0.__class__.__name__}({1})'.format(self, sorted(self.items))
 
     def match(self, uri):
         if 'all' in self.items:
             return True
         elif not self.items:
             return False
         uri = re.sub('^(sip:|sips:)', '', str(uri))
         domain = uri.split('@')[-1]
         return uri in self.items or domain in self.items
 
 
 class ManagementInterfaceAddress(NetworkAddress):
     default_port = 20888
 
 
 # Configuration objects
 
 class GeneralConfig(ConfigSection):
     __cfgfile__ = 'webrtcgateway.ini'
     __section__ = 'General'
 
     web_origins = ConfigSetting(type=StringList, value=['*'])
     sip_domains = ConfigSetting(type=StringList, value=['*'])
     outbound_sip_proxy = ConfigSetting(type=SIPProxyAddress, value=None)
     trace_client = False
     websocket_ping_interval = 120
     recording_dir = ConfigSetting(type=Path, value=Path(os.path.join(ServerConfig.spool_dir.normalized, 'videoconference', 'recordings')))
     filesharing_dir = ConfigSetting(type=Path, value=Path(os.path.join(ServerConfig.spool_dir.normalized, 'videoconference', 'files')))
     http_management_interface = ConfigSetting(type=ManagementInterfaceAddress, value=ManagementInterfaceAddress('127.0.0.1'))
     http_management_auth_secret = ConfigSetting(type=str, value=None)
     sylk_push_url = ConfigSetting(type=str, value=None)
 
 
 class JanusConfig(ConfigSection):
     __cfgfile__ = 'webrtcgateway.ini'
     __section__ = 'Janus'
 
     api_url = 'ws://127.0.0.1:8188'
     api_secret = '0745f2f74f34451c89343afcdcae5809'
     trace_janus = False
     max_bitrate = ConfigSetting(type=VideoBitrate, value=VideoBitrate(2016000))  # ~2 MBits/s
     video_codec = ConfigSetting(type=VideoCodec, value=VideoCodec('vp9'))
 
 
 class RoomConfig(ConfigSection):
     __cfgfile__ = 'webrtcgateway.ini'
 
     record = False
     access_policy = ConfigSetting(type=AccessPolicyValue, value=AccessPolicyValue('allow, deny'))
     allow = ConfigSetting(type=PolicySettingValue, value=PolicySettingValue('all'))
     deny = ConfigSetting(type=PolicySettingValue, value=PolicySettingValue('none'))
     max_bitrate = ConfigSetting(type=VideoBitrate, value=JanusConfig.max_bitrate)
     video_codec = ConfigSetting(type=VideoCodec, value=JanusConfig.video_codec)
 
 
 class VideoroomConfiguration(object):
     video_codec = 'vp9'
     max_bitrate = 2016000
     record = False
     recording_dir = None
     filesharing_dir = None
 
     def __init__(self, data):
         self.__dict__.update(data)
 
     @property
     def janus_data(self):
         return dict(videocodec=self.video_codec, bitrate=self.max_bitrate, record=self.record, rec_dir=self.recording_dir)
 
 
 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 = VideoroomConfiguration(dict(RoomConfig))
         RoomConfig.reset()
     else:
         config = VideoroomConfiguration(dict(RoomConfig))  # use room defaults
     config.recording_dir = os.path.join(GeneralConfig.recording_dir, room)
     config.filesharing_dir = os.path.join(GeneralConfig.filesharing_dir, room)
     return config