Add --host argument to replay.py to allow non-loopback interfaces

replay.py

 #!/usr/bin/env python
 # Copyright 2010 Google Inc. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
@@ skipping 25 matching lines @@
   $ sudo ./replay.py --up 128KByte/s --down 4Mbit/s --delay_ms=100 archive.wpr
 
   # 1% packet loss rate
   $ sudo ./replay.py --packet_loss_rate=0.01 archive.wpr
 """
 
 import json
 import logging
 import optparse
 import os
+import socket
 import sys
 import traceback
 
 import cachemissarchive
 import customhandlers
 import dnsproxy
 import httparchive
 import httpclient
 import httpproxy
 import platformsettings
@@ skipping 85 matching lines @@
           httpproxy.HttpsProxyServer,
           archive_fetch, custom_handlers, options.certfile,
           host=host, port=options.ssl_port, **options.shaping_http)
 
 
 def AddTrafficShaper(server_manager, options, host):
   if options.shaping_dummynet:
     ssl_port = options.ssl_shaping_port if options.ssl else None
     kwargs = dict(
         host=host, port=options.shaping_port, ssl_port=ssl_port,
-        use_loopback=not options.server_mode, **options.shaping_dummynet)
+        use_loopback=not options.server_mode and host == '127.0.0.1',
+        **options.shaping_dummynet)
     if not options.dns_forwarding:
       kwargs['dns_port'] = None
     server_manager.Append(trafficshaper.TrafficShaper, **kwargs)
 
 
 class OptionsWrapper(object):
   """Add checks, updates, and methods to option values.
 
   Example:
     options, args = option_parser.parse_args()
@@ skipping 21 matching lines @@
   )
   NET_CHOICES = [key for key, values in _NET_CONFIGS]
 
   def __init__(self, options, parser):
     self._options = options
     self._parser = parser
     self._nondefaults = set([
         name for name, value in parser.defaults.items()
         if getattr(options, name) != value])
     self._CheckConflicts()
+    self._CheckValidIp('host')
     self._MassageValues()
 
   def _CheckConflicts(self):
     """Give an error if mutually exclusive options are used."""
     for option, bad_options in self._CONFLICTING_OPTIONS:
       if option in self._nondefaults:
         for bad_option in bad_options:
           if bad_option in self._nondefaults:
             self._parser.error('Option --%s cannot be used with --%s.' %
                                 (bad_option, option))
 
+  def _CheckValidIp(self, name):
+    """Give an error if option |name| is not a valid IPv4 address."""
+    value = getattr(self._options, name)
+    if value:
+      try:
+        socket.inet_aton(value)
+      except:
+        self._parser.error('Option --%s must be a valid IPv4 address.' % name)
+
   def _ShapingKeywordArgs(self, shaping_key):
     """Return the shaping keyword args for |shaping_key|.
 
     Args:
       shaping_key: one of 'dummynet', 'dns', 'http'.
     Returns:
       {}  # if shaping_key does not apply, or options have default values.
       {k: v, ...}
     """
     kwargs = {}
@@ skipping 65 matching lines @@
                       'replay will load and append entries to archive file',
                       options.cache_miss_file)
       cache_misses = cachemissarchive.CacheMissArchive.Load(
           options.cache_miss_file)
     else:
       cache_misses = cachemissarchive.CacheMissArchive(
           options.cache_miss_file)
   if options.server:
     AddDnsForward(server_manager, options.server)
   else:
-    host = platformsettings.get_server_ip_address(options.server_mode)
+    host = options.host
+    if not host:
+      host = platformsettings.get_server_ip_address(options.server_mode)
     real_dns_lookup = dnsproxy.RealDnsLookup(
         name_servers=[platformsettings.get_original_primary_nameserver()])
     if options.record:
       httparchive.HttpArchive.AssertWritable(replay_filename)
       if options.append and os.path.exists(replay_filename):
         http_archive = httparchive.HttpArchive.Load(replay_filename)
         logging.info('Appending to %s (loaded %d existing responses)',
                      replay_filename, len(http_archive))
       else:
         http_archive = httparchive.HttpArchive()
     else:
       http_archive = httparchive.HttpArchive.Load(replay_filename)
       logging.info('Loaded %d responses from %s',
                    len(http_archive), replay_filename)
     server_manager.AppendRecordCallback(real_dns_lookup.ClearCache)
     server_manager.AppendRecordCallback(http_archive.clear)
 
     if options.dns_forwarding:
-      if not options.server_mode:
+      if not options.server_mode and host == '127.0.0.1':
         AddDnsForward(server_manager, host)
       AddDnsProxy(server_manager, options, host, real_dns_lookup, http_archive)
     if options.ssl and options.certfile is None:
       options.certfile = os.path.join(os.path.dirname(__file__), 'wpr_cert.pem')
-    http_proxy_address = platformsettings.get_httpproxy_ip_address(
-        options.server_mode)
+    http_proxy_address = options.host
+    if not http_proxy_address:
+      http_proxy_address = platformsettings.get_httpproxy_ip_address(
+          options.server_mode)
     AddWebProxy(server_manager, options, http_proxy_address, real_dns_lookup,
                 http_archive, cache_misses)
     AddTrafficShaper(server_manager, options, host)
 
   exit_status = 0
   try:
     server_manager.Run()
   except KeyboardInterrupt:
     logging.info('Shutting down.')
   except (dnsproxy.DnsProxyException,
@@ skipping 137 matching lines @@
       dest='dns_private_passthrough',
       help='Don\'t forward DNS requests that resolve to private network '
            'addresses. CAUTION: With this option important services like '
            'Kerberos will resolve to the HTTP proxy address.')
   harness_group.add_option('-x', '--no-dns_forwarding', default=True,
       action='store_false',
       dest='dns_forwarding',
       help='Don\'t forward DNS requests to the local replay server. '
            'CAUTION: With this option an external mechanism must be used to '
            'forward traffic to the replay server.')
+  harness_group.add_option('--host', default=None,
+      action='store',
+      type='str',
+      help='The IP address to bind all servers to. Defaults to 0.0.0.0 or '
+           '127.0.0.1, depending on --server_mode and platform.')
   harness_group.add_option('-o', '--port', default=80,
       action='store',
       type='int',
       help='Port number to listen on.')
   harness_group.add_option('--ssl_port', default=443,
       action='store',
       type='int',
       help='SSL port number to listen on.')
   harness_group.add_option('--shaping_port', default=None,
       action='store',
@@ skipping 31 matching lines @@
   elif len(args) != 1:
     option_parser.error('Must specify a replay_file')
   else:
     replay_filename = args[0]
 
   return replay(options, replay_filename)
 
 
 if __name__ == '__main__':
   sys.exit(main())