Implement Networking Private API CreateNetwork function on Windows.

components/wifi/wifi_service_win.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/wifi/wifi_service.h"
 
 #include <iphlpapi.h>
 #include <objbase.h>
 #include <wlanapi.h>
 
 #include <set>
 
 #include "base/base_paths_win.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/registry.h"
 #include "components/onc/onc_constants.h"
+#include "third_party/libxml/chromium/libxml_utils.h"
 
 namespace {
 const char kWiFiServiceError[] = "Error.WiFiService";
 const wchar_t kNwCategoryWizardRegKey[] =
     L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Network\\"
     L"NwCategoryWizard";
 const wchar_t kNwCategoryWizardRegValue[] = L"Show";
 const wchar_t kNwCategoryWizardSavedRegValue[] = L"ShowSaved";
 const wchar_t kNwCategoryWizardDeleteRegValue[] = L"ShowDelete";
 const wchar_t kWlanApiDll[] = L"wlanapi.dll";
 
 // WlanApi function names
 const char kWlanConnect[] = "WlanConnect";
 const char kWlanCloseHandle[] = "WlanCloseHandle";
 const char kWlanDisconnect[] = "WlanDisconnect";
 const char kWlanEnumInterfaces[] = "WlanEnumInterfaces";
 const char kWlanFreeMemory[] = "WlanFreeMemory";
 const char kWlanGetAvailableNetworkList[] = "WlanGetAvailableNetworkList";
 const char kWlanGetNetworkBssList[] = "WlanGetNetworkBssList";
 const char kWlanGetProfile[] = "WlanGetProfile";
 const char kWlanOpenHandle[] = "WlanOpenHandle";
 const char kWlanQueryInterface[] = "WlanQueryInterface";
 const char kWlanRegisterNotification[] = "WlanRegisterNotification";
 const char kWlanSaveTemporaryProfile[] = "WlanSaveTemporaryProfile";
 const char kWlanScan[] = "WlanScan";
+const char kWlanSetProfile[] = "WlanSetProfile";
 
 // WlanApi function definitions
 typedef DWORD (WINAPI* WlanConnectFunction)(
     HANDLE hClientHandle,
     CONST GUID *pInterfaceGuid,
     CONST PWLAN_CONNECTION_PARAMETERS pConnectionParameters,
     PVOID pReserved);
 
 typedef DWORD (WINAPI* WlanCloseHandleFunction)(
     HANDLE hClientHandle,
@@ skipping 70 matching lines @@
     BOOL bOverWrite,
     PVOID pReserved);
 
 typedef DWORD (WINAPI* WlanScanFunction)(
     HANDLE hClientHandle,
     CONST GUID *pInterfaceGuid,
     CONST PDOT11_SSID pDot11Ssid,
     CONST PWLAN_RAW_DATA pIeData,
     PVOID pReserved);
 
+typedef DWORD (WINAPI* WlanSetProfileFunction)(
+    HANDLE hClientHandle,
+    const GUID *pInterfaceGuid,
+    DWORD dwFlags,
+    LPCWSTR strProfileXml,
+    LPCWSTR strAllUserProfileSecurity,
+    BOOL bOverwrite,
+    PVOID pReserved,
+    DWORD* pdwReasonCode);
+
+// Values for WLANProfile XML.
+const char kAuthenticationOpen[] = "open";
+const char kAuthenticationWepPsk[] = "WEP";
+const char kAuthenticationWpaPsk[] = "WPAPSK";
+const char kAuthenticationWpa2Psk[] = "WPA2PSK";
+const char kEncryptionAES[] = "AES";
+const char kEncryptionNone[] = "none";
+const char kEncryptionWEP[] = "WEP";
+const char kKeyTypeNetwork[] = "networkKey";
+const char kKeyTypePassphrase[] = "passPhrase";
+
 }  // namespace
 
 namespace wifi {
 
 // Implementation of WiFiService for Windows.
 class WiFiServiceImpl : public WiFiService, base::NonThreadSafe {
  public:
   WiFiServiceImpl();
   virtual ~WiFiServiceImpl();
 
@@ skipping 125 matching lines @@
   }
 
   // Get unique |network_guid| string based on |wlan|.
   std::string GUIDFromWLAN(const WLAN_AVAILABLE_NETWORK& wlan) const {
     return SSIDFromWLAN(wlan);
   }
 
   // Deduce |onc::wifi| security from |alg|.
   std::string SecurityFromDot11AuthAlg(DOT11_AUTH_ALGORITHM alg) const;
 
+  // Deduce WLANProfile |authEncryption| values from |onc::wifi| security.
+  bool AuthEncryptionFromSecurity(const std::string& security,
+                                  bool* security_none,
+                                  std::string* authentication,
+                                  std::string* encryption,
+                                  std::string* key_type) const;
+
   // Populate |properties| based on |wlan| and its corresponding bss info from
   // |wlan_bss_list|.
   void NetworkPropertiesFromAvailableNetwork(const WLAN_AVAILABLE_NETWORK& wlan,
                                              const WLAN_BSS_LIST& wlan_bss_list,
                                              NetworkProperties* properties);
 
   // Get the list of visible wireless networks.
   DWORD GetVisibleNetworkList(NetworkList* network_list);
 
   // Find currently connected network if any. Populate |connected_network_guid|
@@ skipping 20 matching lines @@
 
   // Get DOT11_BSSID_LIST of desired BSSIDs to connect to |ssid| network on
   // given |frequency|.
   DWORD GetDesiredBssList(DOT11_SSID& ssid,
                           Frequency frequency,
                           scoped_ptr<DOT11_BSSID_LIST>* desired_list);
 
   // Normalizes |frequency_in_mhz| into one of |Frequency| values.
   Frequency GetNormalizedFrequency(int frequency_in_mhz) const;
 
+  // Create |profile_xml| based on |network_properties|.
+  bool CreateProfile(const NetworkProperties& network_properties,
+                     std::string* profile_xml);
+
   // Save temporary wireless profile for |network_guid|.
   DWORD SaveTempProfile(const std::string& network_guid);
 
   // Get previously stored |profile_xml| for |network_guid|.
   DWORD GetProfile(const std::string& network_guid, std::string* profile_xml);
 
   // Return true if there is previously stored profile xml for |network_guid|.
   bool HaveProfile(const std::string& network_guid);
 
   // Notify |network_list_changed_observer_| that list of visible networks has
@@ skipping 15 matching lines @@
   WlanEnumInterfacesFunction WlanEnumInterfaces_function_;
   WlanFreeMemoryFunction WlanFreeMemory_function_;
   WlanGetAvailableNetworkListFunction WlanGetAvailableNetworkList_function_;
   // WlanGetNetworkBssList function may not be avaiable on Windows XP.
   WlanGetNetworkBssListFunction WlanGetNetworkBssList_function_;
   WlanGetProfileFunction WlanGetProfile_function_;
   WlanOpenHandleFunction WlanOpenHandle_function_;
   WlanQueryInterfaceFunction WlanQueryInterface_function_;
   WlanRegisterNotificationFunction WlanRegisterNotification_function_;
   WlanScanFunction WlanScan_function_;
+  WlanSetProfileFunction WlanSetProfile_function_;
   // WlanSaveTemporaryProfile function may not be avaiable on Windows XP.
   WlanSaveTemporaryProfileFunction WlanSaveTemporaryProfile_function_;
 
   // WLAN service handle.
   HANDLE client_;
   // GUID of the currently connected interface, if any, otherwise the GUID of
   // one of the WLAN interfaces.
   GUID interface_guid_;
   // Temporary storage of network properties indexed by |network_guid|. Persist
   // only in memory.
@@ skipping 26 matching lines @@
       WlanDisconnect_function_(NULL),
       WlanEnumInterfaces_function_(NULL),
       WlanFreeMemory_function_(NULL),
       WlanGetAvailableNetworkList_function_(NULL),
       WlanGetNetworkBssList_function_(NULL),
       WlanGetProfile_function_(NULL),
       WlanOpenHandle_function_(NULL),
       WlanRegisterNotification_function_(NULL),
       WlanSaveTemporaryProfile_function_(NULL),
       WlanScan_function_(NULL),
+      WlanSetProfile_function_(NULL),
       client_(NULL),
       enable_notify_network_changed_(true) {}
 
 WiFiServiceImpl::~WiFiServiceImpl() { UnInitialize(); }
 
 void WiFiServiceImpl::Initialize(
     scoped_refptr<base::SequencedTaskRunner> task_runner) {
   DCHECK(!client_);
   task_runner_.swap(task_runner);
   // Restore NwCategoryWizard in case if we crashed during connect.
@@ skipping 54 matching lines @@
   }
   connect_properties_.SetWithoutPathExpansion(network_guid,
                                               properties.release());
 }
 
 void WiFiServiceImpl::CreateNetwork(
     bool shared,
     scoped_ptr<base::DictionaryValue> properties,
     std::string* network_guid,
     std::string* error) {
-  CheckError(ERROR_CALL_NOT_IMPLEMENTED, kWiFiServiceError, error);
+  DWORD error_code = EnsureInitialized();
+  if (CheckError(error_code, kWiFiServiceError, error))
+    return;
+
+  WiFiService::NetworkProperties network_properties;
+  if (!network_properties.UpdateFromValue(*properties)) {
+    CheckError(ERROR_INVALID_DATA, kWiFiServiceError, error);
+    return;
+  }
+
+  network_properties.guid = network_properties.ssid;
+  std::string profile_xml;
+  if (!CreateProfile(network_properties, &profile_xml)) {
+    CheckError(ERROR_INVALID_DATA, kWiFiServiceError, error);
+    return;
+  }
+
+  string16 profile_xml16(UTF8ToUTF16(profile_xml));
+  DWORD reason_code = 0u;
+
+  error_code = WlanSetProfile_function_(client_,
+                                        &interface_guid_,
+                                        shared ? 0 : WLAN_PROFILE_USER,
+                                        profile_xml16.c_str(),
+                                        NULL,
+                                        FALSE,
+                                        NULL,
+                                        &reason_code);
+  if (CheckError(error_code, kWiFiServiceError, error)) {
+    DVLOG(0) << profile_xml;
+    DVLOG(0) << "SetProfile Reason Code:" << reason_code;
+    return;
+  }
+
+  *network_guid = network_properties.guid;
 }
 
 void WiFiServiceImpl::GetVisibleNetworks(const std::string& network_type,
                                          ListValue* network_list) {
   if (!network_type.empty() &&
       network_type != onc::network_type::kAllTypes &&
       network_type != onc::network_type::kWiFi) {
     return;
   }
 
@@ skipping 254 matching lines @@
           ::GetProcAddress(wlan_api_library_, kWlanQueryInterface));
   WlanRegisterNotification_function_ =
       reinterpret_cast<WlanRegisterNotificationFunction>(
           ::GetProcAddress(wlan_api_library_, kWlanRegisterNotification));
   WlanSaveTemporaryProfile_function_ =
       reinterpret_cast<WlanSaveTemporaryProfileFunction>(
           ::GetProcAddress(wlan_api_library_, kWlanSaveTemporaryProfile));
   WlanScan_function_ =
       reinterpret_cast<WlanScanFunction>(
           ::GetProcAddress(wlan_api_library_, kWlanScan));
