diff --git a/media-relay b/media-relay
index 40bf086..d2701b1 100755
--- a/media-relay
+++ b/media-relay
@@ -1,120 +1,115 @@
 #!/usr/bin/python3
 
 
 if __name__ == '__main__':
     import mediaproxy
     import errno
     import sys
     import subprocess
 
     from application import log
     from application.process import process, ProcessError
     from application.version import Version
     from argparse import ArgumentParser
 
     IP_FORWARD_FILE     = '/proc/sys/net/ipv4/ip_forward'
     CONNTRACK_ACCT_FILE = '/proc/sys/net/netfilter/nf_conntrack_acct'
     KERNEL_VERSION_FILE = '/proc/sys/kernel/osrelease'
 
     name = 'media-relay'
     fullname = 'MediaProxy Relay'
     description = 'MediaProxy Relay component'
 
     process.configuration.user_directory = None
     process.configuration.subdirectory = mediaproxy.mediaproxy_subdirectory
     process.runtime.subdirectory = mediaproxy.mediaproxy_subdirectory
 
     parser = ArgumentParser(usage='%(prog)s [options]')
     parser.add_argument('--version', action='version', version='%(prog)s {}'.format(mediaproxy.__version__))
     parser.add_argument('--systemd', action='store_true', help='run as a systemd simple service and log to journal')
     parser.add_argument('--no-fork', action='store_false', dest='fork', help='run in the foreground and log to the terminal')
     parser.add_argument('--config-dir', dest='config_directory', default=None, help='the configuration directory ({})'.format(process.configuration.system_directory), metavar='PATH')
     parser.add_argument('--runtime-dir', dest='runtime_directory', default=None, help='the runtime directory ({})'.format(process.runtime.directory), metavar='PATH')
     parser.add_argument('--debug', action='store_true', help='enable verbose logging')
     parser.add_argument('--debug-memory', action='store_true', help='enable memory debugging')
 
     options = parser.parse_args()
 
     log.Formatter.prefix_format = '{record.levelname:<8s} '
 
     if options.config_directory is not None:
         process.configuration.local_directory = options.config_directory
+
     if options.runtime_directory is not None:
         process.runtime.directory = options.runtime_directory
 
     if not sys.platform.startswith('linux'):
         log.critical('Cannot start %s. A Linux host is required for operation.' % fullname)
         sys.exit(1)
 
-    try:
-        subprocess.call(['modprobe', 'ip_tables'], env={'PATH': '/usr/sbin:/sbin:/usr/bin:/bin'})
-    except OSError as e:
-        log.critical('Cannot start %s: failed to load the ip_tables kernel module: %s' % (fullname, e))
-        sys.exit(1)
-
     try:
         kernel_version = Version.parse(open(KERNEL_VERSION_FILE).read().strip())
     except (OSError, IOError, ValueError):
         log.critical('Could not determine Linux kernel version')
         sys.exit(1)
 
     if kernel_version < Version(2, 6, 18):
         log.critical('Linux kernel version 2.6.18 or newer is required to run the media relay')
         sys.exit(1)
 
     try:
         ip_forward = bool(int(open(IP_FORWARD_FILE).read()))
     except (OSError, IOError, ValueError):
         ip_forward = False
 
     if not ip_forward:
         log.critical('IP forwarding is not available or not enabled (check %s)' % IP_FORWARD_FILE)
         sys.exit(1)
 
     try:
         with open(CONNTRACK_ACCT_FILE, 'w') as acct_file:
             acct_file.write('1')
     except (IOError, OSError) as e:
         if e.errno != errno.ENOENT:
             log.critical('Could not enable conntrack rule counters (check %s): %s' % (CONNTRACK_ACCT_FILE, e))
             sys.exit(1)
 
     if options.systemd:
         from systemd.journal import JournalHandler
         log.set_handler(JournalHandler(SYSLOG_IDENTIFIER=name))
         log.capture_output()
     elif options.fork:
         try:
             process.daemonize(pidfile='{}.pid'.format(name))
         except ProcessError as e:
             log.critical('Cannot start %s: %s' % (fullname, e))
             sys.exit(1)
         log.use_syslog(name)
 
     log.info('Starting %s %s' % (fullname, mediaproxy.__version__))
 
     try:
         process.wait_for_network(wait_time=10, wait_message='Waiting for network to become available...')
     except KeyboardInterrupt:
         sys.exit(0)
     except RuntimeError as e:
         log.critical('Cannot start %s: %s' % (fullname, e))
         sys.exit(1)
 
     try:
         from mediaproxy.relay import MediaRelay
         from mediaproxy.configuration import RelayConfig
         log.level.current = log.level.DEBUG if options.debug else RelayConfig.log_level
         if options.debug_memory:
             from application.debug.memory import memory_dump
         relay = MediaRelay()
     except Exception as e:
         log.critical('Failed to create %s: %s' % (fullname, e))
         if type(e) is not RuntimeError:
             log.exception()
         sys.exit(1)
 
     relay.run()
 
     if options.debug_memory:
         memory_dump()