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;
}