+  WlanSetProfile_function_ =
+      reinterpret_cast<WlanSetProfileFunction>(
+          ::GetProcAddress(wlan_api_library_, kWlanSetProfile));
 
   if (!WlanConnect_function_ ||
       !WlanCloseHandle_function_ ||
       !WlanDisconnect_function_ ||
       !WlanEnumInterfaces_function_ ||
       !WlanFreeMemory_function_ ||
       !WlanGetAvailableNetworkList_function_ ||
       !WlanGetProfile_function_ ||
       !WlanOpenHandle_function_ ||
       !WlanQueryInterface_function_ ||
       !WlanRegisterNotification_function_ ||
-      !WlanScan_function_) {
+      !WlanScan_function_ ||
+      !WlanSetProfile_function_) {
     DLOG(ERROR) << "Unable to find required WlanApi function.";
     FreeLibrary(wlan_api_library_);
     wlan_api_library_ = NULL;
     return ERROR_NOT_FOUND;
   }
 
   // Some WlanApi functions may not be available on XP.
   if (!WlanGetNetworkBssList_function_ ||
       !WlanSaveTemporaryProfile_function_) {
     DVLOG(1) << "WlanApi function is not be available on XP.";
@@ skipping 159 matching lines @@
     WlanDisconnect_function_ = NULL;
     WlanEnumInterfaces_function_ = NULL;
     WlanFreeMemory_function_ = NULL;
     WlanGetAvailableNetworkList_function_ = NULL;
     WlanGetNetworkBssList_function_ = NULL;
     WlanGetProfile_function_ = NULL;
     WlanOpenHandle_function_ = NULL;
     WlanRegisterNotification_function_ = NULL;
     WlanSaveTemporaryProfile_function_ = NULL;
     WlanScan_function_ = NULL;
+    WlanSetProfile_function_ = NULL;
     ::FreeLibrary(wlan_api_library_);
     wlan_api_library_ = NULL;
   }
   return error;
 }
 
 DOT11_SSID WiFiServiceImpl::SSIDFromGUID(
     const std::string& network_guid) const {
   DOT11_SSID ssid = {0};
   if (network_guid.length() <= DOT11_SSID_MAX_LENGTH) {
@@ skipping 439 matching lines @@
 
   return error;
 }
 
 bool WiFiServiceImpl::HaveProfile(const std::string& network_guid) {
   DWORD error = ERROR_SUCCESS;
   std::string profile_xml;
   return GetProfile(network_guid, &profile_xml) == ERROR_SUCCESS;
 }
 
+bool WiFiServiceImpl::AuthEncryptionFromSecurity(
+    const std::string& security,
+    bool* security_open,
+    std::string* authentication,
+    std::string* encryption,
+    std::string* key_type) const {
+  *security_open = security == onc::wifi::kNone;
+  if (*security_open) {
+    *authentication = kAuthenticationOpen;
+    *encryption = kEncryptionNone;
+  } else if (security == onc::wifi::kWEP_PSK) {
+    *authentication = kAuthenticationOpen;
+    *encryption = kEncryptionWEP;
+    *key_type = kKeyTypeNetwork;
+  } else if (security == onc::wifi::kWPA_PSK) {
+    *authentication = kAuthenticationWpaPsk;
+    *encryption = kEncryptionAES;
+    *key_type = kKeyTypePassphrase;
+  } else if (security == onc::wifi::kWPA2_PSK) {
+    *authentication = kAuthenticationWpa2Psk;
+    *encryption = kEncryptionAES;
+    *key_type = kKeyTypePassphrase;
+  } else {
+    return false;
+  }
+  return true;
+}
+
+bool WiFiServiceImpl::CreateProfile(
+    const NetworkProperties& network_properties,
+    std::string* profile_xml) {
+  // Get authentication and encryption values from security.
+  bool security_open = true;
+  std::string authentication;
+  std::string encryption;
+  std::string key_type;
+  bool valid = AuthEncryptionFromSecurity(network_properties.security,
+                                          &security_open,

[tbarzic, 2013/12/10 19:42:39]

instead of setting |security_open| in AuthEncryptionFromSecurity (feels that the
function does a bit more than just convert security properties, as its name
suggests), I'd do this after the function returns as:

bool security_open = authentication == kAuthenticationOpen &&
                     encryption == kEncryptionNone;

(feel free to keep it as it is if you disagree on semantics)

[mef, 2013/12/10 20:51:43]

Done.

+                                          &authentication,
+                                          &encryption,
+                                          &key_type);
+  if (!valid)
+    return valid;
+
+  // Generate profile XML.
+  XmlWriter xml_writer;
+  xml_writer.StartWriting();
+  xml_writer.StartElement("WLANProfile");
+  xml_writer.AddAttribute(
+      "xmlns",
+      "http://www.microsoft.com/networking/WLAN/profile/v1");
+  xml_writer.WriteElement("name", network_properties.guid);
+  xml_writer.StartElement("SSIDConfig");
+  xml_writer.StartElement("SSID");
+  xml_writer.WriteElement("name", network_properties.ssid);
+  xml_writer.EndElement();  // Ends "SSID" element.
+  xml_writer.EndElement();  // Ends "SSIDConfig" element.
+  xml_writer.WriteElement("connectionType", "ESS");
+  xml_writer.WriteElement("connectionMode", "manual");
+  xml_writer.StartElement("MSM");
+  xml_writer.StartElement("security");
+  xml_writer.StartElement("authEncryption");
+  xml_writer.WriteElement("authentication", authentication);
+  xml_writer.WriteElement("encryption", encryption);
+  xml_writer.WriteElement("useOneX", "false");
+  xml_writer.EndElement();  // Ends "authEncryption" element.
+  if (!security_open) {
+    xml_writer.StartElement("sharedKey");
+    xml_writer.WriteElement("keyType", key_type);
+    xml_writer.WriteElement("protected", "false");
+    xml_writer.WriteElement("keyMaterial", network_properties.password);
+    xml_writer.EndElement();  // Ends "sharedKey" element.
+  }
+  xml_writer.EndElement();  // Ends "security" element.
+  xml_writer.EndElement();  // Ends "MSM" element.
+  xml_writer.EndElement();  // Ends "WLANProfile" element.
+  xml_writer.StopWriting();
+  *profile_xml = xml_writer.GetWrittenString();
+
+  return true;
+}
+
 void WiFiServiceImpl::NotifyNetworkListChanged(const NetworkList& networks) {
   if (network_list_changed_observer_.is_null())
     return;
 
   NetworkGuidList current_networks;
   for (NetworkList::const_iterator it = networks.begin();
        it != networks.end();
        ++it) {
     current_networks.push_back(it->guid);
   }
 
   message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(network_list_changed_observer_, current_networks));
 }
 
 void WiFiServiceImpl::NotifyNetworkChanged(const std::string& network_guid) {
   if (enable_notify_network_changed_ && !networks_changed_observer_.is_null()) {
     DVLOG(1) << "NotifyNetworkChanged: " << network_guid;
     NetworkGuidList changed_networks(1, network_guid);
     message_loop_proxy_->PostTask(
         FROM_HERE,
         base::Bind(networks_changed_observer_, changed_networks));
   }
 }
 
 WiFiService* WiFiService::Create() { return new WiFiServiceImpl(); }
 
 }  // namespace wifi