config.cc - aosp/platform/system/connectivity/apmanager - Git at Google

 //
 // 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
	//
	// 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