| # 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 logging |
| import re |
| |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.server import site_linux_system |
| from autotest_lib.server.cros import remote_command |
| from autotest_lib.server.cros import wifi_test_utils |
| |
| class LinuxServer(site_linux_system.LinuxSystem): |
| """ |
| Linux Server: A machine which hosts network services. |
| |
| """ |
| |
| COMMAND_PING = '/usr/bin/ping' |
| COMMAND_NETPERF = '/usr/bin/netperf' |
| COMMAND_NETSERVER = '/usr/bin/netserver' |
| COMMAND_IP = '/usr/sbin/ip' |
| COMMAND_IPERF = '/usr/bin/iperf' |
| |
| |
| def __init__(self, server, config): |
| site_linux_system.LinuxSystem.__init__(self, server, {}, "server") |
| |
| self._server = server # Server host. |
| self.vpn_kind = None |
| self.config = config |
| self.openvpn_config = {} |
| self.radvd_config = {'file':'/tmp/radvd-test.conf', |
| 'server':'/usr/sbin/radvd'} |
| |
| # Check that tools we require from WiFi test servers exist. |
| self._cmd_netperf = wifi_test_utils.must_be_installed( |
| self._server, LinuxServer.COMMAND_NETPERF) |
| self._cmd_netserver = wifi_test_utils.must_be_installed( |
| self._server, LinuxServer.COMMAND_NETSERVER) |
| self._cmd_ip = wifi_test_utils.must_be_installed( |
| self._server, LinuxServer.COMMAND_IP) |
| self._cmd_iperf = wifi_test_utils.must_be_installed( |
| self._server, LinuxServer.COMMAND_IPERF) |
| # /usr/bin/ping is preferred, as it is likely to be iputils. |
| if wifi_test_utils.is_installed(self._server, |
| LinuxServer.COMMAND_PING): |
| self._cmd_ping = LinuxServer.COMMAND_PING |
| else: |
| self._cmd_ping = 'ping' |
| |
| self._ping_bg_job = None |
| self._wifi_ip = None |
| |
| |
| @property |
| def cmd_netperf(self): |
| """ @return string full path to start netperf. """ |
| return self._cmd_netperf |
| |
| |
| @property |
| def cmd_netserv(self): |
| """ @return string full path to start netserv. """ |
| return self._cmd_netserver |
| |
| |
| @property |
| def cmd_iperf(self): |
| """ @return string full path to start iperf. """ |
| return self._cmd_iperf |
| |
| |
| @property |
| def cmd_ping(self): |
| """ @return string full path to start ping. """ |
| return self._cmd_ping |
| |
| |
| @property |
| def server(self): |
| """ @return Host object for this remote server. """ |
| return self._server |
| |
| |
| @property |
| def wifi_ip(self): |
| """ |
| Returns an IP address pingable from the client DUT. |
| |
| Throws an error if no interface is configured with a potentially |
| pingable IP. |
| |
| @return String IP address on the WiFi subnet. |
| """ |
| if not self._wifi_ip: |
| addrs = self._get_system_ipv4_addrs(self.server) |
| # Discard loopback IPs and the control network IP. |
| valid_addrs = filter( |
| lambda addr: not addr.startswith('127.0.0') and |
| not addr.startswith(self.server.ip), |
| addrs) |
| if not valid_addrs: |
| raise error.TestFailed('No configured interfaces.') |
| if len(valid_addrs) > 1: |
| logging.warning('Multiple interfaces configured on server; ' |
| 'taking first.') |
| self._wifi_ip = valid_addrs[0] |
| return self._wifi_ip |
| |
| |
| def _get_system_ipv4_addrs(self, host): |
| """ |
| Returns a list of IPs configured on host. |
| |
| @param host Host object representing a remote machine. |
| @return list of IPv4 addresses as strings. |
| |
| """ |
| ip_output = host.run('%s -4 addr show' % self._cmd_ip).stdout |
| regex = re.compile('^inet ([0-9]{1,3}(\\.[0-9]{1,3}){3})') |
| ips = [] |
| for line in ip_output.splitlines(): |
| ip = re.search(regex, line.strip()) |
| if ip: |
| # Group 1 will be the IP address following 'inet addr:'. |
| ips.append(ip.group(1)) |
| return ips |
| |
| |
| def vpn_server_config(self, params): |
| """ Configure & launch the server side of the VPN. |
| |
| Parameters, in 'params': |
| |
| kind : required |
| |
| The kind of VPN which should be configured and |
| launched. |
| |
| Valid values: |
| |
| openvpn |
| l2tpipsec (StrongSwan PSK or certificates) |
| |
| config: required |
| |
| The configuration information associated with |
| the VPN server. |
| |
| This is a dict which contains key/value pairs |
| representing the VPN's configuration. |
| |
| The values stored in the 'config' param must all be |
| supported by the specified VPN kind. |
| """ |
| self.vpn_server_kill({}) # Must be first. Relies on self.vpn_kind. |
| self.vpn_kind = params.get('kind', None) |
| |
| # Launch specified VPN server. |
| if self.vpn_kind is None: |
| raise error.TestFail('No VPN kind specified for this test.') |
| elif self.vpn_kind == 'openvpn': |
| # Read config information & create server configuration file. |
| for k, v in params.get('config', {}).iteritems(): |
| self.openvpn_config[k] = v |
| self.server.run("cat <<EOF >/tmp/vpn-server.conf\n%s\nEOF\n" % |
| ('\n'.join( "%s %s" % kv for kv in |
| self.openvpn_config.iteritems()))) |
| self.server.run("/usr/sbin/openvpn " |
| "--config /tmp/vpn-server.conf &") |
| elif self.vpn_kind in ('l2tpipsec-psk', 'l2tpipsec-cert'): |
| configs = { |
| "/etc/xl2tpd/xl2tpd.conf" : |
| "[global]\n" |
| "\n" |
| "[lns default]\n" |
| " ip range = 192.168.1.128-192.168.1.254\n" |
| " local ip = 192.168.1.99\n" |
| " require chap = yes\n" |
| " refuse pap = yes\n" |
| " require authentication = yes\n" |
| " name = LinuxVPNserver\n" |
| " ppp debug = yes\n" |
| " pppoptfile = /etc/ppp/options.xl2tpd\n" |
| " length bit = yes\n", |
| |
| "/etc/xl2tpd/l2tp-secrets" : |
| "* them l2tp-secret", |
| |
| "/etc/ppp/chap-secrets" : |
| "chapuser * chapsecret *", |
| |
| "/etc/ppp/options.xl2tpd" : |
| "ipcp-accept-local\n" |
| "ipcp-accept-remote\n" |
| "noccp\n" |
| "auth\n" |
| "crtscts\n" |
| "idle 1800\n" |
| "mtu 1410\n" |
| "mru 1410\n" |
| "nodefaultroute\n" |
| "debug\n" |
| "lock\n" |
| "proxyarp\n" |
| "connect-delay 5000\n" |
| } |
| config_choices = { |
| 'l2tpipsec-psk': { |
| "/etc/ipsec.conf" : |
| "config setup\n" |
| " charonstart=no\n" |
| " plutostart=yes\n" |
| " plutodebug=%(@plutodebug@)s\n" |
| " plutostderrlog=/var/log/pluto.log\n" |
| "conn L2TP\n" |
| " keyexchange=ikev1\n" |
| " authby=psk\n" |
| " pfs=no\n" |
| " rekey=no\n" |
| " left=%(@local-listen-ip@)s\n" |
| " leftprotoport=17/1701\n" |
| " right=%%any\n" |
| " rightprotoport=17/%%any\n" |
| " auto=add\n", |
| |
| "/etc/ipsec.secrets" : |
| "%(@ipsec-secrets@)s %%any : PSK \"password\"", |
| }, |
| 'l2tpipsec-cert': { |
| "/etc/ipsec.conf" : |
| "config setup\n" |
| " charonstart=no\n" |
| " plutostart=yes\n" |
| " plutodebug=%(@plutodebug@)s\n" |
| " plutostderrlog=/var/log/pluto.log\n" |
| "conn L2TP\n" |
| " keyexchange=ikev1\n" |
| " left=%(@local-listen-ip@)s\n" |
| " leftcert=server.crt\n" |
| " leftid=\"C=US, ST=California, L=Mountain View, " |
| "CN=chromelab-wifi-testbed-server.mtv.google.com\"\n" |
| " leftprotoport=17/1701\n" |
| " right=%%any\n" |
| " rightca=\"C=US, ST=California, L=Mountain View, " |
| "CN=chromelab-wifi-testbed-root.mtv.google.com\"\n" |
| " rightprotoport=17/%%any\n" |
| " auto=add\n" |
| " pfs=no\n", |
| |
| "/etc/ipsec.secrets" : ": RSA server.key \"\"\n", |
| }, |
| } |
| configs.update(config_choices[self.vpn_kind]) |
| |
| replacements = params.get("replacements", {}) |
| # These two replacements must match up to the same |
| # adapter, or a connection will not be established. |
| replacements["@local-listen-ip@"] = "%defaultroute" |
| replacements["@ipsec-secrets@"] = self.server.ip |
| |
| for cfg, template in configs.iteritems(): |
| contents = template % (replacements) |
| self.server.run("cat <<EOF >%s\n%s\nEOF\n" % (cfg, contents)) |
| |
| self.server.run("/usr/sbin/ipsec restart") |
| |
| # Restart xl2tpd to ensure use of newly-created config files. |
| self.server.run("sh /etc/init.d/xl2tpd restart") |
| else: |
| raise error.TestFail('(internal error): No config case ' |
| 'for VPN kind (%s)' % self.vpn_kind) |
| |
| |
| def vpn_server_kill(self, params): |
| """ Kill the VPN server. """ |
| if self.vpn_kind is not None: |
| if self.vpn_kind == 'openvpn': |
| self.server.run("pkill /usr/sbin/openvpn") |
| elif self.vpn_kind in ('l2tpipsec-psk', 'l2tpipsec-cert'): |
| self.server.run("/usr/sbin/ipsec stop") |
| else: |
| raise error.TestFail('(internal error): No kill case ' |
| 'for VPN kind (%s)' % self.vpn_kind) |
| self.vpn_kind = None |
| |
| |
| def ipv6_server_config(self, params): |
| self.ipv6_server_kill({}) |
| radvd_opts = { 'interface': self.config.get('server_dev', 'eth0'), |
| 'adv_send_advert': 'on', |
| 'min_adv_interval': '3', |
| 'max_adv_interval': '10', |
| # NB: Addresses below are within the 2001:0db8/32 |
| # "documentation only" prefix (RFC3849), which is |
| # guaranteed never to be assigned to a real network. |
| 'prefix': '2001:0db8:0100:f101::/64', |
| 'adv_on_link': 'on', |
| 'adv_autonomous': 'on', |
| 'adv_router_addr': 'on', |
| 'rdnss_servers': '2001:0db8:0100:f101::0001 ' |
| '2001:0db8:0100:f101::0002', |
| 'adv_rdnss_lifetime': 'infinity', |
| 'dnssl_list': 'a.com b.com' } |
| radvd_opts.update(params) |
| |
| config = ('interface %(interface)s {\n' |
| ' AdvSendAdvert %(adv_send_advert)s;\n' |
| ' MinRtrAdvInterval %(min_adv_interval)s;\n' |
| ' MaxRtrAdvInterval %(max_adv_interval)s;\n' |
| ' prefix %(prefix)s {\n' |
| ' AdvOnLink %(adv_on_link)s;\n' |
| ' AdvAutonomous %(adv_autonomous)s;\n' |
| ' AdvRouterAddr %(adv_router_addr)s;\n' |
| ' };\n' |
| ' RDNSS %(rdnss_servers)s {\n' |
| ' AdvRDNSSLifetime %(adv_rdnss_lifetime)s;\n' |
| ' };\n' |
| ' DNSSL %(dnssl_list)s {\n' |
| ' };\n' |
| '};\n') % radvd_opts |
| cfg_file = params.get('config_file', self.radvd_config['file']) |
| self.server.run('cat <<EOF >%s\n%s\nEOF\n' % (cfg_file, config)) |
| self.server.run('%s -C %s\n' % (self.radvd_config['server'], cfg_file)) |
| |
| |
| def ipv6_server_kill(self, params): |
| self.server.run('pkill %s >/dev/null 2>&1' % |
| self.radvd_config['server'], ignore_status=True) |
| |
| |
| def ping(self, ping_ip, count, ping_params): |
| """ |
| Ping a client from the server. |
| |
| Ping |ping_ip| |count| times using options to ping specified in |
| |ping_params|. |
| |
| @param ping_ip String containing a client IP address. |
| @param count String number of times to ping the client. |
| @param ping_params dict of settings for ping. |
| @return dict of ping statistics. |
| |
| """ |
| # set timeout for 3s / ping packet |
| ping_params = ping_params.copy() |
| ping_params['count'] = str(count) |
| cmd = "%s %s %s" % (self.cmd_ping, |
| wifi_test_utils.ping_args(ping_params), |
| ping_ip) |
| result = self.server.run(cmd, timeout=3*int(count)) |
| return wifi_test_utils.parse_ping_output(result.stdout) |
| |
| |
| def ping_bg(self, ping_ip, ping_params): |
| """ |
| Ping a client from the server in a background thread. |
| |
| Ping |ping_ip| using options to ping specified in |
| |ping_params| in the background. This call does not block. |
| |
| @param ping_ip String containing a client IP address. |
| @param ping_params dict of settings for ping. |
| |
| """ |
| cmd = "%s %s %s" % (self.cmd_ping, |
| wifi_test_utils.ping_args(ping_params), |
| ping_ip) |
| self._ping_bg_job = remote_command.Command(self.server, cmd) |
| |
| |
| def ping_bg_stop(self): |
| """ |
| Stop pinging the client in the background. |
| |
| """ |
| if self._ping_bg_job is not None: |
| self._ping_bg_job.join() |
| self._ping_bg_job = None |
