def run_once(self):
"""Test body."""
shill = wifi_proxy.WifiProxy.get_proxy()
with shill_temporary_profile.ShillTemporaryProfile(shill.manager):
self.check_bad_ssids(shill)
self.check_bad_wep_keys(shill)
self.check_bad_wpa_passphrases(shill)
def run_vpn_test(self, vpn_type):
"""Run a vpn test of |vpn_type|.
@param vpn_type string type of VPN test to run.
"""
manager = self._shill_proxy.manager
server_address_and_prefix = '%s/%d' % (self.SERVER_ADDRESS,
self.NETWORK_PREFIX)
client_address_and_prefix = '%s/%d' % (self.CLIENT_ADDRESS,
self.NETWORK_PREFIX)
self._vpn_type = vpn_type
self._expect_success = 'incorrect' not in vpn_type
with shill_temporary_profile.ShillTemporaryProfile(
manager, profile_name=self.TEST_PROFILE_NAME):
with virtual_ethernet_pair.VirtualEthernetPair(
interface_name=self.SERVER_INTERFACE_NAME,
peer_interface_name=self.CLIENT_INTERFACE_NAME,
peer_interface_ip=client_address_and_prefix,
interface_ip=server_address_and_prefix,
ignore_shutdown_errors=True) as ethernet_pair:
if not ethernet_pair.is_healthy:
raise error.TestFail('Virtual ethernet pair failed.')
# When shill finds this ethernet interface, it will reset
# its IP address and start a DHCP client. We must configure
# the static IP address through shill.
self.configure_static_ip(self.CLIENT_INTERFACE_NAME,
self.CLIENT_ADDRESS,
self.NETWORK_PREFIX)
with self.get_vpn_server() as server:
self.connect_vpn()
site_utils.ping(server.SERVER_IP_ADDRESS, tries=3)
def run_once(self):
"""Test body."""
shill = wifi_proxy.WifiProxy.get_proxy()
with shill_temporary_profile.ShillTemporaryProfile(
shill.manager, profile_name=self.PROFILE_NAME):
profiles = shill.get_profiles()
logging.info('Got profiles %r', profiles)
# The last profile should be the one we just created.
profile = profiles[-1]
profile_properties = shill.dbus2primitive(
profile.GetProperties(utf8_strings=True))
logging.debug('Profile properties: %r.', profile_properties)
profile_name = self.get_field_from_properties(
profile_properties, self.PROFILE_PROPERTY_NAME)
if profile_name != self.PROFILE_NAME:
raise error.TestFail('Found unexpected top profile with name '
'%r.' % profile_name)
entries = shill.dbus2primitive(
self.get_field_from_properties(profile_properties,
self.PROFILE_PROPERTY_ENTRIES))
logging.info('Found entries: %r', entries)
ethernet_if = interface.Interface.get_connected_ethernet_interface(
)
mac = ethernet_if.mac_address.replace(':', '').lower()
ethernet_entry_key = 'ethernet_%s' % mac
if not ethernet_entry_key in entries:
raise error.TestFail(
'Missing ethernet entry %s from profile.' %
ethernet_entry_key)
entry = profile.GetEntry(ethernet_entry_key)
def run_once(self):
"""Test main loop."""
self._shill_proxy = shill_proxy.ShillProxy()
manager = self._shill_proxy.manager
with shill_temporary_profile.ShillTemporaryProfile(
manager, profile_name=self.TEST_PROFILE_NAME):
with virtual_ethernet_pair.VirtualEthernetPair(
peer_interface_name=self.INTERFACE_NAME,
peer_interface_ip=None) as ethernet_pair:
if not ethernet_pair.is_healthy:
raise error.TestFail('Virtual ethernet pair failed.')
if self.get_authenticated_flag(self.INTERFACE_NAME):
raise error.TestFail('Authentication flag already set.')
with hostapd_server.HostapdServer(
interface=ethernet_pair.interface_name) as hostapd:
# Wait for hostapd to initialize.
time.sleep(1)
if not hostapd.running():
raise error.TestFail('hostapd process exited.')
self.configure_credentials(self.INTERFACE_NAME)
hostapd.send_eap_packets()
if not self.wait_for_authentication(self.INTERFACE_NAME):
raise error.TestFail('Authentication did not complete.')
client_mac_address = ethernet_pair.peer_interface_mac
if not hostapd.client_has_authenticated(client_mac_address):
raise error.TestFail('Server does not agree that '
'client is authenticated')
if hostapd.client_has_logged_off(client_mac_address):
raise error.TestFail('Client has already logged off')
# Since the EAP credentials are associated with the
# top-most profile, popping it should cause the client
# to immediately log-off.
manager.PopProfile(self.TEST_PROFILE_NAME)
if self.get_authenticated_flag(self.INTERFACE_NAME):
raise error.TestFail('Client is still authenticated.')
if not hostapd.client_has_logged_off(client_mac_address):
raise error.TestFail('Client did not log off')
# Re-pushing the profile should make the EAP credentials
# available again, and should cause the client to
# re-authenticate.
manager.PushProfile(self.TEST_PROFILE_NAME)
if not self.wait_for_authentication(self.INTERFACE_NAME):
raise error.TestFail('Re-authentication did not '
'complete.')
def test_body(self):
"""The test main body"""
subnet_mask = self.ethernet_pair.interface_subnet_mask
intended_ip = dhcp_test_base.DhcpTestBase.rewrite_ip_suffix(
subnet_mask,
self.server_ip,
self.INTENDED_IP_SUFFIX)
# Two real name servers, and a bogus one to be unpredictable.
dns_servers = ['8.8.8.8', '8.8.4.4', '192.168.87.88']
domain_name = 'corp.google.com'
dns_search_list = [
'corgie.google.com',
'lies.google.com',
'that.is.a.tasty.burger.google.com',
]
# This is the pool of information the server will give out to the client
# upon request.
dhcp_options = {
dhcp_packet.OPTION_SERVER_ID : self.server_ip,
dhcp_packet.OPTION_SUBNET_MASK : subnet_mask,
dhcp_packet.OPTION_IP_LEASE_TIME : self.LEASE_TIME_SECONDS,
dhcp_packet.OPTION_REQUESTED_IP : intended_ip,
dhcp_packet.OPTION_DNS_SERVERS : dns_servers,
dhcp_packet.OPTION_DOMAIN_NAME : domain_name,
dhcp_packet.OPTION_DNS_DOMAIN_SEARCH_LIST : dns_search_list,
}
service = self.find_ethernet_service(
self.ethernet_pair.peer_interface_name)
manager = self.shill_proxy.manager
with shill_temporary_profile.ShillTemporaryProfile(
manager, profile_name=self.TEST_PROFILE_NAME):
self.connect_dynamic_ip(dhcp_options, service)
for params in self._static_param_list:
self.configure_static_ip(service, params)
self.connect_static_ip(dhcp_options, service, params)
self.clear_static_ip(service, params)
self.connect_dynamic_ip(dhcp_options, service)