Add a route backwards from the DUT to the test host

server/site_wifitest.py

 # Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import common, datetime, fnmatch, logging, os, re, string, threading, time
 
 from autotest_lib.server import autotest, hosts, subcommand
 from autotest_lib.server import site_bsd_router
 from autotest_lib.server import site_linux_router
 from autotest_lib.server import site_linux_server
 from autotest_lib.server import site_host_attributes
+from autotest_lib.server import site_host_route
 from autotest_lib.server import site_eap_certs
 from autotest_lib.server import test
 from autotest_lib.client.common_lib import error
 
 class NotImplemented(Exception):
     def __init__(self, what):
         self.what = what
 
 
     def __str__(self):
@@ skipping 125 matching lines @@
         self.hosting_server = site_linux_server.LinuxServer(self.server, server)
 
         # potential bg thread for ping untilstop
         self.ping_thread = None
 
         # potential bg thread for client network monitoring
         self.client_netdump_thread = None
         self.__client_discover_commands(client)
         self.profile_save({})
         self.firewall_rules = []
+        self.host_route_args = {}
 
         # interface name on client
         self.client_wlanif = client.get('wlandev',
                                         self.__get_wlan_devs(self.client)[0])
 
         # Synchronize time on all devices
         self.time_sync([])
 
         # Find all repeated steps and create iterators for them
         self.iterated_steps = {}
@@ skipping 1056 matching lines @@
                     If not specified, the default is 'none'.
                     The value provided is passed directly to 'connect-vpn'.
         """
         self.vpn_client_kill({}) # Must be first.  Relies on self.vpn_kind.
         self.vpn_kind = params.get('kind', None)
         vpn_host_ip   = params.get('vpn-host-ip', self.server_wifi_ip)
 
         # Must get 'ca_certificate', 'client-certificate' and 'client-key'.
         cert_pathnames = params.get('files', {})
 
+        # Set up a host route on the DUT so that the VPN doesn't prevent us

[thutt, 2011/04/01 21:43:06]

Can you make this comment more clear?  It's rather convoluted at written.

+        # from having IP traffic from it return to us

[thutt, 2011/04/01 21:43:06]

This comment too.
In my implementation, I split the if/elif starting at line 1239 into an if/if.  

I put the route addition between lines 1240 and 1240.  It's a negligible amount
of time, but at least you won't end up creating the route for error cases.

Conversely, the route is removed only if there is an actual VPN kind in
vpn_client_kill.

Feel free to ignore.

[Paul Stewart, 2011/04/01 21:52:45]

Feel free to move it where you'd like, and change the comment as well.  This is
just a suggestion, and I understand you're still actively working on this.

+        __add_host_route(self.client)
+
         if self.vpn_kind is None:
             raise error.TestFail('No VPN kind specified for this test.')
         elif self.vpn_kind == 'openvpn':
             remote_cert_tls_option = ""
             remote_cert_tls        = params.get('remote-cert-tls', None)
 
             if remote_cert_tls is not None:
                 remote_cert_tls_option = "--remote-cert-tls " + remote_cert_tls
 
             # connect-vpn openvpn [options] <name> <host-ip> <domain> \
@@ skipping 18 matching lines @@
     def vpn_client_kill(self, params):
         """ Kill the VPN client if it's running. """
         if self.vpn_kind is not None:
             if self.vpn_kind == 'openvpn':
                 self.client.run("pkill openvpn")
             else:
                 raise error.TestFail('(internal error): No kill case '
                                      'for VPN kind (%s)' % self.vpn_kind)
             self.vpn_kind = None
 
+        __del_host_route(self.client)
+
+    def __add_host_route(self, host):
+        # What is the local address we use to get to the test host?
+        local_ip = site_host_route.LocalHostRoute(host.ip).route_info["src"]
+
+        # How does the test host currently get to this local address?
+        host_route = site_host_route.RemoteHostRoute(host, local_ip).route_info
+
+        # Flatten the returned dict into a single string
+        route_args = " ".join(" ".join(x) for x in host_route.iteritems())
+
+        self.host_route_args[host.ip] = "%s %s" % (local_ip, route_args)
+        host.run("ip route add %s" % self.host_route_args[host.ip])
+
+    def __del_host_route(self, host):
+        if host.ip not in self.host_route_args:
+            return
+
+        host.run("ip route del %s" % self.host_route_args.pop(host.ip))
+
+
 class HelperThread(threading.Thread):
     # Class that wraps a ping command in a thread so it can run in the bg.
     def __init__(self, client, cmd):
         threading.Thread.__init__(self)
         self.client = client
         self.cmd = cmd
 
     def run(self):
         # NB: set ignore_status as we're always terminated w/ pkill
         self.result = self.client.run(self.cmd, ignore_status=True)
@@ skipping 114 matching lines @@
     except error.TestFail:
       if 'expect_failure' in testcase:
         self.expect_failure(name, testcase['expect_failure'])
       else:
         raise
     except Exception, e:
       if 'expect_failure' in testcase:
         self.expect_failure(name, testcase['expect_failure'])
       else:
         raise