able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/layer2svc/dialog/quickcfg.cpp

1433 lines
47 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include <precomp.h>
#include "wzcatl.h"
#include "quickcfg.h"
#include "eapolcfg.h"
#include "wzccore.h"
#include "wzchelp.h"
#define RFSH_TIMEOUT 3500
UINT g_TimerID = 373;
// g_wszHiddWebK is a string of 26 bullets (0x25cf - the hidden password char) and a NULL
WCHAR g_wszHiddWepK[] = {0x25cf, 0x25cf, 0x25cf, 0x25cf, 0x25cf, 0x25cf, 0x25cf, 0x25cf, 0x25cf, 0x25cf, 0x25cf, 0x25cf, 0x25cf,
0x25cf, 0x25cf, 0x25cf, 0x25cf, 0x25cf, 0x25cf, 0x25cf, 0x25cf, 0x25cf, 0x25cf, 0x25cf, 0x25cf, 0x25cf, 0x0000};
#define ARRAYSIZE(x) (sizeof((x)) / sizeof((x)[0]))
// Enhanced message box function
int DisplayFormatMessage(HWND hwnd, UINT idCaption, UINT idFormatString, UINT uType, ...);
//+---------------------------------------------------------------------------
// checks the validity of the WEP Key material and selects the
// material from the first invalid char (non hexa in hexa format or longer
// than the specified length
DWORD
CWZCQuickCfg::GetWepKMaterial(UINT *pnKeyLen, LPBYTE *ppbKMat, DWORD *pdwCtlFlags)
{
DWORD dwErr = ERROR_SUCCESS;
UINT nKeyLen = ::GetWindowTextLength(m_hEdtWepK);
DWORD dwCtlFlags = 0;
LPSTR pszKMat = NULL;
// we only accept the follwing material for WEP keys:
// - no text (length 0) => there is no WEP key provided
// - 5 chars or 10 hexadecimal digits (5byte / 40bit key)
// - 13 chars or 26 hexadecimal digits (13byte / 104bit key)
// - 16 chars or 32 hexadecimal digits (16byte / 128bit key)
if (nKeyLen != 0 &&
nKeyLen != WZC_WEPKMAT_40_ASC && nKeyLen != WZC_WEPKMAT_40_HEX &&
nKeyLen != WZC_WEPKMAT_104_ASC && nKeyLen != WZC_WEPKMAT_104_HEX &&
nKeyLen != WZC_WEPKMAT_128_ASC && nKeyLen != WZC_WEPKMAT_128_HEX)
{
dwErr = ERROR_INVALID_DATA;
}
else if (nKeyLen != 0) // the key is either ascii or hexadecimal, 40 or 104bit
{
dwCtlFlags = WZCCTL_WEPK_PRESENT;
pszKMat = new CHAR[nKeyLen + 1];
if (pszKMat == NULL)
dwErr = ERROR_NOT_ENOUGH_MEMORY;
// get the current key material from the edit control
if (dwErr == ERROR_SUCCESS)
{
if (nKeyLen != ::GetWindowTextA(m_hEdtWepK, pszKMat, nKeyLen+1))
dwErr = GetLastError();
}
// now we have the key material
if (dwErr == ERROR_SUCCESS)
{
// if the key is provided in hexadecimal digits, mark it in
// the ctl flags and do the conversion
if (nKeyLen == WZC_WEPKMAT_40_HEX || nKeyLen == WZC_WEPKMAT_104_HEX || nKeyLen == WZC_WEPKMAT_128_HEX)
{
UINT i = 0, j = 0;
dwCtlFlags |= WZCCTL_WEPK_XFORMAT;
while (i < nKeyLen && pszKMat[i] != '\0')
{
BYTE chHexByte = 0;
if (!isxdigit(pszKMat[i]) || !isxdigit(pszKMat[i+1]))
{
dwErr = ERROR_INVALID_DATA;
break;
}
chHexByte = HEX(pszKMat[i]) << 4;
i++;
chHexByte |= HEX(pszKMat[i]);
i++;
pszKMat[j++] = chHexByte;
}
// if everything went fine, since we parsed hexadecimal digits
// it means the real length is half of the text length (two hexadecimal
// digits per byte)
if (dwErr == ERROR_SUCCESS)
nKeyLen /= 2;
}
}
}
if (dwErr == ERROR_SUCCESS)
{
if (pdwCtlFlags != NULL)
*pdwCtlFlags = dwCtlFlags;
if (pnKeyLen != NULL)
*pnKeyLen = nKeyLen;
if (ppbKMat != NULL)
*ppbKMat = (LPBYTE)pszKMat;
else if (pszKMat != NULL)
delete pszKMat;
}
else
{
if (pszKMat != NULL)
delete pszKMat;
}
return dwErr;
}
//+---------------------------------------------------------------------
// IsConfigInList - checks whether the pwzcConfig (WZC_WLAN_CONFIG object) is
// in the list provided as the first parameter.
BOOL
CWZCQuickCfg::IsConfigInList(CWZCConfig *pHdList, PWZC_WLAN_CONFIG pwzcConfig, CWZCConfig **ppMatchingConfig)
{
BOOL bYes = FALSE;
if (pHdList != NULL)
{
CWZCConfig *pwzcCrt;
pwzcCrt = pHdList;
do
{
if (pwzcCrt->Match(pwzcConfig))
{
if (ppMatchingConfig != NULL)
*ppMatchingConfig = pwzcCrt;
bYes = TRUE;
break;
}
pwzcCrt = pwzcCrt->m_pNext;
} while(pwzcCrt != pHdList);
}
return bYes;
}
//+---------------------------------------------------------------------
// InitListView - initializes the networks list view (doesn't fill it in)
DWORD
CWZCQuickCfg::InitListView()
{
RECT rc;
LV_COLUMN lvc = {0};
DWORD dwStyle;
// initialize the image list styles
dwStyle = ::GetWindowLong(m_hLstNetworks, GWL_STYLE);
::SetWindowLong(m_hLstNetworks, GWL_STYLE, (dwStyle | LVS_SHAREIMAGELISTS));
// Create state image lists
m_hImgs = ImageList_LoadImage(
_Module.GetResourceInstance(),
MAKEINTRESOURCE(IDB_WZC_LISTICONS),
16,
0,
PALETTEINDEX(6),
IMAGE_BITMAP,
0);
ListView_SetImageList(m_hLstNetworks, m_hImgs, LVSIL_SMALL);
lvc.mask = LVCF_FMT | LVCF_WIDTH;
lvc.fmt = LVCFMT_LEFT;
::GetClientRect(m_hLstNetworks, &rc);
lvc.cx = rc.right - GetSystemMetrics(SM_CXVSCROLL);
//lvc.cx = rc.right;
ListView_InsertColumn(m_hLstNetworks, 0, &lvc);
ListView_SetExtendedListViewStyleEx(m_hLstNetworks, LVS_EX_FULLROWSELECT, LVS_EX_FULLROWSELECT);
return ERROR_SUCCESS;
}
//+---------------------------------------------------------------------
// GetOIDs - gets the OIDs for the m_IntfEntry member. It assumes the
// GUID is set already
DWORD
CWZCQuickCfg::GetOIDs(DWORD dwInFlags, LPDWORD pdwOutFlags)
{
DWORD dwError = ERROR_SUCCESS;
DWORD dwOutFlags;
if (m_IntfEntry.wszGuid == NULL)
{
m_IntfEntry.wszGuid = (LPWSTR)RpcCAlloc(sizeof(WCHAR)*GUID_NCH);
if (m_IntfEntry.wszGuid == NULL)
{
dwError = GetLastError();
}
else
{
// don't care of the return code. If getting the GUID fails (it shouldn't)
// then we end up with a "0000..." GUID which will fail anyhow in the
// RPC call later
StringFromGUID2(
m_Guid,
m_IntfEntry.wszGuid,
GUID_NCH);
}
}
if (dwError == ERROR_SUCCESS)
{
if (dwInFlags & INTF_DESCR)
{
RpcFree(m_IntfEntry.wszDescr);
m_IntfEntry.wszDescr = NULL;
}
if (dwInFlags & INTF_PREFLIST)
{
RpcFree(m_IntfEntry.rdStSSIDList.pData);
m_IntfEntry.rdStSSIDList.dwDataLen = 0;
m_IntfEntry.rdStSSIDList.pData = NULL;
}
if (dwInFlags & INTF_SSID)
{
RpcFree(m_IntfEntry.rdSSID.pData);
m_IntfEntry.rdSSID.dwDataLen = 0;
m_IntfEntry.rdSSID.pData = NULL;
}
if (dwInFlags & INTF_BSSID)
{
RpcFree(m_IntfEntry.rdBSSID.pData);
m_IntfEntry.rdBSSID.dwDataLen = 0;
m_IntfEntry.rdBSSID.pData = NULL;
}
if (dwInFlags & INTF_BSSIDLIST)
{
RpcFree(m_IntfEntry.rdBSSIDList.pData);
m_IntfEntry.rdBSSIDList.dwDataLen = 0;
m_IntfEntry.rdBSSIDList.pData = NULL;
}
dwError = WZCQueryInterface(
NULL,
dwInFlags,
&m_IntfEntry,
pdwOutFlags);
}
return dwError;
}
//+---------------------------------------------------------------------
// SavePreferredConfigs - fills in the INTF_ENTRY parameter with all
// the preferred networks from the m_pHdPList
DWORD
CWZCQuickCfg::SavePreferredConfigs(PINTF_ENTRY pIntf, CWZCConfig *pStartCfg)
{
DWORD dwErr = ERROR_SUCCESS;
CWZCConfig *pCrt = NULL;
UINT nPrefrd = 0;
if (m_pHdPList != NULL)
{
// count first the number of preferred entries in the list
pCrt = m_pHdPList;
do
{
nPrefrd++;
pCrt = pCrt->m_pNext;
} while(pCrt != m_pHdPList);
}
if (nPrefrd > 0)
{
PWZC_802_11_CONFIG_LIST pwzcPrefrdList;
UINT nwzcPrefrdSize;
nwzcPrefrdSize = sizeof(WZC_802_11_CONFIG_LIST)+ (nPrefrd-1)*sizeof(WZC_WLAN_CONFIG);
// allocate as much memory as needed for storing all the preferred SSIDs
pwzcPrefrdList = (PWZC_802_11_CONFIG_LIST)RpcCAlloc(nwzcPrefrdSize);
if (pwzcPrefrdList == NULL)
{
dwErr = GetLastError();
}
else
{
DWORD dwLErr;
pwzcPrefrdList->NumberOfItems = 0;
pwzcPrefrdList->Index = 0;
// we have now all we need - start copying the preferred
pCrt = m_pHdPList;
do
{
PWZC_WLAN_CONFIG pPrefrdConfig;
// if this is the configuration that needs to attempted first,
// mark its index in the Index field.
if (pCrt == pStartCfg)
{
pwzcPrefrdList->Index = pwzcPrefrdList->NumberOfItems;
// save the 802.1x configuration just for the configuration we're connecting to!
if (pCrt->m_pEapolConfig != NULL)
{
dwLErr = pCrt->m_pEapolConfig->SaveEapolConfig(m_IntfEntry.wszGuid, &(pCrt->m_wzcConfig.Ssid));
if (dwErr == ERROR_SUCCESS)
dwErr = dwLErr;
}
}
pPrefrdConfig = &(pwzcPrefrdList->Config[pwzcPrefrdList->NumberOfItems++]);
CopyMemory(pPrefrdConfig, &pCrt->m_wzcConfig, sizeof(WZC_WLAN_CONFIG));
pCrt = pCrt->m_pNext;
} while(pwzcPrefrdList->NumberOfItems < nPrefrd && pCrt != m_pHdPList);
pIntf->rdStSSIDList.dwDataLen = nwzcPrefrdSize;
pIntf->rdStSSIDList.pData = (LPBYTE)pwzcPrefrdList;
}
}
else
{
pIntf->rdStSSIDList.dwDataLen = 0;
pIntf->rdStSSIDList.pData = NULL;
}
return dwErr;
}
//+---------------------------------------------------------------------
// FillVisibleList - fills in the configs from the WZC_802_11_CONFIG_LIST object
// into the list of visible configs
DWORD
CWZCQuickCfg::FillVisibleList(PWZC_802_11_CONFIG_LIST pwzcVList)
{
DWORD dwErr = ERROR_SUCCESS;
UINT i;
// cleanup whatever we might already have in the visible list
if (m_pHdVList != NULL)
{
while (m_pHdVList->m_pNext != m_pHdVList)
{
delete m_pHdVList->m_pNext;
}
delete m_pHdVList;
m_pHdVList = NULL;
}
if (pwzcVList != NULL)
{
for (i = 0; i < pwzcVList->NumberOfItems; i++)
{
dwErr = AddUniqueConfig(
0, // no op flags
WZC_DESCR_VISIBLE, // this is a visible entry
&(pwzcVList->Config[i]));
// reset the error if config was just duplicated
if (dwErr == ERROR_DUPLICATE_TAG)
dwErr = ERROR_SUCCESS;
}
}
return dwErr;
}
//+---------------------------------------------------------------------
// FillPreferredList - fills in the configs from the WZC_802_11_CONFIG_LIST object
// into the list of preferred configs
DWORD
CWZCQuickCfg::FillPreferredList(PWZC_802_11_CONFIG_LIST pwzcPList)
{
DWORD dwErr = ERROR_SUCCESS;
UINT i;
// cleanup whatever we might already have in the preferred list
if (m_pHdPList != NULL)
{
while (m_pHdPList ->m_pNext != m_pHdPList)
{
delete m_pHdPList ->m_pNext;
}
delete m_pHdPList;
m_pHdPList = NULL;
}
if (pwzcPList != NULL)
{
for (i = 0; i < pwzcPList->NumberOfItems; i++)
{
PWZC_WLAN_CONFIG pwzcPConfig = &(pwzcPList->Config[i]);
CWZCConfig *pVConfig = NULL;
DWORD dwFlags = WZC_DESCR_PREFRD;
// check whether this preferred is also visible and adjust dwFlags if so
if (IsConfigInList(m_pHdVList, pwzcPConfig, &pVConfig))
{
// mark the visible entry as being also preferred!
// NOTE: This is why the visible list needs to be filled in first!
pVConfig->m_dwFlags |= WZC_DESCR_PREFRD;
dwFlags |= WZC_DESCR_VISIBLE;
}
dwErr = AddUniqueConfig(
WZCADD_OVERWRITE, // preferred entries cause info to be overwritten
dwFlags,
pwzcPConfig);
// reset the error if config was just duplicated
if (dwErr == ERROR_DUPLICATE_TAG)
dwErr = ERROR_SUCCESS;
}
}
return dwErr;
}
//+---------------------------------------------------------------------------
// Adds the given configuration to the internal lists. The entries in the lists
// are ordered on InfrastructureMode in descending order. This way the Infrastructure
// entries will be on the top of the list while the adhoc entries will be on the
// bottom. (we rely on the order as it is given in NDIS_802_11_NETWORK_INFRASTRUCTURE)
DWORD
CWZCQuickCfg::AddUniqueConfig(
DWORD dwOpFlags,
DWORD dwEntryFlags,
PWZC_WLAN_CONFIG pwzcConfig,
CWZCConfig **ppNewNode)
{
DWORD dwErr = ERROR_SUCCESS;
CWZCConfig *pHdList = (dwEntryFlags & WZC_DESCR_PREFRD) ? m_pHdPList : m_pHdVList;
// skip the null SSIDs from the visible list (coming from APs
// not responding to broadcast SSID).
if (pHdList == m_pHdVList)
{
UINT i = pwzcConfig->Ssid.SsidLength;
for (; i > 0 && pwzcConfig->Ssid.Ssid[i-1] == 0; i--);
if (i == 0)
goto exit;
}
// if the list is currently empty, create the first entry as the head of the list
if (pHdList == NULL)
{
pHdList = new CWZCConfig(dwEntryFlags, pwzcConfig);
if (pHdList == NULL)
dwErr = ERROR_NOT_ENOUGH_MEMORY;
else
{
pHdList->m_pEapolConfig = new CEapolConfig;
if (pHdList->m_pEapolConfig == NULL)
dwErr = ERROR_NOT_ENOUGH_MEMORY;
else
dwErr = pHdList->m_pEapolConfig->LoadEapolConfig(m_IntfEntry.wszGuid, &(pHdList->m_wzcConfig.Ssid));
if (dwErr != ERROR_SUCCESS)
{
delete pHdList;
pHdList = NULL;
}
}
// if the caller wants, return the pointer to the newly created object
if (ppNewNode != NULL)
*ppNewNode = pHdList;
}
else
{
// else the list already contains at least one element
CWZCConfig *pCrt, *pHdGroup;
// scan the list (keep in mind it is ordered descendingly on IM)
pHdGroup = pCrt = pHdList;
do
{
// check whether we entered a new group of configs (different InfrastructureMode)
if (pHdGroup->m_wzcConfig.InfrastructureMode != pCrt->m_wzcConfig.InfrastructureMode)
pHdGroup = pCrt;
// if found an identical entry (same SSID and same InfraMode)
// signal the DUPLICATE_TAG error
if (pCrt->Match(pwzcConfig))
{
// merge the flags first
pCrt->m_dwFlags |= dwEntryFlags;
// If requested, copy over the new configuration.
// If not explicitly requested, copy over only if the existent configuration
// prooves to be weaker than the one being added.
if (dwOpFlags & WZCADD_OVERWRITE || pCrt->Weaker(pwzcConfig))
{
memcpy(&(pCrt->m_wzcConfig), pwzcConfig, sizeof(WZC_WLAN_CONFIG));
}
// if the caller wants, return the pointer to the matching entry
if (ppNewNode != NULL)
*ppNewNode = pCrt;
// signal there is already a matching config
dwErr = ERROR_DUPLICATE_TAG;
}
pCrt = pCrt->m_pNext;
} while (dwErr == ERROR_SUCCESS &&
pCrt != pHdList &&
pwzcConfig->InfrastructureMode <= pCrt->m_wzcConfig.InfrastructureMode);
// if dwErr is unchanged, this means a new node has to be added ahead of pCrt node
if (dwErr == ERROR_SUCCESS)
{
// create the new config and insert it ahead of this node.
CWZCConfig *pNewConfig;
pNewConfig = new CWZCConfig(dwEntryFlags, pwzcConfig);
if (pNewConfig == NULL)
{
dwErr = ERROR_NOT_ENOUGH_MEMORY;
}
else
{
pNewConfig->m_pEapolConfig = new CEapolConfig;
if (pNewConfig->m_pEapolConfig == NULL)
dwErr = ERROR_NOT_ENOUGH_MEMORY;
else
dwErr = pNewConfig->m_pEapolConfig->LoadEapolConfig(m_IntfEntry.wszGuid, &(pNewConfig->m_wzcConfig.Ssid));
if (dwErr != ERROR_SUCCESS)
{
delete pNewConfig;
pNewConfig = NULL;
}
}
if (dwErr == ERROR_SUCCESS)
{
INT nDiff;
// if asked to insert in the head of the group, pCrt should point to this head
if (dwOpFlags & WZCADD_HIGROUP)
pCrt = pHdGroup;
pNewConfig->m_pPrev = pCrt->m_pPrev;
pNewConfig->m_pNext = pCrt;
pCrt->m_pPrev->m_pNext = pNewConfig;
pCrt->m_pPrev = pNewConfig;
// get the difference between the Infrastructure modes for the new node and
// for the current head
nDiff = pNewConfig->m_wzcConfig.InfrastructureMode - pHdList->m_wzcConfig.InfrastructureMode;
// if the newly entered entry has the largest "key" in
// the existent sequence, or it has to be inserted in the head of its group and it is
// in the first group, then the global list head moves to the new entry
if (nDiff > 0 || ((dwOpFlags & WZCADD_HIGROUP) && (nDiff == 0)))
pHdList = pNewConfig;
}
// if the caller wants, return the pointer to the newly created object
if (ppNewNode != NULL)
*ppNewNode = pNewConfig;
}
}
if (dwEntryFlags & WZC_DESCR_PREFRD)
{
m_pHdPList = pHdList;
}
else
{
m_pHdVList = pHdList;
}
exit:
return dwErr;
}
//+---------------------------------------------------------------------------
// Display the Visible & Preferred lists into their controls
DWORD
CWZCQuickCfg::RefreshListView()
{
DWORD dwErr = ERROR_SUCCESS;
CWZCConfig *pCrt;
UINT i = 0;
// clear first the list
ListView_DeleteAllItems(m_hLstNetworks);
// Add first VPI
if (m_pHdPList != NULL)
{
pCrt = m_pHdPList;
do
{
if (pCrt->m_dwFlags & WZC_DESCR_VISIBLE &&
pCrt->m_wzcConfig.InfrastructureMode == Ndis802_11Infrastructure)
{
pCrt->m_nListIndex = i;
pCrt->AddConfigToListView(m_hLstNetworks, i++);
}
pCrt = pCrt->m_pNext;
} while (pCrt != m_pHdPList);
}
// Add next VI
if (m_pHdVList != NULL)
{
pCrt = m_pHdVList;
do
{
if (!(pCrt->m_dwFlags & WZC_DESCR_PREFRD) &&
pCrt->m_wzcConfig.InfrastructureMode == Ndis802_11Infrastructure)
{
pCrt->m_nListIndex = i;
pCrt->AddConfigToListView(m_hLstNetworks, i++);
}
pCrt = pCrt->m_pNext;
} while (pCrt != m_pHdVList);
}
// Add now VPA
if (m_pHdPList != NULL)
{
pCrt = m_pHdPList;
do
{
if (pCrt->m_dwFlags & WZC_DESCR_VISIBLE &&
pCrt->m_wzcConfig.InfrastructureMode == Ndis802_11IBSS)
{
pCrt->m_nListIndex = i;
pCrt->AddConfigToListView(m_hLstNetworks, i++);
}
pCrt = pCrt->m_pNext;
} while (pCrt != m_pHdPList);
}
// Add now VA
if (m_pHdVList != NULL)
{
pCrt = m_pHdVList;
do
{
if (!(pCrt->m_dwFlags & WZC_DESCR_PREFRD) &&
pCrt->m_wzcConfig.InfrastructureMode == Ndis802_11IBSS)
{
pCrt->m_nListIndex = i;
pCrt->AddConfigToListView(m_hLstNetworks, i++);
}
pCrt = pCrt->m_pNext;
} while (pCrt != m_pHdVList);
}
ListView_SetItemState(m_hLstNetworks, 0, LVIS_SELECTED, LVIS_SELECTED);
ListView_EnsureVisible(m_hLstNetworks, 0, FALSE);
return dwErr;
}
DWORD
CWZCQuickCfg::RefreshControls()
{
DWORD dwError = ERROR_SUCCESS;
CWZCConfig *pConfig = NULL;
LVITEM lvi = {0};
INT iSelected;
BOOL bEnableWepCtrls = FALSE;
UINT nKLen = 0;
UINT nCheckOneX = BST_UNCHECKED;
BOOL bEnableOneX = FALSE;
// get the selected item from the visible list
iSelected = ListView_GetNextItem(m_hLstNetworks, -1, LVNI_SELECTED);
if (iSelected >= 0)
{
lvi.mask = LVIF_PARAM;
lvi.iItem = iSelected;
if (ListView_GetItem(m_hLstNetworks, &lvi))
{
pConfig = (CWZCConfig*)lvi.lParam;
}
}
else
{
::EnableWindow(m_hBtnConnect, FALSE);
return dwError;
}
// since we just switched the networks, yes, the wep key can be seen as touched.
// If we find out there is already a key available, we'll reset this flag and go
// with that one until the user is clicking it.
m_bKMatTouched = TRUE;
if (pConfig != NULL)
{
CWZCConfig *pVConfig;
// pick up the "privacy" bit from the matching visible configuration
// NOTE: The test below should always succeed actually
if (IsConfigInList(m_pHdVList, &(pConfig->m_wzcConfig), &pVConfig))
bEnableWepCtrls = (pVConfig->m_wzcConfig.Privacy != 0);
else
bEnableWepCtrls = (pConfig->m_wzcConfig.Privacy != 0);
if (pConfig->m_dwFlags & WZC_DESCR_PREFRD &&
pConfig->m_wzcConfig.dwCtlFlags & WZCCTL_WEPK_PRESENT &&
pConfig->m_wzcConfig.KeyLength > 0)
{
//--- when a password is to be displayed as hidden chars, don't put in
//--- its actual length, but just 8 bulled chars.
nKLen = 8;
m_bKMatTouched = FALSE;
}
if (bEnableWepCtrls)
{
// For networks requiring privacy, 802.1X is going to be by default disabled and
// locked out on all IBSS networks.
if (pConfig->m_wzcConfig.InfrastructureMode == Ndis802_11IBSS)
{
nCheckOneX = BST_UNCHECKED;
bEnableOneX = FALSE;
}
else
{
// for all non-preferred Infrastructure networks, 802.1X is going to be by default
// enabled since these networks start with "the key is provided for me automatically"
// which suggests 802.1X.
if (!(pConfig->m_dwFlags & WZC_DESCR_PREFRD))
{
nCheckOneX = BST_CHECKED;
}
else // this is a preferred Infrastructure network
{
// initial 802.1X state is the one from the profile
nCheckOneX = pConfig->m_pEapolConfig->Is8021XEnabled() ?
BST_CHECKED:
BST_UNCHECKED;
}
// for Infrastructure networks requiring privacy, user is allowed to change 802.1X state
bEnableOneX = TRUE;
}
}
}
g_wszHiddWepK[nKLen] = L'\0';
::SetWindowText(m_hEdtWepK, g_wszHiddWepK);
::SetWindowText(m_hEdtWepK2, g_wszHiddWepK);
g_wszHiddWepK[nKLen] = 0x25cf;
if (bEnableWepCtrls)
{
CheckDlgButton(IDC_WZCQCFG_CHK_ONEX, nCheckOneX);
::EnableWindow(m_hChkOneX, bEnableOneX);
if (::IsWindowEnabled(m_hEdtWepK2))
{
::EnableWindow(m_hLblWepK2, FALSE);
::EnableWindow(m_hEdtWepK2, FALSE);
}
if (::IsWindowVisible(m_hLblNoWepKInfo))
{
::ShowWindow(m_hWarnIcon, SW_HIDE);
::ShowWindow(m_hLblNoWepKInfo, SW_HIDE);
::ShowWindow(m_hChkNoWepK, SW_HIDE);
}
if (!::IsWindowVisible(m_hLblWepKInfo))
{
::ShowWindow(m_hLblWepKInfo, SW_SHOW);
::ShowWindow(m_hLblWepK, SW_SHOW);
::ShowWindow(m_hEdtWepK, SW_SHOW);
::ShowWindow(m_hLblWepK2, SW_SHOW);
::ShowWindow(m_hEdtWepK2, SW_SHOW);
::ShowWindow(m_hChkOneX, SW_SHOW);
}
}
else
{
if (::IsWindowVisible(m_hLblWepKInfo))
{
::ShowWindow(m_hLblWepKInfo, SW_HIDE);
::ShowWindow(m_hLblWepK, SW_HIDE);
::ShowWindow(m_hEdtWepK, SW_HIDE);
::ShowWindow(m_hLblWepK2, SW_HIDE);
::ShowWindow(m_hEdtWepK2, SW_HIDE);
::ShowWindow(m_hChkOneX, SW_HIDE);
}
if (!::IsWindowVisible(m_hLblNoWepKInfo))
{
::ShowWindow(m_hWarnIcon, SW_SHOW);
::ShowWindow(m_hLblNoWepKInfo, SW_SHOW);
::ShowWindow(m_hChkNoWepK, SW_SHOW);
CheckDlgButton(IDC_WZCQCFG_CHK_NOWK,BST_UNCHECKED);
}
pConfig = NULL; // reset the pointer to the configuration to force disable the "Connect" button
}
::EnableWindow(m_hBtnConnect, pConfig != NULL);
return dwError;
}
//+---------------------------------------------------------------------------
// class constructor
CWZCQuickCfg::CWZCQuickCfg(const GUID * pGuid)
{
// initialize the UI handles
m_hLblInfo = NULL;
m_hLblNetworks = NULL;
m_hLstNetworks = NULL;
m_hLblWepKInfo = NULL;
m_hLblWepK = NULL;
m_hEdtWepK = NULL;
m_hLblWepK2 = NULL;
m_hEdtWepK2 = NULL;
m_hChkOneX = NULL;
m_hWarnIcon = NULL;
m_hLblNoWepKInfo = NULL;
m_hChkNoWepK = NULL;
m_hBtnAdvanced = NULL;
m_hBtnConnect = NULL;
// initialize the Images handle
m_hImgs = NULL;
// initialize the WZC data
m_bHaveWZCData = FALSE;
ZeroMemory(&m_IntfEntry, sizeof(INTF_ENTRY));
m_dwOIDFlags = 0;
m_nTimer = 0;
m_hCursor = NULL;
if (pGuid != NULL)
m_Guid = *pGuid;
else
ZeroMemory(&m_Guid, sizeof(GUID));
// init the internal list heads
m_pHdVList = NULL;
m_pHdPList = NULL;
// init the connection
m_wszTitle = NULL;
}
//+---------------------------------------------------------------------------
// class destructor
CWZCQuickCfg::~CWZCQuickCfg()
{
if (m_hImgs != NULL)
ImageList_Destroy(m_hImgs);
// delete the internal INTF_ENTRY object
WZCDeleteIntfObj(&m_IntfEntry);
// delete the internal list of visible configurations
// (is like filling it with NULL)
FillVisibleList(NULL);
// delete the internal list of preferred configurations
// (is like filling it with NULL)
FillPreferredList(NULL);
if (m_nTimer != 0)
KillTimer(m_nTimer);
}
//+---------------------------------------------------------------------------
// INIT_DIALOG handler
LRESULT
CWZCQuickCfg::OnInitDialog (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
DWORD dwError;
DWORD dwInFlags;
BOOL bEnableAll;
m_bKMatTouched = TRUE;
// reference the UI controls
m_hLblInfo = GetDlgItem(IDC_WZCQCFG_LBL_INFO);
m_hLblNetworks = GetDlgItem(IDC_WZCQCFG_LBL_NETWORKS);
m_hLstNetworks = GetDlgItem(IDC_WZCQCFG_NETWORKS);
m_hLblWepKInfo = GetDlgItem(IDC_WZCQCFG_LBL_WKINFO);
m_hLblWepK = GetDlgItem(IDC_WZCQCFG_LBL_WEPK);
m_hEdtWepK = GetDlgItem(IDC_WZCQCFG_WEPK);
m_hLblWepK2 = GetDlgItem(IDC_WZCQCFG_LBL_WEPK2);
m_hEdtWepK2 = GetDlgItem(IDC_WZCQCFG_WEPK2);
m_hChkOneX = GetDlgItem(IDC_WZCQCFG_CHK_ONEX);
m_hWarnIcon = GetDlgItem(IDC_WZCQCFG_ICO_WARN);
m_hLblNoWepKInfo = GetDlgItem(IDC_WZCQCFG_LBL_NOWKINFO);
m_hChkNoWepK = GetDlgItem(IDC_WZCQCFG_CHK_NOWK);
m_hBtnAdvanced = GetDlgItem(IDC_WZCQCFG_ADVANCED);
m_hBtnConnect = GetDlgItem(IDC_WZCQCFG_CONNECT);
if (m_wszTitle != NULL)
SetWindowText(m_wszTitle);
if (m_hWarnIcon != NULL)
::SendMessage(m_hWarnIcon, STM_SETICON, (WPARAM)LoadIcon(NULL, IDI_WARNING), (LPARAM)0);
// sets the icon images for the list view
InitListView();
CenterWindow();
m_dwOIDFlags = 0;
dwInFlags = INTF_BSSIDLIST|INTF_PREFLIST|INTF_ALL_FLAGS;
dwError = GetOIDs(dwInFlags,&m_dwOIDFlags);
if (m_dwOIDFlags == dwInFlags)
{
// if the OIDs are supported, fill in everything.
if (m_IntfEntry.dwCtlFlags & INTFCTL_OIDSSUPP)
{
// add the list of visible configs for this adapter
FillVisibleList((PWZC_802_11_CONFIG_LIST)m_IntfEntry.rdBSSIDList.pData);
// add the list of preferred configs for this adapter
FillPreferredList((PWZC_802_11_CONFIG_LIST)m_IntfEntry.rdStSSIDList.pData);
// fill in the list view
RefreshListView();
m_hCursor = SetCursor(LoadCursor(NULL, IDC_ARROW));
// and enable all controls
bEnableAll = TRUE;
}
}
else
{
// switch the cursor to "App starting"
m_hCursor = SetCursor(LoadCursor(NULL, IDC_APPSTARTING));
// we should fill in the UI after Tr (see the WZC state machine)
// Tr is 3secs (defined in ..zeroconf\server\state.h)
m_nTimer = (UINT)SetTimer(g_TimerID, RFSH_TIMEOUT);
bEnableAll = FALSE;
}
// now that the UI is filled up set the remaining controls to their
// respective states.
RefreshControls();
::EnableWindow(m_hLblInfo, bEnableAll);
::EnableWindow(m_hLblNetworks, bEnableAll);
::EnableWindow(m_hLstNetworks, bEnableAll);
::EnableWindow(m_hBtnAdvanced, bEnableAll);
::SetFocus(m_hLstNetworks);
bHandled = TRUE;
return 0;
}
//+---------------------------------------------------------------------------
// Help handlers
extern const WCHAR c_szNetCfgHelpFile[];
LRESULT
CWZCQuickCfg::OnContextMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
::WinHelp(m_hWnd,
c_wszWzcHelpFile,
HELP_CONTEXTMENU,
(ULONG_PTR)g_aHelpIDs_IDD_WZCQCFG);
bHandled = TRUE;
return 0;
}
LRESULT
CWZCQuickCfg::OnHelp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
LPHELPINFO lphi = reinterpret_cast<LPHELPINFO>(lParam);
if (HELPINFO_WINDOW == lphi->iContextType)
{
::WinHelp(static_cast<HWND>(lphi->hItemHandle),
c_wszWzcHelpFile,
HELP_WM_HELP,
(ULONG_PTR)g_aHelpIDs_IDD_WZCQCFG);
bHandled = TRUE;
}
return 0;
}
//+---------------------------------------------------------------------
// Refresh timer handler
LRESULT
CWZCQuickCfg::OnTimer(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
if (m_nTimer != 0)
{
BOOL bEnableAll;
DWORD dwInFlags;
// switch the cursor back to whatever it was
SetCursor(LoadCursor(NULL, IDC_ARROW));
KillTimer(m_nTimer);
m_nTimer = 0;
m_dwOIDFlags = 0;
dwInFlags = INTF_BSSIDLIST|INTF_PREFLIST|INTF_ALL_FLAGS;
GetOIDs(dwInFlags,&m_dwOIDFlags);
bEnableAll = (m_dwOIDFlags == dwInFlags) && (m_IntfEntry.dwCtlFlags & INTFCTL_OIDSSUPP);
if (bEnableAll)
{
// add the list of visible configs for this adapter
FillVisibleList((PWZC_802_11_CONFIG_LIST)m_IntfEntry.rdBSSIDList.pData);
// add the list of preferred configs for this adapter
FillPreferredList((PWZC_802_11_CONFIG_LIST)m_IntfEntry.rdStSSIDList.pData);
// fill in the list view
RefreshListView();
}
// now that the UI is filled up set the remaining controls to their
// respective states.
RefreshControls();
// enable all the UI when done refreshing
::EnableWindow(m_hLblInfo, bEnableAll);
::EnableWindow(m_hLblNetworks, bEnableAll);
::EnableWindow(m_hLstNetworks, bEnableAll);
::EnableWindow(m_hBtnAdvanced, bEnableAll);
}
return 0;
}
//+---------------------------------------------------------------------
// Selection changed in the list
LRESULT CWZCQuickCfg::OnItemChanged(
int idCtrl,
LPNMHDR pnmh,
BOOL& bHandled)
{
bHandled = TRUE;
RefreshControls();
::SetFocus(m_hLstNetworks);
return 0;
}
//+---------------------------------------------------------------------
// User clicked an entry in the list
LRESULT CWZCQuickCfg::OnDbClick(int idCtrl, LPNMHDR pnmh, BOOL& bHandled)
{
if (idCtrl == IDC_WZCQCFG_NETWORKS && ::IsWindowEnabled(m_hBtnConnect))
{
OnConnect(
(WORD)pnmh->code,
(WORD)pnmh->idFrom,
pnmh->hwndFrom,
bHandled);
}
return 0;
}
//+---------------------------------------------------------------------------
// OnConnect button handler
LRESULT
CWZCQuickCfg::OnConnect(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
DWORD dwErr = ERROR_SUCCESS;
INT iSelected;
CWZCConfig *pConfig = NULL;
UINT nKeyLen;
LPBYTE pbKMat = NULL;
DWORD dwCtlFlags;
BOOL bOkToDismiss = TRUE;
// get the selected item from the visible list
iSelected = ListView_GetNextItem(m_hLstNetworks, -1, LVNI_SELECTED);
if (iSelected < 0)
dwErr = ERROR_GEN_FAILURE;
// iSelected should be 0 otherwise "Connect" won't be enabled
if (dwErr == ERROR_SUCCESS)
{
LVITEM lvi = {0};
lvi.mask = LVIF_PARAM;
lvi.iItem = iSelected;
if (ListView_GetItem(m_hLstNetworks, &lvi))
{
pConfig = (CWZCConfig*)lvi.lParam;
if (pConfig == NULL)
dwErr = ERROR_GEN_FAILURE;
}
else
dwErr = ERROR_GEN_FAILURE;
}
if (dwErr == ERROR_SUCCESS)
{
// here we should have a valid pConfig
ASSERT(pConfig);
if ((m_IntfEntry.dwCtlFlags & INTFCTL_CM_MASK) != Ndis802_11AutoUnknown &&
(m_IntfEntry.dwCtlFlags & INTFCTL_CM_MASK) != pConfig->m_wzcConfig.InfrastructureMode)
{
// User is trying to access a network type (infra or adhoc) that they're not allowed to access.
// Give them an error message
UINT idMessage = (pConfig->m_wzcConfig.InfrastructureMode == Ndis802_11Infrastructure) ? IDS_CANTACCESSNET_INFRA : IDS_CANTACCESSNET_ADHOC;
WCHAR szSSID[MAX_PATH];
ListView_GetItemText(m_hLstNetworks, iSelected, 0, szSSID, ARRAYSIZE(szSSID));
DisplayFormatMessage(m_hWnd, IDS_WZCERR_CAPTION, idMessage, MB_ICONERROR | MB_OK, szSSID);
// Can't connect - error
dwErr = ERROR_GEN_FAILURE;
// Don't close the dialog
bOkToDismiss = FALSE;
}
}
// get the WEP key only if the user touched it. m_bKMatTouched is FALSE only when the configuration
// selected is already in the preferred list and that preferred config already contained a key which was
// not touched a bit by the user. Otherwise it is TRUE.
if (dwErr == ERROR_SUCCESS && m_bKMatTouched)
{
UINT nIdsErr;
// check whether the WEP key has the right format
dwErr = GetWepKMaterial(&nKeyLen, &pbKMat, &dwCtlFlags);
if (dwErr != ERROR_SUCCESS)
{
::SendMessage(m_hEdtWepK, EM_SETSEL, 0, (LPARAM)-1);
::SetFocus(m_hEdtWepK);
nIdsErr = IDS_WZCERR_INVALID_WEPK;
}
// check whether the WEP key is confirmed correctly
if (dwErr == ERROR_SUCCESS && nKeyLen > 0)
{
WCHAR wszWepK1[32], wszWepK2[32];
UINT nKeyLen1, nKeyLen2;
nKeyLen1 = ::GetWindowText(m_hEdtWepK, wszWepK1, sizeof(wszWepK1)/sizeof(WCHAR));
nKeyLen2 = ::GetWindowText(m_hEdtWepK2, wszWepK2, sizeof(wszWepK2)/sizeof(WCHAR));
if (nKeyLen1 != nKeyLen2 || nKeyLen1 == 0 || wcscmp(wszWepK1, wszWepK2) != 0)
{
nIdsErr = IDS_WZCERR_MISMATCHED_WEPK;
::SetWindowText(m_hEdtWepK2, L"");
::SetFocus(m_hEdtWepK2);
dwErr = ERROR_INVALID_DATA;
}
}
if (dwErr != ERROR_SUCCESS)
{
WCHAR wszBuffer[MAX_PATH];
WCHAR wszCaption[MAX_PATH];
LoadString(nIdsErr == IDS_WZCERR_INVALID_WEPK ? _Module.GetResourceInstance() : WZCGetSPResModule(),
nIdsErr,
wszBuffer,
MAX_PATH);
LoadString(_Module.GetResourceInstance(),
IDS_WZCERR_CAPTION,
wszCaption,
MAX_PATH);
MessageBox(wszBuffer, wszCaption, MB_ICONERROR|MB_OK);
bOkToDismiss = FALSE;
}
}
// we do have the right WEP key here, lets copy it to the corresponding config
if (dwErr == ERROR_SUCCESS)
{
// if this configuration is not a preferred one, copy it in the preferred
// list at the top of its group
if (!(pConfig->m_dwFlags & WZC_DESCR_PREFRD))
{
// move this configuration out of the visible list
pConfig->m_pNext->m_pPrev = pConfig->m_pPrev;
pConfig->m_pPrev->m_pNext = pConfig->m_pNext;
// if the list head pointed on this config, move it to
// the next in the list
if (m_pHdVList == pConfig)
m_pHdVList = pConfig->m_pNext;
// if the list head still points on the same config,
// it means this was the only one in the list. So, null out the head.
if (m_pHdVList == pConfig)
m_pHdVList = NULL;
//next insert this visible config in the preferred list
if (m_pHdPList == NULL)
{
m_pHdPList = pConfig;
pConfig->m_pNext = pConfig;
pConfig->m_pPrev = pConfig;
}
else
{
CWZCConfig *pCrt;
// the new preferred config comes on top of the list if:
// (it is infrastructure) or (there are no infrastructures in the preferred list)
if (pConfig->m_wzcConfig.InfrastructureMode == Ndis802_11Infrastructure ||
m_pHdPList->m_wzcConfig.InfrastructureMode == Ndis802_11IBSS)
{
pCrt = m_pHdPList;
m_pHdPList = pConfig;
}
else // it definitely doesn't come the first in the list
{
for (pCrt = m_pHdPList->m_pNext; pCrt != m_pHdPList; pCrt=pCrt->m_pNext)
{
// if this is the first configuration in the matching group break the loop
if (pCrt->m_wzcConfig.InfrastructureMode == Ndis802_11IBSS)
break;
}
}
// now we have to insert pConfig in the front of pCrt;
pConfig->m_pNext = pCrt;
pConfig->m_pPrev = pCrt->m_pPrev;
pConfig->m_pNext->m_pPrev = pConfig;
pConfig->m_pPrev->m_pNext = pConfig;
}
}
// if the configuration is a preferred one, just make sure we copy over the
// privacy bit from the visible list. That one is the "real" thing
else
{
CWZCConfig *pVConfig;
if (IsConfigInList(m_pHdVList, &pConfig->m_wzcConfig, &pVConfig))
{
pConfig->m_wzcConfig.Privacy = pVConfig->m_wzcConfig.Privacy;
}
}
// now the configuration is at its right position - put in the new WEP key, if any was typed in
if (pConfig->m_wzcConfig.Privacy && m_bKMatTouched)
{
// if no key is provided, it means there is no key material.
// All we do is to reset the corresponding bit - whatever material was there
// will be preserved along with its length & format
if (!(dwCtlFlags & WZCCTL_WEPK_PRESENT))
{
pConfig->m_wzcConfig.dwCtlFlags &= ~WZCCTL_WEPK_PRESENT;
}
else
{
// now if we have a WEP key, copy over its control flags and material
pConfig->m_wzcConfig.dwCtlFlags = dwCtlFlags;
ZeroMemory(pConfig->m_wzcConfig.KeyMaterial, WZCCTL_MAX_WEPK_MATERIAL);
pConfig->m_wzcConfig.KeyLength = nKeyLen;
memcpy(pConfig->m_wzcConfig.KeyMaterial, pbKMat, nKeyLen);
}
}
}
// if all 802.11 params have been taken care of, copy now the 802.1x params (if needed)
if (dwErr == ERROR_SUCCESS &&
pConfig->m_pEapolConfig != NULL)
{
// if the network is an infrastructure one fix the 802.1X state.
// For ad hoc networks don't touch the 802.1x since it might mess the setting for a
// corresponding Infrastructure network (802.1X doesn't differentiate between SSID Infra & SSID ad hoc)
// 802.1X engine is smart enough to not act on ad hoc networks regardless its registry state!
if (pConfig->m_wzcConfig.InfrastructureMode == Ndis802_11Infrastructure)
{
// if the network requires privacy, set its state according to the "Enable 802.1X" checkbox
if (pConfig->m_wzcConfig.Privacy)
{
pConfig->m_pEapolConfig->Set8021XState(IsDlgButtonChecked(IDC_WZCQCFG_CHK_ONEX) == BST_CHECKED);
}
else // if the network doesn't require privacy - disable 802.1X!
{
// if the network is either ad hoc or infrastructure with no wep
// explicitly disable 802.1x
pConfig->m_pEapolConfig->Set8021XState(0);
}
}
}
// ok, save the preferred list back to Wireless Zero Configuration Service
if (dwErr == ERROR_SUCCESS)
{
RpcFree(m_IntfEntry.rdStSSIDList.pData);
m_IntfEntry.rdStSSIDList.dwDataLen = 0;
m_IntfEntry.rdStSSIDList.pData = NULL;
dwErr = SavePreferredConfigs(&m_IntfEntry, pConfig);
}
if (dwErr == ERROR_SUCCESS)
{
// by saving the preferred list here we're forcing a hard reset to
// the WZC State machine. This is what we want since we're here
// as a consequence of a failure and a user intervention.
dwErr = WZCSetInterface(
NULL,
INTF_PREFLIST,
&m_IntfEntry,
NULL);
if (dwErr == ERROR_PARTIAL_COPY)
{
DisplayFormatMessage(
m_hWnd,
IDS_WZCERR_CAPTION,
IDS_WZC_PARTIAL_APPLY,
MB_ICONEXCLAMATION|MB_OK);
dwErr = ERROR_SUCCESS;
}
}
// in case of any failure we might want to warn the user (another popup?)
// the question is what is the user supposed to do in such a case?
if (dwErr != ERROR_SUCCESS)
{
dwErr = ERROR_SUCCESS;
}
if(pbKMat != NULL)
delete pbKMat;
if (bOkToDismiss)
{
bHandled = TRUE;
SpEndDialog(IDOK);
}
return 0;
}
//+---------------------------------------------------------------------------
// OK button handler
LRESULT
CWZCQuickCfg::OnCancel(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
bHandled = TRUE;
SpEndDialog(IDCANCEL);
return 0;
}
//+---------------------------------------------------------------------------
// Advanced button handler
LRESULT
CWZCQuickCfg::OnAdvanced(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
bHandled = TRUE;
SpEndDialog(IDC_WZCQCFG_ADVANCED);
return 0;
}
int DisplayFormatMessage(HWND hwnd, UINT idCaption, UINT idFormatString, UINT uType, ...)
{
int iResult = IDCANCEL;
TCHAR szError[1024 + 1]; *szError = 0;
TCHAR szCaption[256 + 1];
TCHAR szFormat[1024 + 1]; *szFormat = 0;
// Load and format the error body
if (LoadString(WZCGetSPResModule(), idFormatString, szFormat, ARRAYSIZE(szFormat)))
{
va_list arguments;
va_start(arguments, uType);
if (FormatMessage(FORMAT_MESSAGE_FROM_STRING, szFormat, 0, 0, szError, ARRAYSIZE(szError), &arguments))
{
// Load the caption
if (LoadString(_Module.GetResourceInstance(), idCaption, szCaption, ARRAYSIZE(szCaption)))
{
iResult = MessageBox(hwnd, szError, szCaption, uType);
}
}
va_end(arguments);
}
return iResult;
}
//+---------------------------------------------------------------------------
// Notification handler for the wep key edit text box
LRESULT
CWZCQuickCfg::OnWepKMatCmd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
if (wNotifyCode == EN_SETFOCUS)
{
if (!m_bKMatTouched)
{
// the user has just clicked for the first time on an existent key.. clear out the fields,
// standing for "The key is provided automatically"
::SetWindowText(m_hEdtWepK, L"");
::SetWindowText(m_hEdtWepK2, L"");
::EnableWindow(m_hLblWepK2, FALSE); // disable confirmation label for empty key
::EnableWindow(m_hEdtWepK2, FALSE); // disable confirmation edit for empty key
m_bKMatTouched = TRUE;
// if the 802.1X checkbox is enabled then we do have to check it here!
if (::IsWindowEnabled(m_hChkOneX))
CheckDlgButton(IDC_WZCQCFG_CHK_ONEX, BST_CHECKED);
}
}
if (wNotifyCode == EN_CHANGE)
{
UINT nKMatLen = ::GetWindowTextLength(m_hEdtWepK);
if (!::IsWindowEnabled(m_hEdtWepK2) && nKMatLen > 0)
{
// user just typed in some key material - enable the confirmation text
::EnableWindow(m_hLblWepK2, TRUE);
::EnableWindow(m_hEdtWepK2, TRUE);
// also uncheck 802.1x checkbox
if (::IsWindowEnabled(m_hChkOneX))
CheckDlgButton(IDC_WZCQCFG_CHK_ONEX, BST_UNCHECKED);
}
if (::IsWindowEnabled(m_hEdtWepK2) && nKMatLen == 0)
{
// user just deleted all of the key material - switching to
// "The key is provided for me automatically"
::SetWindowText(m_hEdtWepK2, L"");
::EnableWindow(m_hLblWepK2, FALSE);
::EnableWindow(m_hEdtWepK2, FALSE);
// auto key suggests 802.1X
if (::IsWindowEnabled(m_hChkOneX))
CheckDlgButton(IDC_WZCQCFG_CHK_ONEX, BST_CHECKED);
}
}
return 0;
}
LRESULT
CWZCQuickCfg::OnCheckConfirmNoWep(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
::EnableWindow(m_hBtnConnect, IsDlgButtonChecked(IDC_WZCQCFG_CHK_NOWK) == BST_CHECKED);
return 0;
}
Reference in a new issue Copy permalink