| // |
| // Copyright (C) 2014 The Android Open Source Project |
| // |
| // 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. |
| // |
| |
| #include "apmanager/config.h" |
| |
| #include <base/strings/stringprintf.h> |
| |
| #if !defined(__ANDROID__) |
| #include <chromeos/dbus/service_constants.h> |
| #else |
| #include <dbus/apmanager/dbus-constants.h> |
| #endif // __ANDROID__ |
| |
| #include "apmanager/error.h" |
| #include "apmanager/daemon.h" |
| #include "apmanager/device.h" |
| #include "apmanager/manager.h" |
| |
| using std::string; |
| |
| namespace apmanager { |
| |
| // static |
| const char Config::kHostapdConfigKeyBridgeInterface[] = "bridge"; |
| const char Config::kHostapdConfigKeyChannel[] = "channel"; |
| const char Config::kHostapdConfigKeyControlInterface[] = "ctrl_interface"; |
| const char Config::kHostapdConfigKeyControlInterfaceGroup[] = |
| "ctrl_interface_group"; |
| const char Config::kHostapdConfigKeyDriver[] = "driver"; |
| const char Config::kHostapdConfigKeyFragmThreshold[] = "fragm_threshold"; |
| const char Config::kHostapdConfigKeyHTCapability[] = "ht_capab"; |
| const char Config::kHostapdConfigKeyHwMode[] = "hw_mode"; |
| const char Config::kHostapdConfigKeyIeee80211ac[] = "ieee80211ac"; |
| const char Config::kHostapdConfigKeyIeee80211n[] = "ieee80211n"; |
| const char Config::kHostapdConfigKeyIgnoreBroadcastSsid[] = |
| "ignore_broadcast_ssid"; |
| const char Config::kHostapdConfigKeyInterface[] = "interface"; |
| const char Config::kHostapdConfigKeyRsnPairwise[] = "rsn_pairwise"; |
| const char Config::kHostapdConfigKeyRtsThreshold[] = "rts_threshold"; |
| const char Config::kHostapdConfigKeySsid[] = "ssid"; |
| const char Config::kHostapdConfigKeyWepDefaultKey[] = "wep_default_key"; |
| const char Config::kHostapdConfigKeyWepKey0[] = "wep_key0"; |
| const char Config::kHostapdConfigKeyWpa[] = "wpa"; |
| const char Config::kHostapdConfigKeyWpaKeyMgmt[] = "wpa_key_mgmt"; |
| const char Config::kHostapdConfigKeyWpaPassphrase[] = "wpa_passphrase"; |
| |
| const char Config::kHostapdHwMode80211a[] = "a"; |
| const char Config::kHostapdHwMode80211b[] = "b"; |
| const char Config::kHostapdHwMode80211g[] = "g"; |
| |
| // static |
| const uint16_t Config::kPropertyDefaultChannel = 6; |
| const uint16_t Config::kPropertyDefaultServerAddressIndex = 0; |
| const bool Config::kPropertyDefaultHiddenNetwork = false; |
| |
| // static |
| const char Config::kHostapdDefaultDriver[] = "nl80211"; |
| const char Config::kHostapdDefaultRsnPairwise[] = "CCMP"; |
| const char Config::kHostapdDefaultWpaKeyMgmt[] = "WPA-PSK"; |
| // Fragmentation threshold: disabled. |
| const int Config::kHostapdDefaultFragmThreshold = 2346; |
| // RTS threshold: disabled. |
| const int Config::kHostapdDefaultRtsThreshold = 2347; |
| |
| // static |
| const uint16_t Config::kBand24GHzChannelLow = 1; |
| const uint16_t Config::kBand24GHzChannelHigh = 13; |
| const uint32_t Config::kBand24GHzBaseFrequency = 2412; |
| const uint16_t Config::kBand5GHzChannelLow = 34; |
| const uint16_t Config::kBand5GHzChannelHigh = 165; |
| const uint16_t Config::kBand5GHzBaseFrequency = 5170; |
| |
| // static |
| const int Config::kSsidMinLength = 1; |
| const int Config::kSsidMaxLength = 32; |
| const int Config::kPassphraseMinLength = 8; |
| const int Config::kPassphraseMaxLength = 63; |
| |
| Config::Config(Manager* manager, int service_identifier) |
| : manager_(manager), |
| adaptor_( |
| manager->control_interface()->CreateConfigAdaptor( |
| this, service_identifier)) { |
| // Initialize default configuration values. |
| SetSecurityMode(kSecurityModeNone); |
| SetHwMode(kHwMode80211g); |
| SetOperationMode(kOperationModeServer); |
| SetServerAddressIndex(kPropertyDefaultServerAddressIndex); |
| SetChannel(kPropertyDefaultChannel); |
| SetHiddenNetwork(kPropertyDefaultHiddenNetwork); |
| SetFullDeviceControl(true); |
| } |
| |
| Config::~Config() {} |
| |
| // static. |
| bool Config::GetFrequencyFromChannel(uint16_t channel, uint32_t* freq) { |
| bool ret_value = true; |
| if (channel >= kBand24GHzChannelLow && channel <= kBand24GHzChannelHigh) { |
| *freq = kBand24GHzBaseFrequency + (channel - kBand24GHzChannelLow) * 5; |
| } else if (channel >= kBand5GHzChannelLow && |
| channel <= kBand5GHzChannelHigh) { |
| *freq = kBand5GHzBaseFrequency + (channel - kBand5GHzChannelLow) * 5; |
| } else { |
| ret_value = false; |
| } |
| return ret_value; |
| } |
| |
| bool Config::ValidateSsid(Error* error, const string& value) { |
| if (value.length() < kSsidMinLength || value.length() > kSsidMaxLength) { |
| Error::PopulateAndLog( |
| error, |
| Error::kInvalidArguments, |
| base::StringPrintf("SSID must contain between %d and %d characters", |
| kSsidMinLength, kSsidMaxLength), |
| FROM_HERE); |
| return false; |
| } |
| return true; |
| } |
| |
| bool Config::ValidateSecurityMode(Error* error, const string& value) { |
| if (value != kSecurityModeNone && value != kSecurityModeRSN) { |
| Error::PopulateAndLog( |
| error, |
| Error::kInvalidArguments, |
| base::StringPrintf("Invalid/unsupported security mode [%s]", |
| value.c_str()), |
| FROM_HERE); |
| return false; |
| } |
| return true; |
| } |
| |
| bool Config::ValidatePassphrase(Error* error, const string& value) { |
| if (value.length() < kPassphraseMinLength || |
| value.length() > kPassphraseMaxLength) { |
| Error::PopulateAndLog( |
| error, |
| Error::kInvalidArguments, |
| base::StringPrintf("Passphrase must contain between %d and %d characters", |
| kPassphraseMinLength, kPassphraseMaxLength), |
| FROM_HERE); |
| |
| return false; |
| } |
| return true; |
| } |
| |
| bool Config::ValidateHwMode(Error* error, const string& value) { |
| if (value != kHwMode80211a && value != kHwMode80211b && |
| value != kHwMode80211g && value != kHwMode80211n && |
| value != kHwMode80211ac) { |
| Error::PopulateAndLog( |
| error, |
| Error::kInvalidArguments, |
| base::StringPrintf("Invalid HW mode [%s]", value.c_str()), |
| FROM_HERE); |
| return false; |
| } |
| return true; |
| } |
| |
| bool Config::ValidateOperationMode(Error* error, const string& value) { |
| if (value != kOperationModeServer && value != kOperationModeBridge) { |
| Error::PopulateAndLog( |
| error, |
| Error::kInvalidArguments, |
| base::StringPrintf("Invalid operation mode [%s]", value.c_str()), |
| FROM_HERE); |
| return false; |
| } |
| return true; |
| } |
| |
| bool Config::ValidateChannel(Error* error, const uint16_t& value) { |
| if ((value >= kBand24GHzChannelLow && value <= kBand24GHzChannelHigh) || |
| (value >= kBand5GHzChannelLow && value <= kBand5GHzChannelHigh)) { |
| return true; |
| } |
| Error::PopulateAndLog(error, |
| Error::kInvalidArguments, |
| base::StringPrintf("Invalid channel [%d]", value), |
| FROM_HERE); |
| return false; |
| } |
| |
| bool Config::GenerateConfigFile(Error* error, string* config_str) { |
| // SSID. |
| string ssid = GetSsid(); |
| if (ssid.empty()) { |
| Error::PopulateAndLog(error, |
| Error::kInvalidConfiguration, |
| "SSID not specified", |
| FROM_HERE); |
| return false; |
| } |
| base::StringAppendF( |
| config_str, "%s=%s\n", kHostapdConfigKeySsid, ssid.c_str()); |
| |
| // Bridge interface is required for bridge mode operation. |
| if (GetOperationMode() == kOperationModeBridge) { |
| if (GetBridgeInterface().empty()) { |
| Error::PopulateAndLog( |
| error, |
| Error::kInvalidConfiguration, |
| "Bridge interface not specified, required for bridge mode", |
| FROM_HERE); |
| return false; |
| } |
| base::StringAppendF(config_str, |
| "%s=%s\n", |
| kHostapdConfigKeyBridgeInterface, |
| GetBridgeInterface().c_str()); |
| } |
| |
| // Channel. |
| base::StringAppendF( |
| config_str, "%s=%d\n", kHostapdConfigKeyChannel, GetChannel()); |
| |
| // Interface. |
| if (!AppendInterface(error, config_str)) { |
| return false; |
| } |
| |
| // Hardware mode. |
| if (!AppendHwMode(error, config_str)) { |
| return false; |
| } |
| |
| // Security mode configurations. |
| if (!AppendSecurityMode(error, config_str)) { |
| return false; |
| } |
| |
| // Control interface. |
| if (!control_interface_.empty()) { |
| base::StringAppendF(config_str, |
| "%s=%s\n", |
| kHostapdConfigKeyControlInterface, |
| control_interface_.c_str()); |
| base::StringAppendF(config_str, |
| "%s=%s\n", |
| kHostapdConfigKeyControlInterfaceGroup, |
| Daemon::kAPManagerGroupName); |
| } |
| |
| // Hostapd default configurations. |
| if (!AppendHostapdDefaults(error, config_str)) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool Config::ClaimDevice() { |
| if (!device_) { |
| LOG(ERROR) << "Failed to claim device: device doesn't exist."; |
| return false; |
| } |
| return device_->ClaimDevice(GetFullDeviceControl()); |
| } |
| |
| bool Config::ReleaseDevice() { |
| if (!device_) { |
| LOG(ERROR) << "Failed to release device: device doesn't exist."; |
| return false; |
| } |
| return device_->ReleaseDevice(); |
| } |
| |
| void Config::SetSsid(const string& ssid) { |
| adaptor_->SetSsid(ssid); |
| } |
| |
| string Config::GetSsid() const { |
| return adaptor_->GetSsid(); |
| } |
| |
| void Config::SetInterfaceName(const std::string& interface_name) { |
| adaptor_->SetInterfaceName(interface_name); |
| } |
| |
| string Config::GetInterfaceName() const { |
| return adaptor_->GetInterfaceName(); |
| } |
| |
| void Config::SetSecurityMode(const std::string& mode) { |
| adaptor_->SetSecurityMode(mode); |
| } |
| |
| string Config::GetSecurityMode() const { |
| return adaptor_->GetSecurityMode(); |
| } |
| |
| void Config::SetPassphrase(const std::string& passphrase) { |
| adaptor_->SetPassphrase(passphrase); |
| } |
| |
| string Config::GetPassphrase() const { |
| return adaptor_->GetPassphrase(); |
| } |
| |
| void Config::SetHwMode(const std::string& hw_mode) { |
| adaptor_->SetHwMode(hw_mode); |
| } |
| |
| string Config::GetHwMode() const { |
| return adaptor_->GetHwMode(); |
| } |
| |
| void Config::SetOperationMode(const std::string& op_mode) { |
| adaptor_->SetOperationMode(op_mode); |
| } |
| |
| string Config::GetOperationMode() const { |
| return adaptor_->GetOperationMode(); |
| } |
| |
| void Config::SetChannel(uint16_t channel) { |
| adaptor_->SetChannel(channel); |
| } |
| |
| uint16_t Config::GetChannel() const { |
| return adaptor_->GetChannel(); |
| } |
| |
| void Config::SetHiddenNetwork(bool hidden_network) { |
| adaptor_->SetHiddenNetwork(hidden_network); |
| } |
| |
| bool Config::GetHiddenNetwork() const { |
| return adaptor_->GetHiddenNetwork(); |
| } |
| |
| void Config::SetBridgeInterface(const std::string& interface_name) { |
| adaptor_->SetBridgeInterface(interface_name); |
| } |
| |
| string Config::GetBridgeInterface() const { |
| return adaptor_->GetBridgeInterface(); |
| } |
| |
| void Config::SetServerAddressIndex(uint16_t index) { |
| adaptor_->SetServerAddressIndex(index); |
| } |
| |
| uint16_t Config::GetServerAddressIndex() const { |
| return adaptor_->GetServerAddressIndex(); |
| } |
| |
| void Config::SetFullDeviceControl(bool full_control) { |
| adaptor_->SetFullDeviceControl(full_control); |
| } |
| |
| bool Config::GetFullDeviceControl() const { |
| return adaptor_->GetFullDeviceControl(); |
| } |
| |
| bool Config::AppendHwMode(Error* error, string* config_str) { |
| string hw_mode = GetHwMode(); |
| string hostapd_hw_mode; |
| if (hw_mode == kHwMode80211a) { |
| hostapd_hw_mode = kHostapdHwMode80211a; |
| } else if (hw_mode == kHwMode80211b) { |
| hostapd_hw_mode = kHostapdHwMode80211b; |
| } else if (hw_mode == kHwMode80211g) { |
| hostapd_hw_mode = kHostapdHwMode80211g; |
| } else if (hw_mode == kHwMode80211n) { |
| // Use 802.11a for 5GHz channel and 802.11g for 2.4GHz channel |
| if (GetChannel() >= 34) { |
| hostapd_hw_mode = kHostapdHwMode80211a; |
| } else { |
| hostapd_hw_mode = kHostapdHwMode80211g; |
| } |
| base::StringAppendF(config_str, "%s=1\n", kHostapdConfigKeyIeee80211n); |
| |
| // Get HT Capability. |
| string ht_cap; |
| if (!device_->GetHTCapability(GetChannel(), &ht_cap)) { |
| Error::PopulateAndLog(error, |
| Error::kInvalidConfiguration, |
| "Failed to get HT Capability", |
| FROM_HERE); |
| return false; |
| } |
| base::StringAppendF(config_str, "%s=%s\n", |
| kHostapdConfigKeyHTCapability, |
| ht_cap.c_str()); |
| } else if (hw_mode == kHwMode80211ac) { |
| if (GetChannel() >= 34) { |
| hostapd_hw_mode = kHostapdHwMode80211a; |
| } else { |
| hostapd_hw_mode = kHostapdHwMode80211g; |
| } |
| base::StringAppendF(config_str, "%s=1\n", kHostapdConfigKeyIeee80211ac); |
| |
| // TODO(zqiu): Determine VHT Capabilities based on the interface PHY's |
| // capababilites. |
| } else { |
| Error::PopulateAndLog( |
| error, |
| Error::kInvalidConfiguration, |
| base::StringPrintf("Invalid hardware mode: %s", hw_mode.c_str()), |
| FROM_HERE); |
| return false; |
| } |
| |
| base::StringAppendF( |
| config_str, "%s=%s\n", kHostapdConfigKeyHwMode, hostapd_hw_mode.c_str()); |
| return true; |
| } |
| |
| bool Config::AppendHostapdDefaults(Error* error, string* config_str) { |
| // Driver: NL80211. |
| base::StringAppendF( |
| config_str, "%s=%s\n", kHostapdConfigKeyDriver, kHostapdDefaultDriver); |
| |
| // Fragmentation threshold: disabled. |
| base::StringAppendF(config_str, |
| "%s=%d\n", |
| kHostapdConfigKeyFragmThreshold, |
| kHostapdDefaultFragmThreshold); |
| |
| // RTS threshold: disabled. |
| base::StringAppendF(config_str, |
| "%s=%d\n", |
| kHostapdConfigKeyRtsThreshold, |
| kHostapdDefaultRtsThreshold); |
| |
| return true; |
| } |
| |
| bool Config::AppendInterface(Error* error, string* config_str) { |
| string interface = GetInterfaceName(); |
| if (interface.empty()) { |
| // Ask manager for unused ap capable device. |
| device_ = manager_->GetAvailableDevice(); |
| if (!device_) { |
| Error::PopulateAndLog( |
| error, Error::kInternalError, "No device available", FROM_HERE); |
| return false; |
| } |
| } else { |
| device_ = manager_->GetDeviceFromInterfaceName(interface); |
| if (!device_) { |
| Error::PopulateAndLog( |
| error, |
| Error::kInvalidConfiguration, |
| base::StringPrintf( |
| "Unable to find device for the specified interface [%s]", |
| interface.c_str()), |
| FROM_HERE); |
| return false; |
| } |
| if (device_->GetInUse()) { |
| Error::PopulateAndLog( |
| error, |
| Error::kInvalidConfiguration, |
| base::StringPrintf("Device [%s] for interface [%s] already in use", |
| device_->GetDeviceName().c_str(), |
| interface.c_str()), |
| FROM_HERE); |
| return false; |
| } |
| } |
| |
| // Use the preferred AP interface from the device. |
| selected_interface_ = device_->GetPreferredApInterface(); |
| base::StringAppendF(config_str, |
| "%s=%s\n", |
| kHostapdConfigKeyInterface, |
| selected_interface_.c_str()); |
| return true; |
| } |
| |
| bool Config::AppendSecurityMode(Error* error, string* config_str) { |
| string security_mode = GetSecurityMode(); |
| if (security_mode == kSecurityModeNone) { |
| // Nothing need to be done for open network. |
| return true; |
| } |
| |
| if (security_mode == kSecurityModeRSN) { |
| string passphrase = GetPassphrase(); |
| if (passphrase.empty()) { |
| Error::PopulateAndLog( |
| error, |
| Error::kInvalidConfiguration, |
| base::StringPrintf("Passphrase not set for security mode: %s", |
| security_mode.c_str()), |
| FROM_HERE); |
| return false; |
| } |
| |
| base::StringAppendF(config_str, "%s=2\n", kHostapdConfigKeyWpa); |
| base::StringAppendF(config_str, |
| "%s=%s\n", |
| kHostapdConfigKeyRsnPairwise, |
| kHostapdDefaultRsnPairwise); |
| base::StringAppendF(config_str, |
| "%s=%s\n", |
| kHostapdConfigKeyWpaKeyMgmt, |
| kHostapdDefaultWpaKeyMgmt); |
| base::StringAppendF(config_str, |
| "%s=%s\n", |
| kHostapdConfigKeyWpaPassphrase, |
| passphrase.c_str()); |
| return true; |
| } |
| |
| Error::PopulateAndLog( |
| error, |
| Error::kInvalidConfiguration, |
| base::StringPrintf("Invalid security mode: %s", security_mode.c_str()), |
| FROM_HERE); |
| return false; |
| } |
| |
| } // namespace apmanager |
