HRESULT CWlanManager::StartHostedNetwork() { HRESULT hr = S_OK; DWORD dwError = ERROR_SUCCESS; Lock(); if (!m_Initialized) { BAIL_ON_WIN32_ERROR(ERROR_INVALID_STATE, hr); } // if (wlan_hosted_network_active == m_HostedNetworkState) // { // BAIL_ON_WIN32_ERROR(ERROR_INVALID_STATE, hr); // } // // Start hosted network // dwError = WlanHostedNetworkStartUsing( m_WlanHandle, NULL, NULL ); BAIL_ON_WIN32_ERROR(dwError, hr); error: Unlock(); return hr; }
bool Wlan::StartHostedNet( const char * ssid, const char * key, int maxPeers ) { bool result = false; if (OpenHandle()) { WLAN_HOSTED_NETWORK_REASON reason = {}; WLAN_HOSTED_NETWORK_CONNECTION_SETTINGS settings = {}; settings.dwMaxNumberOfPeers = maxPeers; size_t ssidLen = strlen( ssid ); settings.hostedNetworkSSID.uSSIDLength = ssidLen; memcpy( settings.hostedNetworkSSID.ucSSID, (void*) ssid, ssidLen ); if (WlanHostedNetworkSetProperty( m_handle, WLAN_HOSTED_NETWORK_OPCODE::wlan_hosted_network_opcode_connection_settings, sizeof( WLAN_HOSTED_NETWORK_CONNECTION_SETTINGS ), &settings, &reason, NULL ) == ERROR_SUCCESS) { size_t keyLength = strlen( key ) + 1; if (WlanHostedNetworkSetSecondaryKey( m_handle, keyLength, (PUCHAR) key, TRUE, TRUE, &reason, NULL ) == ERROR_SUCCESS) { result = (WlanHostedNetworkStartUsing( m_handle, &reason, NULL ) == ERROR_SUCCESS); } } } return result; }
int MainWindow::checkWlanHosteed(){ DWORD dwError = 0; DWORD dwServiceVersion = 0; HANDLE hClient = NULL; if (ERROR_SUCCESS != (dwError = WlanOpenHandle( WLAN_API_VERSION, NULL, // reserved &dwServiceVersion, &hClient ))) { return dwError; } // check service version if (WLAN_API_VERSION_MAJOR(dwServiceVersion) < WLAN_API_VERSION_MAJOR(WLAN_API_VERSION_2_0)) { WlanCloseHandle(hClient, NULL); return -1; } std::string strSSID = "test"; std::string strSecondaryKey = "123456780"; // Set the network mode to allow BOOL bIsAllow = TRUE; WLAN_HOSTED_NETWORK_REASON dwFailedReason; DWORD dwReturnValue = WlanHostedNetworkSetProperty(hClient, wlan_hosted_network_opcode_enable, sizeof(BOOL), &bIsAllow, &dwFailedReason, NULL); if(ERROR_SUCCESS != dwReturnValue) { return dwReturnValue; } // Set the network SSID and the maximum number of connections WLAN_HOSTED_NETWORK_CONNECTION_SETTINGS wlanConnectionSetting; memset(&wlanConnectionSetting, 0, sizeof(WLAN_HOSTED_NETWORK_CONNECTION_SETTINGS)); // The SSID field in WLAN_HOSTED_NETWORK_CONNECTION_SETTINGS must be of type ANSI, so if the program uses the Unicode, you need to do the conversion. #ifdef _UNICODE WideCharToMultiByte(CP_ACP, 0, strSSID.c_str(), // Save SSID CString types strSSID.length(), // SSID the length of a string (LPSTR)wlanConnectionSetting.hostedNetworkSSID.ucSSID, 32, NULL, NULL); #else memcpy(wlanConnectionSetting.hostedNetworkSSID.ucSSID, strSSID.c_str(), strlen(strSSID.c_str())); #endif wlanConnectionSetting.hostedNetworkSSID.uSSIDLength = strlen((const char*)wlanConnectionSetting.hostedNetworkSSID.ucSSID); wlanConnectionSetting.dwMaxNumberOfPeers = 100; dwReturnValue = WlanHostedNetworkSetProperty(hClient, wlan_hosted_network_opcode_connection_settings, sizeof(WLAN_HOSTED_NETWORK_CONNECTION_SETTINGS), &wlanConnectionSetting, &dwFailedReason, NULL); if(ERROR_SUCCESS != dwReturnValue) { return dwReturnValue; } UCHAR keyBuf[100] = {0}; #ifdef _UNICODE WideCharToMultiByte(CP_ACP, 0, strSecondaryKey.c_str(), strSecondaryKey.length(), (LPSTR)keyBuf, 100, NULL, NULL); #else memcpy(keyBuf, strSecondaryKey.c_str(), strSecondaryKey.length()); #endif dwReturnValue = WlanHostedNetworkSetSecondaryKey(hClient, strlen((const char*)keyBuf) + 1, keyBuf, TRUE, FALSE, &dwFailedReason, NULL); if(ERROR_SUCCESS != dwReturnValue) { return dwReturnValue; } dwReturnValue = WlanHostedNetworkStartUsing(hClient, &dwFailedReason, NULL); if(ERROR_SUCCESS != dwReturnValue) { if (wlan_hosted_network_reason_interface_unavailable == dwFailedReason) { return dwFailedReason; } return dwReturnValue; } /*PIP_ADAPTER_INFO pAdapterInfo; pAdapterInfo = (IP_ADAPTER_INFO *) malloc(sizeof(IP_ADAPTER_INFO)); ULONG buflen = sizeof(IP_ADAPTER_INFO); if(GetAdaptersInfo(pAdapterInfo, &buflen) == ERROR_BUFFER_OVERFLOW) { free(pAdapterInfo); pAdapterInfo = (IP_ADAPTER_INFO *) malloc(buflen); } if(GetAdaptersInfo(pAdapterInfo, &buflen) == NO_ERROR) { PIP_ADAPTER_INFO pAdapter = pAdapterInfo; while (pAdapter) { QString str = QString("\tAdapter Name: \t%1\n\ \tAdapter Desc: \t%2\n\ \tIP Address: \t%3\n\ \tGateway: \t%4\n").arg(pAdapter->AdapterName) .arg(pAdapter->Description) //.arg((byte*)pAdapter->Address) .arg(pAdapter->IpAddressList.IpAddress.String) .arg(pAdapter->GatewayList.IpAddress.String); pAdapter = pAdapter->Next; QMessageBox msg(this); msg.setText(str); msg.exec(); } } else { printf("Call to GetAdaptersInfo failed.\n"); }*/ CoInitialize (NULL); // init security to enum RAS connections CoInitializeSecurity (NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_PKT, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, NULL); INetSharingManager * pNSM = NULL; HRESULT hr = ::CoCreateInstance (__uuidof(NetSharingManager), NULL, CLSCTX_ALL, __uuidof(INetSharingManager), (void**)&pNSM); if(hr == S_OK){ // in case it exists already //DeletePortMapping (pNSM, NAT_PROTOCOL_TCP, 555); // add a port mapping to every shared or firewalled connection. hr = DoTheWork (pNSM); pNSM->Release(); if (hr!= S_OK){ return hr; } }else return hr; return 0; }
//Performs legwork of configuring and starting the wireless hosted network bool HostedNetworkController::initialize(QString networkName, QString networkPassword) { /* Create variables to receive the result of Wlan API calls */ HRESULT result; //HRESULT to store the return value PWLAN_HOSTED_NETWORK_REASON pHostedNetworkFailReason = nullptr; //Pointer to the specific call failure reason DWORD negotiatedVersion = 0; //DWORD for the Wlan API to store the negotiated API version in if (wlanHandle == 0) { /* Open a handle to the Wlan API */ DWORD negotiatedVersion = 0; //DWORD for the Wlan API to store the negotiated API version in result = WlanOpenHandle( WLAN_API_VERSION_2_0, //Request API version 2.0 nullptr, //Reserved &negotiatedVersion, //Address of the DWORD to store the negotiated version &wlanHandle //Address of the HANDLE to store the Wlan handle ); if (result != NO_ERROR) { /* Something went wrong */ MessageBox(nullptr, reinterpret_cast<const wchar_t*>(QString( ("Unable to open a handle to the Wlan API. Error: \n ") + QString::fromWCharArray(_com_error(result).ErrorMessage()) ).utf16()), L"Inssidious failed to start.", MB_OK); ExitProcess(1); } } /* Stop any existing running Hosted Network */ emit hostedNetworkMessage("Stopping any currently running Hosted Networks.", HOSTED_NETWORK_STARTING); result = WlanHostedNetworkForceStop( wlanHandle, //Wlan handle pHostedNetworkFailReason, //Pointer to where the API can store a failure reason in nullptr //Reserved ); if (result != NO_ERROR) { emit hostedNetworkMessage("Unable to stop an existing, running Hosted Network. Error: \n " + QString::fromWCharArray(_com_error(result).ErrorMessage()), HOSTED_NETWORK_STARTING_FAILED); return false; } /* Prepare the network name in the appropriate SSID format */ DOT11_SSID hostedNetworkSSID; //DOT11_SSID struct to use later with WLAN_HOSTED_NETWORK_CONNECTION_SETTINGS hostedNetworkSSID.uSSIDLength = networkName.count();//Set the length of the array in th uSSIDLength struct value for (int i = 0; i < networkName.count(); i++) //Fill the ucSSID array { hostedNetworkSSID.ucSSID[i] = networkName.at(i).unicode(); } /* Initialize the WLAN_HOSTED_NETWORK_CONNECTION_SETTINGS with the SSID and max peer count */ /* And Set the Hosted Network network name and peer count */ emit hostedNetworkMessage("Setting the network name and password.", HOSTED_NETWORK_STARTING); WLAN_HOSTED_NETWORK_CONNECTION_SETTINGS hostedNetworkConnectionSettings{ hostedNetworkSSID, maxNumberOfPeers }; result = WlanHostedNetworkSetProperty( wlanHandle, //Wlan handle wlan_hosted_network_opcode_connection_settings, //Type of data being passed to the API sizeof(hostedNetworkConnectionSettings), //Size of the data at the pointer to hosted network connection settings static_cast<PVOID>(&hostedNetworkConnectionSettings), //Pointer to the hosted network connection settings we are setting pHostedNetworkFailReason, //Pointer to where the API can store a failure reason in nullptr //Reserved ); if (result != NO_ERROR) { emit hostedNetworkMessage("Unable to set hosted network settings. Error: \n " + QString::fromWCharArray(_com_error(result).ErrorMessage()), HOSTED_NETWORK_STARTING_FAILED); return false; } /* Prepare the network password in the appropriate UCHAR format */ DWORD dwKeyLength = networkPassword.count() + 1; //Length of the network password, needed for the API call, +1 for the null PUCHAR pucKeyData = new UCHAR[dwKeyLength]; //Initialize our UCHAR variable for (int i = 0; i < networkPassword.count(); i++) //Fill the array { pucKeyData[i] = networkPassword.at(i).unicode(); pucKeyData[i + 1] = '\0'; //null the next character to ensure we have a null at the end of the loop } /* Set the Hosted Network password */ result = WlanHostedNetworkSetSecondaryKey( wlanHandle, //Wlan handle dwKeyLength, //Length of the network password array including the null character pucKeyData, //Pointer to a UCHAR array with the network password TRUE, //Is a pass phrase TRUE, //Do not persist this key for future hosted network sessions pHostedNetworkFailReason, //Pointer to where the API can store a failure reason in nullptr //Reserved ); if (result != NO_ERROR) { emit hostedNetworkMessage("Unable to set hosted network password. Error: \n " + QString::fromWCharArray(_com_error(result).ErrorMessage()), HOSTED_NETWORK_STARTING_FAILED); return false; } /* Save the hosted network settings */ emit hostedNetworkMessage("Saving the hosted network settings.", HOSTED_NETWORK_STARTING); result = WlanHostedNetworkInitSettings( wlanHandle, //Wlan handle pHostedNetworkFailReason, //Pointer to where the API can store a failure reason in nullptr //Reserved ); if (result != NO_ERROR) { emit hostedNetworkMessage("Unable to save hosted network settings. Error: \n " + QString::fromWCharArray(_com_error(result).ErrorMessage()), HOSTED_NETWORK_STARTING_FAILED); return false; } /* Start the Hosted Network */ emit hostedNetworkMessage("Starting the Hosted Network.", HOSTED_NETWORK_STARTING); result = WlanHostedNetworkStartUsing( wlanHandle, //Wlan handle pHostedNetworkFailReason, //Pointer to where the API can store a failure reason in nullptr //Reserved ); if (result != NO_ERROR) { emit hostedNetworkMessage("Unable to start the wireless hosted network. Error: \n " + QString::fromWCharArray(_com_error(result).ErrorMessage()), HOSTED_NETWORK_STARTING_FAILED); return false; } /* Register to receive hosted network related notifications in our callback function */ result = WlanRegisterNotification( wlanHandle, //Wlan handle WLAN_NOTIFICATION_SOURCE_HNWK, //Specifically receive Hosted Network notifications TRUE, //Don't send duplicate notifications &WlanNotificationCallback, //WLAN_NOTIFICATION_CALLBACK function to call with notifactions this, //Context to pass along with the notification nullptr, //Reserved nullptr //Previously registered notification sources ); if (result != NO_ERROR) { emit hostedNetworkMessage("Unable to register for Wlan Hosted Network Notifications. Error: \n" + QString::fromWCharArray(_com_error(result).ErrorMessage()), HOSTED_NETWORK_STARTING_FAILED); return false; } /* Check the hosted network status */ int loop30 = 0; PWLAN_HOSTED_NETWORK_STATUS pHostedNetworkStatus = nullptr; while (loop30 < 30) { loop30++; pHostedNetworkStatus = nullptr; result = WlanHostedNetworkQueryStatus( wlanHandle, //Wlan handle &pHostedNetworkStatus, //Pointer to a pointer for HOSTED_NETWORK_STATUS nullptr //Reserved ); if (result != NO_ERROR) { Sleep(500); continue; } else { break; } } /* Left the loop */ if (result != NO_ERROR || !pHostedNetworkStatus) { emit hostedNetworkMessage("Unable to query hosted network status. Error: \n " + QString::fromWCharArray(_com_error(result).ErrorMessage()), HOSTED_NETWORK_STARTING_FAILED); return false; } /* The Hosted Network started. Free memory, emit the status, save the network GUID, and return true */ hostedNetworkGUID = pHostedNetworkStatus->IPDeviceID; WlanFreeMemory(pHostedNetworkStatus); pHostedNetworkStatus = nullptr; emit hostedNetworkMessage("Hosted Network started successfully.", HOSTED_NETWORK_STARTED); return true; }