blob: 75c7229bfbbde81178a09405dcfbaf5e68acb32b [file] [log] [blame]
# Copyright 2022 The Fuchsia Authors
#
# 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
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import collections
import logging
from typing import Any, Dict, FrozenSet, List, Optional, Union
from antlion.controllers.ap_lib import hostapd_constants
from antlion.controllers.ap_lib.hostapd_bss_settings import BssSettings
from antlion.controllers.ap_lib.hostapd_security import Security
def ht40_plus_allowed(channel: int):
"""Returns: True iff HT40+ is enabled for this configuration."""
channel_supported = (
channel
in hostapd_constants.HT40_ALLOW_MAP[
hostapd_constants.N_CAPABILITY_HT40_PLUS_CHANNELS
]
)
return channel_supported
def ht40_minus_allowed(channel: int):
"""Returns: True iff HT40- is enabled for this configuration."""
channel_supported = (
channel
in hostapd_constants.HT40_ALLOW_MAP[
hostapd_constants.N_CAPABILITY_HT40_MINUS_CHANNELS
]
)
return channel_supported
def get_frequency_for_channel(channel: int):
"""The frequency associated with a given channel number.
Args:
value: channel number.
Returns:
int, frequency in MHz associated with the channel.
"""
for frequency, channel_iter in hostapd_constants.CHANNEL_MAP.items():
if channel == channel_iter:
return frequency
else:
raise ValueError("Unknown channel value: %r." % channel)
def get_channel_for_frequency(frequency: int):
"""The channel number associated with a given frequency.
Args:
value: frequency in MHz.
Returns:
int, frequency associated with the channel.
"""
return hostapd_constants.CHANNEL_MAP[frequency]
class HostapdConfig(object):
"""The root settings for the router.
All the settings for a router that are not part of an ssid.
"""
def __init__(
self,
interface: Optional[str] = None,
mode: Optional[str] = None,
channel: Optional[int] = None,
frequency: Optional[int] = None,
n_capabilities: Optional[List[Any]] = None,
beacon_interval: Optional[int] = None,
dtim_period: Optional[int] = None,
frag_threshold: Optional[int] = None,
rts_threshold: Optional[int] = None,
short_preamble: Optional[bool] = None,
ssid: Optional[str] = None,
hidden: bool = False,
security: Optional[Security] = None,
bssid: Optional[str] = None,
force_wmm: Optional[bool] = None,
pmf_support: Optional[int] = None,
obss_interval: Optional[int] = None,
vht_channel_width: Optional[Any] = None,
vht_center_channel: Optional[int] = None,
ac_capabilities: Optional[List[Any]] = None,
beacon_footer: str = "",
spectrum_mgmt_required: Optional[bool] = None,
scenario_name: Optional[str] = None,
min_streams: Optional[int] = None,
wnm_features: FrozenSet[hostapd_constants.WnmFeature] = frozenset(),
bss_settings: Optional[List[Any]] = None,
additional_parameters: Optional[Dict[str, Any]] = None,
set_ap_defaults_profile: str = "whirlwind",
) -> None:
"""Construct a HostapdConfig.
You may specify channel or frequency, but not both. Both options
are checked for validity (i.e. you can't specify an invalid channel
or a frequency that will not be accepted).
Args:
interface: The name of the interface to use.
mode: MODE_11x defined above.
channel: Channel number.
frequency: Frequency of channel.
n_capabilities: List of N_CAPABILITY_x defined above.
beacon_interval: Beacon interval of AP.
dtim_period: Include a DTIM every |dtim_period| beacons.
frag_threshold: Maximum outgoing data frame size.
rts_threshold: Maximum packet size without requiring explicit
protection via rts/cts or cts to self.
short_preamble: Whether to use a short preamble.
ssid: string, The name of the ssid to broadcast.
hidden: Should the ssid be hidden.
security: The security settings to use.
bssid: A MAC address like string for the BSSID.
force_wmm: True if we should force WMM on, False if we should
force it off, None if we shouldn't force anything.
pmf_support: One of PMF_SUPPORT_* above. Controls whether the
client supports/must support 802.11w. If None, defaults to
required with wpa3, else defaults to disabled.
obss_interval: Interval in seconds that client should be
required to do background scans for overlapping BSSes.
vht_channel_width: Object channel width
vht_center_channel: Center channel of segment 0.
ac_capabilities: List of AC_CAPABILITY_x defined above.
beacon_footer: Containing (not validated) IE data to be
placed at the end of the beacon.
spectrum_mgmt_required: True if we require the DUT to support
spectrum management.
scenario_name: To be included in file names, instead
of the interface name.
min_streams: Number of spatial streams required.
wnm_features: WNM features to enable on the AP.
control_interface: The file name to use as the control interface.
bss_settings: The settings for all bss.
additional_parameters: A dictionary of additional parameters to add
to the hostapd config.
set_ap_defaults_profile: profile name to load defaults from
"""
if n_capabilities is None:
n_capabilities = []
if ac_capabilities is None:
ac_capabilities = []
if bss_settings is None:
bss_settings = []
if additional_parameters is None:
additional_parameters = {}
self.set_ap_defaults_profile = set_ap_defaults_profile
self._interface = interface
if channel is not None and frequency is not None:
raise ValueError("Specify either frequency or channel " "but not both.")
unknown_caps = [
cap
for cap in n_capabilities
if cap not in hostapd_constants.N_CAPABILITIES_MAPPING
]
if unknown_caps:
raise ValueError("Unknown capabilities: %r" % unknown_caps)
if channel:
self.channel = channel
elif frequency:
self.frequency = frequency
else:
raise ValueError("Specify either frequency or channel.")
self._n_capabilities = set(n_capabilities)
if force_wmm is not None:
self._wmm_enabled = force_wmm
elif self._n_capabilities:
self._wmm_enabled = True
if self._n_capabilities and mode is None:
mode = hostapd_constants.MODE_11N_PURE
self._mode = mode
if not self.supports_frequency(self.frequency):
raise ValueError(
"Configured a mode %s that does not support "
"frequency %d" % (self._mode, self.frequency)
)
self._beacon_interval = beacon_interval
self._dtim_period = dtim_period
self._frag_threshold = frag_threshold
self._rts_threshold = rts_threshold
self._short_preamble = short_preamble
self._ssid = ssid
self._hidden = hidden
self._security = security
self._bssid = bssid
# Default PMF Values
if pmf_support is None:
if (
self.security
and self.security.security_mode_string == hostapd_constants.WPA3_STRING
):
# Set PMF required for WP3
self._pmf_support = hostapd_constants.PMF_SUPPORT_REQUIRED
elif (
self.security
and self.security.security_mode_string
in hostapd_constants.WPA3_MODE_STRINGS
):
# Default PMF to enabled for WPA3 mixed modes (can be
# overwritten by explicitly provided value)
self._pmf_support = hostapd_constants.PMF_SUPPORT_ENABLED
else:
# Default PMD to disabled for all other modes (can be
# overwritten by explicitly provided value)
self._pmf_support = hostapd_constants.PMF_SUPPORT_DISABLED
elif pmf_support not in hostapd_constants.PMF_SUPPORT_VALUES:
raise ValueError("Invalid value for pmf_support: %r" % pmf_support)
elif (
pmf_support != hostapd_constants.PMF_SUPPORT_REQUIRED
and self.security
and self.security.security_mode_string == hostapd_constants.WPA3_STRING
):
raise ValueError("PMF support must be required with wpa3.")
else:
self._pmf_support = pmf_support
self._obss_interval = obss_interval
if self.is_11ac:
if str(vht_channel_width) == "40" or str(vht_channel_width) == "20":
self._vht_oper_chwidth = hostapd_constants.VHT_CHANNEL_WIDTH_40
elif str(vht_channel_width) == "80":
self._vht_oper_chwidth = hostapd_constants.VHT_CHANNEL_WIDTH_80
elif str(vht_channel_width) == "160":
self._vht_oper_chwidth = hostapd_constants.VHT_CHANNEL_WIDTH_160
elif str(vht_channel_width) == "80+80":
self._vht_oper_chwidth = hostapd_constants.VHT_CHANNEL_WIDTH_80_80
elif vht_channel_width is not None:
raise ValueError("Invalid channel width")
else:
logging.warning(
"No channel bandwidth specified. Using 80MHz for 11ac."
)
self._vht_oper_chwidth = 1
if vht_center_channel is not None:
self._vht_oper_centr_freq_seg0_idx = vht_center_channel
elif vht_channel_width == 20 and channel is not None:
self._vht_oper_centr_freq_seg0_idx = channel
else:
self._vht_oper_centr_freq_seg0_idx = (
self._get_11ac_center_channel_from_channel(self.channel)
)
self._ac_capabilities = set(ac_capabilities)
self._beacon_footer = beacon_footer
self._spectrum_mgmt_required = spectrum_mgmt_required
self._scenario_name = scenario_name
self._min_streams = min_streams
self._wnm_features = wnm_features
self._additional_parameters = additional_parameters
self._bss_lookup: Dict[str, BssSettings] = collections.OrderedDict()
for bss in bss_settings:
if bss.name in self._bss_lookup:
raise ValueError(
"Cannot have multiple bss settings with the same name."
)
self._bss_lookup[bss.name] = bss
def _get_11ac_center_channel_from_channel(self, channel: int) -> int:
"""Returns the center channel of the selected channel band based
on the channel and channel bandwidth provided.
"""
channel = int(channel)
center_channel_delta = hostapd_constants.CENTER_CHANNEL_MAP[
self._vht_oper_chwidth
]["delta"]
for channel_map in hostapd_constants.CENTER_CHANNEL_MAP[self._vht_oper_chwidth][
"channels"
]:
lower_channel_bound, upper_channel_bound = channel_map
if lower_channel_bound <= channel <= upper_channel_bound:
return lower_channel_bound + center_channel_delta
raise ValueError(
"Invalid channel for {channel_width}.".format(
channel_width=self._vht_oper_chwidth
)
)
@property
def _get_default_config(self):
"""Returns: dict of default options for hostapd."""
if self.set_ap_defaults_profile == "mistral":
return collections.OrderedDict(
[
("logger_syslog", "-1"),
("logger_syslog_level", "0"),
# default RTS and frag threshold to ``off''
("rts_threshold", None),
("fragm_threshold", None),
("driver", hostapd_constants.DRIVER_NAME),
]
)
else:
return collections.OrderedDict(
[
("logger_syslog", "-1"),
("logger_syslog_level", "0"),
# default RTS and frag threshold to ``off''
("rts_threshold", "2347"),
("fragm_threshold", "2346"),
("driver", hostapd_constants.DRIVER_NAME),
]
)
@property
def _hostapd_ht_capabilities(self):
"""Returns: string suitable for the ht_capab= line in a hostapd config."""
ret = []
for cap in hostapd_constants.N_CAPABILITIES_MAPPING.keys():
if cap in self._n_capabilities:
ret.append(hostapd_constants.N_CAPABILITIES_MAPPING[cap])
return "".join(ret)
@property
def _hostapd_vht_capabilities(self):
"""Returns: string suitable for the vht_capab= line in a hostapd config."""
ret = []
for cap in hostapd_constants.AC_CAPABILITIES_MAPPING.keys():
if cap in self._ac_capabilities:
ret.append(hostapd_constants.AC_CAPABILITIES_MAPPING[cap])
return "".join(ret)
@property
def _require_ht(self):
"""Returns: True iff clients should be required to support HT."""
return self._mode == hostapd_constants.MODE_11N_PURE
@property
def _require_vht(self):
"""Returns: True if clients should be required to support VHT."""
return self._mode == hostapd_constants.MODE_11AC_PURE
@property
def hw_mode(self):
"""Returns: string hardware mode understood by hostapd."""
if self._mode == hostapd_constants.MODE_11A:
return hostapd_constants.MODE_11A
if self._mode == hostapd_constants.MODE_11B:
return hostapd_constants.MODE_11B
if self._mode == hostapd_constants.MODE_11G:
return hostapd_constants.MODE_11G
if self.is_11n or self.is_11ac:
# For their own historical reasons, hostapd wants it this way.
if self._frequency > 5000:
return hostapd_constants.MODE_11A
return hostapd_constants.MODE_11G
raise ValueError("Invalid mode.")
@property
def is_11n(self):
"""Returns: True if we're trying to host an 802.11n network."""
return self._mode in (
hostapd_constants.MODE_11N_MIXED,
hostapd_constants.MODE_11N_PURE,
)
@property
def is_11ac(self):
"""Returns: True if we're trying to host an 802.11ac network."""
return self._mode in (
hostapd_constants.MODE_11AC_MIXED,
hostapd_constants.MODE_11AC_PURE,
)
@property
def channel(self):
"""Returns: int channel number for self.frequency."""
return get_channel_for_frequency(self.frequency)
@channel.setter
def channel(self, value):
"""Sets the channel number to configure hostapd to listen on.
Args:
value: int, channel number.
"""
self.frequency = get_frequency_for_channel(value)
@property
def bssid(self) -> Optional[str]:
return self._bssid
@bssid.setter
def bssid(self, value: str):
self._bssid = value
@property
def frequency(self) -> int:
"""Returns: frequency for hostapd to listen on."""
return self._frequency
@frequency.setter
def frequency(self, value: int):
"""Sets the frequency for hostapd to listen on.
Args:
value: int, frequency in MHz.
"""
if value not in hostapd_constants.CHANNEL_MAP:
raise ValueError("Tried to set an invalid frequency: %r." % value)
self._frequency = value
@property
def bss_lookup(self) -> Dict[str, BssSettings]:
return self._bss_lookup
@property
def ssid(self) -> Optional[str]:
"""Returns: SsidSettings, The root Ssid settings being used."""
return self._ssid
@ssid.setter
def ssid(self, value: str):
"""Sets the ssid for the hostapd.
Args:
value: SsidSettings, new ssid settings to use.
"""
self._ssid = value
@property
def hidden(self):
"""Returns: bool, True if the ssid is hidden, false otherwise."""
return self._hidden
@hidden.setter
def hidden(self, value: bool):
"""Sets if this ssid is hidden.
Args:
value: If true the ssid will be hidden.
"""
self.hidden = value
@property
def security(self) -> Optional[Security]:
"""Returns: The security type being used."""
return self._security
@security.setter
def security(self, value: Security):
"""Sets the security options to use.
Args:
value: The type of security to use.
"""
self._security = value
@property
def ht_packet_capture_mode(self) -> Optional[str]:
"""Get an appropriate packet capture HT parameter.
When we go to configure a raw monitor we need to configure
the phy to listen on the correct channel. Part of doing
so is to specify the channel width for HT channels. In the
case that the AP is configured to be either HT40+ or HT40-,
we could return the wrong parameter because we don't know which
configuration will be chosen by hostap.
Returns:
string, HT parameter for frequency configuration.
"""
if not self.is_11n:
return None
if ht40_plus_allowed(self.channel):
return "HT40+"
if ht40_minus_allowed(self.channel):
return "HT40-"
return "HT20"
@property
def beacon_footer(self) -> str:
return self._beacon_footer
@beacon_footer.setter
def beacon_footer(self, value: str):
"""Changes the beacon footer.
Args:
value: The beacon footer value.
"""
self._beacon_footer = value
@property
def scenario_name(self) -> Optional[str]:
return self._scenario_name
@property
def min_streams(self) -> Optional[int]:
return self._min_streams
@property
def wnm_features(self) -> FrozenSet[hostapd_constants.WnmFeature]:
return self._wnm_features
@wnm_features.setter
def wnm_features(self, value: FrozenSet[hostapd_constants.WnmFeature]):
self._wnm_features = value
def __repr__(self) -> str:
return (
"%s(mode=%r, channel=%r, frequency=%r, "
"n_capabilities=%r, beacon_interval=%r, "
"dtim_period=%r, frag_threshold=%r, ssid=%r, bssid=%r, "
"wmm_enabled=%r, security_config=%r, "
"spectrum_mgmt_required=%r)"
% (
self.__class__.__name__,
self._mode,
self.channel,
self.frequency,
self._n_capabilities,
self._beacon_interval,
self._dtim_period,
self._frag_threshold,
self._ssid,
self._bssid,
self._wmm_enabled,
self._security,
self._spectrum_mgmt_required,
)
)
def supports_channel(self, value: int) -> bool:
"""Check whether channel is supported by the current hardware mode.
@param value: channel to check.
@return True iff the current mode supports the band of the channel.
"""
for freq, channel in hostapd_constants.CHANNEL_MAP.items():
if channel == value:
return self.supports_frequency(freq)
return False
def supports_frequency(self, frequency: int) -> bool:
"""Check whether frequency is supported by the current hardware mode.
@param frequency: frequency to check.
@return True iff the current mode supports the band of the frequency.
"""
if self._mode == hostapd_constants.MODE_11A and frequency < 5000:
return False
if (
self._mode in (hostapd_constants.MODE_11B, hostapd_constants.MODE_11G)
and frequency > 5000
):
return False
if frequency not in hostapd_constants.CHANNEL_MAP:
return False
channel = hostapd_constants.CHANNEL_MAP[frequency]
supports_plus = (
channel
in hostapd_constants.HT40_ALLOW_MAP[
hostapd_constants.N_CAPABILITY_HT40_PLUS_CHANNELS
]
)
supports_minus = (
channel
in hostapd_constants.HT40_ALLOW_MAP[
hostapd_constants.N_CAPABILITY_HT40_MINUS_CHANNELS
]
)
if (
hostapd_constants.N_CAPABILITY_HT40_PLUS in self._n_capabilities
and not supports_plus
):
return False
if (
hostapd_constants.N_CAPABILITY_HT40_MINUS in self._n_capabilities
and not supports_minus
):
return False
return True
def add_bss(self, bss: BssSettings) -> None:
"""Adds a new bss setting.
Args:
bss: The bss settings to add.
"""
if bss.name in self._bss_lookup:
raise ValueError("A bss with the same name already exists.")
self._bss_lookup[bss.name] = bss
def remove_bss(self, bss_name: str) -> None:
"""Removes a bss setting from the config."""
del self._bss_lookup[bss_name]
def package_configs(self) -> List[Dict[str, Union[str, int]]]:
"""Package the configs.
Returns:
A list of dictionaries, one dictionary for each section of the
config.
"""
# Start with the default config parameters.
conf = self._get_default_config
if self._interface:
conf["interface"] = self._interface
if self._bssid:
conf["bssid"] = self._bssid
if self._ssid:
conf["ssid"] = self._ssid
conf["ignore_broadcast_ssid"] = 1 if self._hidden else 0
conf["channel"] = self.channel
conf["hw_mode"] = self.hw_mode
if self.is_11n or self.is_11ac:
conf["ieee80211n"] = 1
conf["ht_capab"] = self._hostapd_ht_capabilities
if self.is_11ac:
conf["ieee80211ac"] = 1
conf["vht_oper_chwidth"] = self._vht_oper_chwidth
conf["vht_oper_centr_freq_seg0_idx"] = self._vht_oper_centr_freq_seg0_idx
conf["vht_capab"] = self._hostapd_vht_capabilities
if self._wmm_enabled is not None:
conf["wmm_enabled"] = 1 if self._wmm_enabled else 0
if self._require_ht:
conf["require_ht"] = 1
if self._require_vht:
conf["require_vht"] = 1
if self._beacon_interval:
conf["beacon_int"] = self._beacon_interval
if self._dtim_period:
conf["dtim_period"] = self._dtim_period
if self._frag_threshold:
conf["fragm_threshold"] = self._frag_threshold
if self._rts_threshold:
conf["rts_threshold"] = self._rts_threshold
if self._pmf_support:
conf["ieee80211w"] = self._pmf_support
if self._obss_interval:
conf["obss_interval"] = self._obss_interval
if self._short_preamble:
conf["preamble"] = 1
if self._spectrum_mgmt_required:
# To set spectrum_mgmt_required, we must first set
# local_pwr_constraint. And to set local_pwr_constraint,
# we must first set ieee80211d. And to set ieee80211d, ...
# Point being: order matters here.
conf["country_code"] = "US" # Required for local_pwr_constraint
conf["ieee80211d"] = 1 # Required for local_pwr_constraint
conf["local_pwr_constraint"] = 0 # No local constraint
conf["spectrum_mgmt_required"] = 1 # Requires local_pwr_constraint
if self._security:
for k, v in self._security.generate_dict().items():
conf[k] = v
all_conf = [conf]
for bss in self._bss_lookup.values():
bss_conf = collections.OrderedDict()
for k, v in (bss.generate_dict()).items():
bss_conf[k] = v
all_conf.append(bss_conf)
for wnm_feature in self._wnm_features:
if wnm_feature == hostapd_constants.WnmFeature.TIME_ADVERTISEMENT:
conf.update(hostapd_constants.ENABLE_WNM_TIME_ADVERTISEMENT)
elif wnm_feature == hostapd_constants.WnmFeature.WNM_SLEEP_MODE:
conf.update(hostapd_constants.ENABLE_WNM_SLEEP_MODE)
elif wnm_feature == hostapd_constants.WnmFeature.BSS_TRANSITION_MANAGEMENT:
conf.update(hostapd_constants.ENABLE_WNM_BSS_TRANSITION_MANAGEMENT)
elif wnm_feature == hostapd_constants.WnmFeature.PROXY_ARP:
conf.update(hostapd_constants.ENABLE_WNM_PROXY_ARP)
elif (
wnm_feature
== hostapd_constants.WnmFeature.IPV6_NEIGHBOR_ADVERTISEMENT_MULTICAST_TO_UNICAST
):
conf.update(
hostapd_constants.ENABLE_WNM_IPV6_NEIGHBOR_ADVERTISEMENT_MULTICAST_TO_UNICAST
)
if self._additional_parameters:
all_conf.append(self._additional_parameters)
return all_conf