VPN: Test to set up & validate a Client connection to the Server

server/site_wifitest.py

-# Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
+# 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_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
 
 
@@ skipping 27 matching lines @@
       client_monitor_stop     stop monitoring for wireless system events
       client_check_event_*    check the client's event log for an event;
                               should always be preceded by client_monitor_start
       sleep                   pause on the autotest server for a time
       client_ping             ping the server on the client machine
       server_ping             ping the client on the server machine
       client_iperf            run iperf on the client to the server
       server_iperf            run iperf on the server to the client
       client_netperf          run netperf on the client to the server
       server_netperf          run netperf on the server to the client
+      vpn_client_load_tunnel  load 'tun' device for VPN client
+      vpn_client_config       launch a VPN client to connect with the
+                              VPN server
 
     Steps that are done on the client or server machine are implemented in
     this class.  Steps that are done on the wifi router are implemented in
     a separate class that knows how to control the router.  There are presently
     two classes: BSDRouter for routers based on FreeBSD and LinuxRouter for
     those based on Linux/mac80211.  Additional router support can be added
     by adding a new class and auto-selecting it in __init__.
 
     The WiFiTest class could be generalized to handle clients other than
     ChromeOS; this would useful for systems that use Network Manager or
     wpa_supplicant directly.
     """
 
     def __init__(self, name, steps, config):
         self.name = name
         self.steps = steps
         self.perf_keyvals = {}
 
-        self.cur_frequency = None;
-        self.cur_phymode = None;
-        self.cur_security = None;
+        self.cur_frequency = None
+        self.cur_phymode   = None
+        self.cur_security  = None
+        self.vpn_kind      = None
 
         router = config['router']
+        #
+        # The server machine may be multi-homed or only on the wifi
+        # network.  When only on the wifi net we suppress server_*
+        # requests since we cannot initiate them from the control machine.
+        #
+        server = config['server']
+        # NB: server may not be reachable on the control network
+
         self.router = hosts.create_host(router['addr'])
         # NB: truncate SSID to 32 characters
         self.defssid = self.__get_defssid(router['addr'])[0:32]
 
         defaults = config.get('defaults', {})
         self.deftimeout = defaults.get('timeout', 30)
         self.defpingcount = defaults.get('pingcount', 10)
         self.defwaittime = defaults.get('netperf_wait_time', 3)
         self.defiperfport = str(defaults.get('iperf_port', 12866))
         self.defnetperfport = str(defaults.get('netperf_port', 12865))
@@ skipping 19 matching lines @@
         # The address on the wifi network is retrieved each time it
         # associates to the router.
         #
         client = config['client']
         self.client = hosts.create_host(client['addr'])
         self.client_at = autotest.Autotest(self.client)
         self.client_wifi_ip = None            # client's IP address on wifi net
         self.client_wifi_device_path = None   # client's flimflam wifi path
         self.client_installed_scripts = {}
 
-        #
-        # The server machine may be multi-homed or only on the wifi
-        # network.  When only on the wifi net we suppress server_*
-        # requests since we cannot initiate them from the control machine.
-        #
-        server = config['server']
-        # NB: server may not be reachable on the control network
         if 'addr' in server:
             self.server = hosts.create_host(server['addr'])
             self.server_at = autotest.Autotest(self.server)
             # if not specified assume the same as the control address
             self.server_wifi_ip = server.get('wifi_addr', self.server.ip)
             self.__server_discover_commands(server)
         else:
             self.server = None
             # NB: wifi address must be set if not reachable from control
             self.server_wifi_ip = server['wifi_addr']
 
+        # hosting_server is a machine which hosts network services,
+        # such as VPN.
+        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 = []
 
         # interface name on client
@@ skipping 122 matching lines @@
                 logging.info("%s: step '%s' (expect failure)  params %s",
                     self.name, method, params)
             else:
                 logging.info("%s: step '%s' params %s", self.name, method,
                     params)
 
             self.error_message = ''
             func = getattr(self, method, None)
             if func is None:
                 func = getattr(self.wifi, method, None)
+            if func is None:
+                func = getattr(self.hosting_server, method, None)
             if func is not None:
                 try:
                     func(params)
                     if expect_failure is True:
                         expect_failure = False
                         raise error.TestFail("Expected failure")
                 except Exception, e:
                     if expect_failure is True:
                         if not failure_string:
                             continue
@@ skipping 77 matching lines @@
 
     def install_files(self, params):
         """ Install files on the client or router with the provided
         contents"""
 
         systemname = params.get('system', None)
         if systemname == 'router':
             system = self.router
         elif systemname == 'client':
             system = self.client
+        elif systemname == 'server':
+            system = self.server
         else:
-            raise error.TestFail('install_files: Must specify router or client')
+            raise error.TestFail('install_files: Must specify router, '
+                                 'server or client')
 
         for name,contents in params.get('files', {}).iteritems():
             self.insert_file(system, name, contents)
 
 
     def connect(self, params):
         """ Connect client to AP/router """
 
         script_client_file = self.install_script('site_wlan_connect.py',
                                                  'site_wlan_wait_state.py')
@@ skipping 686 matching lines @@
     def client_suspend_end(self, params):
         """ Join the backgrounded suspend thread """
 
         self.client_suspend_thread.join()
         if self.client_suspend_thread.result.exit_status:
             raise error.TestError('suspend failed')
 
     def restart_supplicant(self, params):
         """ Restart wpa_supplicant.  Cert params are unfortunately "sticky". """
 
-        self.client.run("stop wpasupplicant; start wpasupplicant");
+        self.client.run("stop wpasupplicant; start wpasupplicant")
 
     def __list_profile(self):
         ret = []
         result = self.client.run('%s/test/list-entries' %
                                  self.client_cmd_flimflam_lib)
         for line in result.stdout.splitlines():
             m = re.search('\[(wifi_.*)\]', line)
             if m is not None:
                 ret.append(m.group(1))
         return ret
@@ skipping 69 matching lines @@
             system = { 'client': self.client,
                        'server': self.server,
                        'router': self.router }.get(name)
             if not system:
                 raise error.TestFail('time_sync: Must specify '
                                      'router, client or server')
             datefmt = '%m%d%H%M%Y.%S' if name == 'client' else '%Y%m%d%H%M.%S'
             system.run('date -u %s' %
                        datetime.datetime.utcnow().strftime(datefmt))
 
+    def vpn_client_load_tunnel(self, params):
+        """ Load the 'tun' device.
+
+            Necessary when the VPN Server is configured with 'dev tun'.
+        """
+        result = self.client.run('modprobe tun') # When server using tunnel.
+
+    def vpn_client_config(self, params):
+        """ Configure & launch the VPN client.
+
+            Parameters:
+
+              'kind'      : required
+                  Indicates the kind of VPN which is to be used.
+                  Valid values are:
+
+                    openvpn
+
+              'vpn-host-ip': optional
+                  Specifies the IP of the VPN server.  If not provided,
+                  defaults to 'self.server_wifi_ip'
+
+              'files'      : required
+                  A dict which contains a set of file names.
+
+                     'ca-certificate'     : path to CA certificate file
+                     'client-certificate' : path to client certificate file
+                     'client-key'         : path to client key file
+        """
+        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', {})
+
+        if self.vpn_kind is None:
+            raise error.TestFail('No VPN kind specified for this test.')
+        elif self.vpn_kind == 'openvpn':
+            # connect-vpn openvpn <name> <host> <domain> <cafile> <certfile>
+            result = self.client.run('%s/test/connect-vpn openvpn '
+                                     'vpn-name %s vpn-domain '
+                                     '%s '   # ca certificate
+                                     '%s '   # client certificate
+                                     '%s' %  # client key
+                                     (self.client_cmd_flimflam_lib,
+                                      vpn_host_ip,
+                                      cert_pathnames['ca-certificate'],
+                                      cert_pathnames['client-certificate'],
+                                      cert_pathnames['client-key']))
+        else:
+            raise error.TestFail('(internal error): No launch case '
+                                 'for VPN kind (%s)' % self.vpn_kind)
+
+    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.server.run("pkill openvpn")
+            else:
+                raise error.TestFail('(internal error): No kill case '
+                                     'for VPN kind (%s)' % self.vpn_kind)
+            self.vpn_kind = None
 
 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
@@ skipping 115 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