BOOL OnOKGeneral(HWND hDlg, PWLAN_CFG_PROPS psProp)
{
HRESULT hr = S_OK;
SHWZCNET wzcnet;
INT nMeta;
DWORD dwMask;
// Get the UI settings
memcpy(&wzcnet, &psProp->wzcnet, sizeof(SHWZCNET));
UpdateDataGeneral(hDlg, &wzcnet, &nMeta, FALSE);
if (psProp->dwFlags & WZCDLG_PROPS_RWSSID) // SSID is changable
{
// Is the SSID empty?
if (TEXT('\0') == wzcnet.szName[0])
{
MessageBoxWithResID(hDlg, IDS_WZC_NULL_SSID, IDS_WZC_MSG_TITLE, MB_ICONSTOP | MB_OK);
CBR(FALSE);
}
// Is the name valid?
hr = SHWZCValidateNetworkName(wzcnet.szName, NULL, 0);
if (FAILED(hr))
{
MessageBoxWithResID(hDlg, IDS_WZC_INVALID_NAME, IDS_WZC_MSG_TITLE, MB_ICONSTOP | MB_OK);
CHR(hr);
}
// Make sure that we do have a valid handle to shwzc
// If the handle is null, most likely the parent window received an OnActivateHome.
// We don't ever destroy the callback because the parent window will destroy it.
hr = SetCallbackRegistration(TRUE, psProp->psWLanInfo);
CHR(hr);
// Is this a duplicate name?
if (S_FALSE != SHWZCIsDuplicateName(psProp->psWLanInfo->hshwzc,
wzcnet.szName, BOOLIFY(wzcnet.dwFlags & SHWZCF_NET_ADHOC)))
{
MessageBoxWithResID(hDlg, IDS_WZC_DUP_SSID, IDS_WZC_MSG_TITLE, MB_ICONSTOP | MB_OK);
CBR(FALSE);
}
// Copy the name
CHRA(StringCchCopy(psProp->wzcnet.szName, ARRAYSIZE(psProp->wzcnet.szName), wzcnet.szName));
}
// Apply the changes
dwMask = SHWZCF_SETMASK_ADHOC | SHWZCF_SETMASK_REQUIRE_WZC_PROBE;
hr = SHWZCCopySettings(&psProp->wzcnet, &wzcnet, dwMask);
CHR(hr);
psProp->uMeta = nMeta;
psProp->dwMask |= dwMask;
Error:
if (FAILED(hr))
{
PostMessage(hDlg, WM_DELAY_SETFOCUS, IDC_WZC_EDIT_SSID, 0L);
}
return SUCCEEDED(hr);
}
HRESULT RefreshWifiAdvanceSettings(HWND hDlg)
{
HRESULT hr = S_OK;
HWND hCombo;
int iRet;
UINT uiTime;
BOOL fNotification;
hr = SHWZCGetNotificationState(&fNotification);
CHR(hr);
SendDlgItemMessage(hDlg, IDC_WZC_CHECK_NOTIFICATION, BM_SETCHECK, fNotification ? BST_CHECKED : BST_UNCHECKED, 0);
hr = SHWZCGetWifiTimeoutPeriod(&uiTime);
CHR(hr);
hCombo = GetDlgItem(hDlg, IDC_WZC_COMBO_AUTO_OFF);
CWR(hCombo);
for (int i = 0; i <= (IDS_WZC_AUTO_OFF_LAST-IDS_WZC_AUTO_OFF_FIRST); i++)
{
iRet = SendMessage(hCombo, CB_INSERTSTRING, (WPARAM)-1, (LPARAM) LoadStringEtc(HINST_RESDLL, IDS_WZC_AUTO_OFF_FIRST+i, NULL));
CBR(iRet != CB_ERR);
if (uiTime == g_uiAutoOffTimer[i])
{
SendMessage(hCombo, CB_SETCURSEL, (WPARAM)iRet, (LPARAM)0);
}
CBR(CB_ERR != SendMessage(hCombo, CB_SETITEMDATA, (WPARAM)iRet, (LPARAM)g_uiAutoOffTimer[i]));
}
Error:
return hr;
}
static HRESULT GetEAPParams(UINT iIndex, __inout WZC_EAPOL_PARAMS *pwzceap)
{
HRESULT hr = S_OK;
HKEY hkey = NULL;
DWORD dwValueType;
DWORD cbSize;
// Open the default type key
hr = OpenEAPRegistryKey(iIndex, &hkey);
CHR(hr);
// Get the type code
cbSize = sizeof(pwzceap->dwEapType);
CBR(ERROR_SUCCESS == RegQueryValueEx(hkey, g_szRegValueEAPType, NULL, &dwValueType,
(BYTE*)&pwzceap->dwEapType, &cbSize) && REG_DWORD == dwValueType);
// Get the flags
cbSize = sizeof(pwzceap->dwEapFlags);
CBR(ERROR_SUCCESS == RegQueryValueEx(hkey, g_szRegValueEAPFlags, NULL, &dwValueType,
(BYTE*)&pwzceap->dwEapFlags, &cbSize) && REG_DWORD == dwValueType);
Error:
if (NULL != hkey)
{
RegCloseKey(hkey);
}
return hr;
}
static HRESULT OnConnect(PWLAN_INFO psInfo, INT iItem)
{
HRESULT hr = S_OK;
PCSHWZCNET pwzcnet = (PCSHWZCNET)GetListItemLPARAM(psInfo->hwndNetList, iItem);
SHWZCNET wzcnet;
BOOL fSecure;
// The first item is "Add net settings...". It cannot be deleted.
CBR(iItem > 0 && pwzcnet != NULL);
memcpy(&wzcnet, pwzcnet, sizeof(SHWZCNET));
// If the item isn't preferred
if (!(SHWZCF_NET_PREFERRED & wzcnet.dwFlags))
{
DWORD dwNoFastConnect = 0;
fSecure = BOOLIFY(wzcnet.dwFlags & SHWZCF_NET_8021X) ||
!( ( (Ndis802_11Encryption1Enabled != wzcnet.dwEncryptionType) &&
(Ndis802_11Encryption2Enabled != wzcnet.dwEncryptionType) &&
(Ndis802_11Encryption3Enabled != wzcnet.dwEncryptionType) ) &&
(Ndis802_11AuthModeOpen == wzcnet.dwAuthentication) );
// If secure or fastconnect is disabled, show the settings wizard, else connect
RegistryGetDWORD(HKEY_LOCAL_MACHINE, WZC_REGKEY_BASE, WZC_REGKEY_DISABLEFASTCONNECT, &dwNoFastConnect);
if (fSecure || dwNoFastConnect != 0)
{
CBR(OnNetworkProperties(psInfo, iItem));
}
else
{
SHWZCSetNetwork(psInfo->hshwzc, &wzcnet, NULL, NULL, 0, SHWZCF_SETMASK_ALL);
}
}
// disable SK1 Connect while we're attempting to connect for this network
SHEnableSoftkey(psInfo->hwndNetListMB, 0, TRUE, FALSE);
// Ensure that power is on. Ignore errors, this is a "Best-effort" attempt
SHWZCSetPowerState(TRUE);
// Now connect directly (we'll automatically get a refresh event)
hr = SHWZCConnectNetwork(psInfo->hshwzc, wzcnet.szName,
BOOLIFY(SHWZCF_NET_ADHOC & wzcnet.dwFlags));
CHR(hr);
Error:
if(FAILED(hr))
{
// re-enable SK since something went wrong
SHEnableSoftkey(psInfo->hwndNetListMB, 0, TRUE, TRUE);
}
return hr;
}
static HRESULT GetMetaNetworkNames()
{
HRESULT hr = S_OK;
UINT i;
if (0 == g_rgmni[0].szName[0])
{
// Enumerate the entries
hr = EnumMetaNetworkNames(EnumMetaNetworkNamesCallback, NULL);
CHR(hr);
// Make sure we got them all
for (i = 0; i != ARRAYSIZE(g_rgmni); ++i)
{
CBR(0 != g_rgmni[i].szName[0]);
}
}
Error:
if (FAILED(hr))
{
// Make sure we retry later
g_rgmni[0].szName[0] = TEXT('\0');
}
return hr;
}
HRESULT GetEAPIncremented(PWLC pwlc)
{
HRESULT hr = S_OK;
UINT iIndex;
// If EAP hasn't been enabled, just start with the initial defaults
if (!pwlc->EapolParams.bEnable8021x)
{
hr = GetEAPDefaults(pwlc);
CHR(hr);
goto Exit;
}
// WPA[2]-PSK doesn't increment through the EAP types
CBR(! IsAnyWPAPSK(pwlc->AuthenticationMode));
// Find the index of the current type
hr = FindEAPRegistryIndex(pwlc->EapolParams.dwEapType, &iIndex, NULL);
CHR(hr);
// Set the parameters for the next type
hr = GetEAPParams(iIndex + 1, &pwlc->EapolParams);
CHR(hr);
Error:
Exit:
return hr;
}
static BOOL CALLBACK EnumAuthentication(DWORD dwType, LPCTSTR pszName, LPVOID pvParam)
{
HRESULT hr = S_OK;
HWND hcbAuth = (HWND)pvParam;
int nIndex;
// Add the item
nIndex = SendMessage(hcbAuth, CB_ADDSTRING, 0, (LPARAM)pszName);
CBR(CB_ERR != nIndex);
// Set the type
CBR(CB_ERR != SendMessage(hcbAuth, CB_SETITEMDATA, nIndex, dwType));
Error:
return SUCCEEDED(hr);
}
inline void
LocalTrrkKernel
( UpperOrLower uplo,
Orientation orientationOfA,
Orientation orientationOfB,
T alpha, const DistMatrix<T,STAR,MC >& A,
const DistMatrix<T,MR, STAR>& B,
T beta, DistMatrix<T,MC, MR >& C )
{
#ifndef RELEASE
PushCallStack("LocalTrrkKernel");
CheckInput( orientationOfA, orientationOfB, A, B, C );
#endif
const Grid& g = C.Grid();
DistMatrix<T,STAR,MC> AL(g), AR(g);
DistMatrix<T,MR,STAR> BT(g),
BB(g);
DistMatrix<T,MC,MR> CTL(g), CTR(g),
CBL(g), CBR(g);
DistMatrix<T,MC,MR> DTL(g), DBR(g);
const int half = C.Height()/2;
ScaleTrapezoid( beta, LEFT, uplo, 0, C );
LockedPartitionRight( A, AL, AR, half );
LockedPartitionDown
( B, BT,
BB, half );
PartitionDownDiagonal
( C, CTL, CTR,
CBL, CBR, half );
DTL.AlignWith( CTL );
DBR.AlignWith( CBR );
DTL.ResizeTo( CTL.Height(), CTL.Width() );
DBR.ResizeTo( CBR.Height(), CBR.Width() );
//------------------------------------------------------------------------//
if( uplo == LOWER )
internal::LocalGemm
( orientationOfA, orientationOfB, alpha, AR, BT, T(1), CBL );
else
internal::LocalGemm
( orientationOfA, orientationOfB, alpha, AL, BB, T(1), CTR );
internal::LocalGemm
( orientationOfA, orientationOfB, alpha, AL, BT, T(0), DTL );
AxpyTriangle( uplo, T(1), DTL, CTL );
internal::LocalGemm
( orientationOfA, orientationOfB, alpha, AR, BB, T(0), DBR );
AxpyTriangle( uplo, T(1), DBR, CBR );
//------------------------------------------------------------------------//
#ifndef RELEASE
PopCallStack();
#endif
}
HRESULT GetWirelessStateFlags(DWORD *pdwStatus)
{
HRESULT hr = S_OK;
CBR(pdwStatus);
*pdwStatus = 0;
CHR(RegistryGetDWORD(HKEY_LOCAL_MACHINE, c_szRegKeySSWifi, c_szRegValueSSWifi, pdwStatus));
Error:
return hr;
}
HRESULT RegValueSZ(HKEY hKey, LPCTSTR szName, LPTSTR* ppszValue, DWORD cbLen)
{
HRESULT hr = S_OK;
DWORD dwRet, cbBufLen;
BOOL fDelete = FALSE;
CBR(hKey != NULL && ppszValue != NULL);
cbBufLen = 0;
dwRet = RegQueryValueEx(hKey, szName, NULL, NULL, NULL, &cbBufLen);
CBR(dwRet == ERROR_SUCCESS);
if (!cbLen)
{
*ppszValue = (LPTSTR)LocalAlloc(LPTR, cbBufLen);
CPR(*ppszValue);
cbLen = cbBufLen;
// This flag is to only free space
// allocated here if RegQuery fails below
// We should not free space being passed in.
fDelete = TRUE;
}
dwRet = RegQueryValueEx(hKey, szName, NULL, NULL, (LPBYTE)*ppszValue, &cbLen);
if (dwRet != ERROR_SUCCESS && !cbLen)
{
if(fDelete)
{
LocalFree(*ppszValue);
// Avoid a potential double free in the calling function
*ppszValue = NULL;
}
}
CBR(dwRet == ERROR_SUCCESS);
Error:
return hr;
}
HRESULT GetMetaNetworkIndex(LPCTSTR pszGUID, UINT *piMetaNetwork)
{
HRESULT hr = S_OK;
GUID guid;
UINT i;
ASSERT(NULL != pszGUID);
ASSERT(NULL != piMetaNetwork);
// Convert the string to a GUID
CBR(SHGUIDFromString(pszGUID, &guid));
// Get the GUID index
i = MatchMetaNetworkIndex(guid);
CBR(i < ARRAYSIZE(g_rgmni));
// Success
*piMetaNetwork = i;
Error:
return hr;
}
static HRESULT FindEAPRegistryIndex(DWORD dwFindType, __out __opt UINT *piIndex, __out __opt HKEY *phkey)
{
HRESULT hr = S_OK;
UINT iIndex;
HKEY hkey = NULL;
DWORD dwEAPType;
DWORD dwValueType;
DWORD cbSize;
for (iIndex = 0;; ++iIndex)
{
// Try to open the registry key at this index
hr = OpenEAPRegistryKey(iIndex, &hkey);
CHR(hr);
// Get the associated type
cbSize = sizeof(dwEAPType);
CBR(ERROR_SUCCESS == RegQueryValueEx(hkey, g_szRegValueEAPType, NULL, &dwValueType,
(BYTE*)&dwEAPType, &cbSize) && REG_DWORD == dwValueType);
// Do they match?
if (dwEAPType == dwFindType)
{
break;
}
// Close the registry key
RegCloseKey(hkey);
hkey = NULL;
}
// We got a match
if (NULL != piIndex)
{
*piIndex = iIndex;
}
if (NULL != phkey)
{
*phkey = hkey;
hkey = NULL;
}
Error:
if (NULL != hkey)
{
RegCloseKey(hkey);
}
return hr;
}
//==========================================================================*
// Function: OnNetworkProperties
//
// Purpose: (1) Display the network properties dialog
// (2) Move(insert) the network to the head of the prefered list
//
// Arguments:
// [IN] psInfo - pointer to the WLAN_INFO structure
// [IN] item - item need to show context menu
//
// Return Values:
// BOOL - TRUE for handle it successfully
//==========================================================================*
static BOOL OnNetworkProperties(PWLAN_INFO psInfo, INT iItem)
{
HRESULT hr = S_OK;
WLAN_CFG_PROPS sProps = {0};
PCSHWZCNET pwzcnet = (PCSHWZCNET)GetListItemLPARAM(psInfo->hwndNetList, iItem);
BOOL fAdhoc;
TCHAR szGUID[MAX_PATH];
FINDGUID fg;
CBR(iItem > 0 && pwzcnet != NULL);
// If the selected network is a "Permanent" non-editable network, exit without
// showing the NetworkProperties pages
fAdhoc = BOOLIFY(SHWZCF_NET_ADHOC & pwzcnet->dwFlags);
CBREx (!SHWZCIsPermanentNetwork(pwzcnet->szName, fAdhoc), S_FALSE);
// Get the current EAP data
hr = SHWZCGetNetwork(psInfo->hshwzc, pwzcnet->szName, fAdhoc,
&sProps.wzcnet, &sProps.pvEapData, &sProps.cbEapData);
CHR(hr);
// We don't care about the result, since if this fails we just won't match
// with any networks and we'll use the default
szGUID[0] = 0;
SHWZCGetDestinationGUID(psInfo->hshwzc, pwzcnet->szName, fAdhoc,
szGUID, ARRAYSIZE(szGUID));
fg.pszGUID = szGUID;
fg.uIndex = 0;
if (S_FALSE == SHWZCEnumDestinations(EnumFindGUID, &fg))
{
sProps.uMeta = fg.uIndex;
}
sProps.psWLanInfo = psInfo;
hr = WZCCreateNetworkWLanPropsDlgs(psInfo->hDlg, &sProps);
CHR(hr);
if (IDOK == sProps.nReturn)
{
hr = ApplyProperties(psInfo, &sProps);
CHR(hr);
}
Error:
LocalFree(sProps.pvEapData);
return SUCCEEDED(hr);
}
static HRESULT OpenEAPRegistryKey(UINT iIndex, __out HKEY *phkey)
{
HRESULT hr = S_OK;
TCHAR szKey[MAX_PATH];
// Build the registry path
hr = StringCchPrintf(szKey, ARRAYSIZE(szKey), TEXT("%s\\%s%u"),
g_szRegKeyBase, g_szRegKeyEAP, iIndex + 1);
CHRA(hr);
// Open the registry key
CBR(ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER, szKey, 0, 0, phkey));
Error:
return hr;
}
static HRESULT OnChangeNetFilter(PWLAN_INFO psInfo)
{
HRESULT hr = S_OK;
INT nNetFilter;
nNetFilter = SendDlgItemMessage(psInfo->hDlg, IDC_WZC_COMBO_FILTER, CB_GETCURSEL, 0, 0L);
ASSERT(WZC_FILTER_ALL_AVAILABLE <= nNetFilter && nNetFilter <= WZC_FILTER_ADHOC);
if (nNetFilter != psInfo->nNetFilter)
{
DWORD dwState = 0;
// Get the current state
SHWZCGetState(psInfo->hshwzc, &dwState);
dwState &= ~SHWZCF_ALLOW_MASK;
// Convert to infrastructure mode
psInfo->nNetFilter = (WZC_FILTER) nNetFilter;
switch(nNetFilter)
{
case WZC_FILTER_ALL_AVAILABLE:
dwState |= SHWZCF_ALLOW_ALL;
break;
case WZC_FILTER_ACCESS_POINT:
dwState |= SHWZCF_ALLOW_AP;
break;
case WZC_FILTER_ADHOC:
dwState |= SHWZCF_ALLOW_ADHOC;
break;
default:
// There is no default case, see ASSERT above
CBR(FALSE);
}
// Set the "Network to access" setting to WZC engine
hr = SHWZCSetState(psInfo->hshwzc, dwState);
CHR(hr);
hr = RefreshNetListView(psInfo);
}
Error:
return hr;
}
HRESULT SetWirelessStateFlags(UINT uMask, UINT uValue)
{
HRESULT hr = S_OK;
DWORD dwData = 0;
HKEY hKey = NULL;
CBR(ERROR_SUCCESS == RegCreateKeyEx(HKEY_LOCAL_MACHINE, c_szRegKeySSWifi,
0, NULL, REG_OPTION_VOLATILE, 0, NULL, &hKey, NULL));
RegistryGetDWORD(hKey, NULL, c_szRegValueSSWifi, &dwData);
dwData = (dwData & ~uMask) | (uMask & uValue);
CHR(RegistrySetDWORD(hKey, NULL, c_szRegValueSSWifi, dwData));
Error:
RegCloseKey(hKey);
return hr;
}
HRESULT EnableControlsAuthentication(HWND hDlg, PWLAN_CFG_PROPS psProp)
{
HRESULT hr = S_OK;
HWND hcbAuth = GetDlgItem(hDlg, IDC_WZC_COMBO_AUTHENTICATION);
// Clear the authentication combo box
SendMessage(hcbAuth, CB_RESETCONTENT, 0, 0);
// Populate the authentication combo box
hr = SHWZCEnumAuthenticationTypes(BOOLIFY(SHWZCF_NET_ADHOC & psProp->wzcnet.dwFlags),
EnumAuthentication, hcbAuth);
CHR(hr);
CBR(S_OK == hr); // S_FALSE is failure
Error:
return hr;
}
static HRESULT OnRemoveSetting(PWLAN_INFO psInfo, INT iItem)
{
HRESULT hr = S_OK;
PCSHWZCNET pwzcnet =(PCSHWZCNET)GetListItemLPARAM(psInfo->hwndNetList, iItem);
// The first item is "Add net settings...". It cannot be deleted.
CBR(iItem > 0 && pwzcnet != NULL);
// Delete the network
hr = SHWZCDeleteNetwork(psInfo->hshwzc, pwzcnet->szName,
BOOLIFY(SHWZCF_NET_ADHOC & pwzcnet->dwFlags));
CHR(hr);
// Refresh list view
RefreshNetListView(psInfo);
Error:
return hr;
}
//==========================================================================*
// Function: OnNetworkContextMenu
//
// Purpose: Display wireless network context menu.
// The menu has two items: connect/disconnect/remove
// We need to show/hide connect or disconnect items according to
// the connection state of the network.
// The first listview item "add new setting..." doesn't have a context menu
//
// Arguments:
// [IN] psInfo - pointer to the WLAN_INFO structure
// [IN] pt - position which menu need to locate
// [IN] item - item need to show context menu
//
// Return Values:
// BOOL - TRUE for handle it successfully
//==========================================================================*
static BOOL OnNetworkContextMenu(PWLAN_INFO psInfo, POINT pt, INT iItem)
{
HRESULT hr = S_OK;
HMENU hMenu = NULL;
HMENU hMenuTrack = NULL;
IUnknown *pIUnknown = NULL;
HANDLE hCMExtensions = NULL;
// The first item is "Add new network..." item. It doesn't need a context menu.
CBR(iItem > 0);
hMenu = LoadMenu(HINST_RESDLL, MAKEINTRESOURCE(IDR_WZC_MENU_NETWORK));
CWR(hMenu);
hMenuTrack = GetSubMenu(hMenu, 0);
CWR(hMenuTrack);
InsertMenu(hMenuTrack, (UINT)-1, MF_BYPOSITION|MF_STRING, IDM_WZC_WIFI_POWERCMD,
LoadStringEtc(HINST_RESDLL, IDS_WZC_WIFI_POWERON + ((psInfo->dwHWFlags & SHWZCF_HW_ON) ? 1:0), NULL));
SHLoadMenuExtensions((IUnknown*)psInfo->pNetworkObject,
gc_szMenuNamespace,
gc_szContextExtensions,
&psInfo->hContextExt);
TrackPopupMenu(hMenuTrack, TPM_LEFTALIGN | TPM_TOPALIGN, pt.x, pt.y, 0,
psInfo->hDlg, NULL);
SHFreeContextMenuExtensions(psInfo->hContextExt);
psInfo->hContextExt = NULL;
Error:
if (hMenuTrack)
{
CloseHandle(hMenuTrack);
}
if (hMenu)
{
DestroyMenu(hMenu);
}
return SUCCEEDED(hr);
}
//==========================================================================*
// Function: InsertFirstSettingsItem
//
// Purpose: Add the first item of the list view ("Add New" or "Search for Networks")
//
// Arguments:
// [IN] psInfo - pointer to the WLAN_INFO structure
//
// Return Values:
// HRESULT - S_OK for succeed
//==========================================================================*
static HRESULT InsertFirstSettingsItem(PWLAN_INFO psInfo)
{
HRESULT hr = S_OK;
LV_ITEM lv = { 0 };
LPCTSTR pszText;
pszText = (LPCTSTR)LoadString(HINST_RESDLL,
(psInfo->dwHWFlags & SHWZCF_HW_ON) ? IDS_WZC_ADD_NEW_SETTINGS : IDS_WZC_SEARCH_NETWORKS,
NULL,
0);
CBRA(NULL != pszText);
// Fill list view structure and insert item
lv.mask = LVIF_TEXT | LVIF_IMAGE;
lv.pszText = (LPTSTR)pszText;
lv.iImage = -1;
CBR(0 <= ListView_InsertItem(psInfo->hwndNetList, &lv));
Error:
return hr;
}
HRESULT PopulateEncryptionBox(HWND hDlg, PCSHWZCNET pwzcnet)
{
HRESULT hr = S_OK;
HWND hcbEncryption = GetDlgItem(hDlg, IDC_WZC_COMBO_DATA_ENCRYPTION);
int nIndex;
// Clear the encryption combo box
SendMessage(hcbEncryption, CB_RESETCONTENT, 0, 0);
// Enumerate the available encryption types
hr = SHWZCEnumEncryptionTypes(pwzcnet, EnumEncryption, hcbEncryption);
CHR(hr);
CBR(S_OK == hr); // S_FALSE means failure
nIndex = FindIndexFromComboData(hcbEncryption, pwzcnet->dwEncryptionType);
CBRA(0 <= nIndex); // huh??
SendMessage(hcbEncryption, CB_SETCURSEL, nIndex, 0);
EnableWepKControls(hDlg, pwzcnet);
Error:
return hr;
}
static HRESULT ApplyProperties(PWLAN_INFO psInfo, const WLAN_CFG_PROPS *psProps)
{
HRESULT hr = S_OK;
FINDGUID fg;
TCHAR szGUID[MAX_PATH];
DWORD dwHardwareState;
fg.pszGUID = szGUID;
fg.cchGUID = ARRAYSIZE(szGUID);
fg.uIndex = 0;
fg.uDesired = psProps->uMeta;
// Set the network data
hr = SHWZCSetNetwork(psInfo->hshwzc, &psProps->wzcnet, psProps->pszKey,
psProps->pvEapData, psProps->cbEapData, psProps->dwMask);
CHR(hr);
// Copy the GUID string
CBR(S_FALSE == SHWZCEnumDestinations(EnumSetGUID, &fg));
hr = SHWZCSetDestinationGUID(psInfo->hshwzc, psProps->wzcnet.szName,
BOOLIFY(SHWZCF_NET_ADHOC & psProps->wzcnet.dwFlags), szGUID);
CHR(hr);
// Refresh the view
RefreshNetListView(psInfo);
dwHardwareState = SHWZCGetHardwareFlags();
if (!(dwHardwareState & SHWZCF_HW_CONNECTED) && !(dwHardwareState & SHWZCF_HW_CONNECTING))
{
hr = SHWZCConnectNetwork(psInfo->hshwzc, psProps->wzcnet.szName,
BOOLIFY(SHWZCF_NET_ADHOC & psProps->wzcnet.dwFlags));
CHR(hr);
}
Error:
return hr;
}
HRESULT GetEAPFlags(DWORD dwType, DWORD *pdwFlags)
{
HRESULT hr = S_OK;
HKEY hkey = NULL;
DWORD dwValueType;
DWORD cbSize;
// Find the registry index that matches this type
hr = FindEAPRegistryIndex(dwType, NULL, &hkey);
CHR(hr);
// Get the default flags for this type
cbSize = sizeof(*pdwFlags);
CBR(ERROR_SUCCESS == RegQueryValueEx(hkey, g_szRegValueEAPFlags, NULL, &dwValueType,
(BYTE*)pdwFlags, &cbSize) && REG_DWORD == dwValueType);
Error:
if (NULL != hkey)
{
RegCloseKey(hkey);
}
return hr;
}
HRESULT GetEAPDefaultType(DWORD *pdwType)
{
HRESULT hr = S_OK;
HKEY hkey = NULL;
DWORD dwValueType;
DWORD cbSize;
// Open the default type key
hr = OpenEAPRegistryKey(0, &hkey);
CHR(hr);
// Get the type code
cbSize = sizeof(*pdwType);
CBR(ERROR_SUCCESS == RegQueryValueEx(hkey, g_szRegValueEAPType, NULL, &dwValueType,
(BYTE*)pdwType, &cbSize) && REG_DWORD == dwValueType);
Error:
if (NULL != hkey)
{
RegCloseKey(hkey);
}
return hr;
}
void OnEAPProps(HWND hDlg, PWLAN_CFG_PROPS psProp)
{
HRESULT hr = S_OK;
HINSTANCE hinstEAPDll = NULL;
WZC_EAP_CB_ITEMDATA *pEapCbItemData;
PEAP_EXTENSION_INFO pCurExt=NULL;
HWND hwndCbEAPType = GetDlgItem(hDlg, IDC_WZC_COMBO_EAP_TYPE);
int iListIndex = ComboBox_GetCurSel(hwndCbEAPType);
DWORD dwError = (DWORD)-1;
UCHAR *pConnectionDataOut=NULL;
DWORD dwSizeOfConnectionDataOut=0;
UNREFERENCED_PARAMETER(psProp);
pEapCbItemData = (WZC_EAP_CB_ITEMDATA *)ComboBox_GetItemData(hwndCbEAPType,iListIndex);
if (pEapCbItemData)
{
pCurExt = pEapCbItemData->pEapExtInfo;
}
if (pCurExt && pCurExt->wszConfigUIPath)
{
RASEAPINVOKECONFIGUI pfnEapConfig;
RASEAPFREE pfnEapFreeMem;
hinstEAPDll = LoadLibrary(pCurExt->wszConfigUIPath);
CBR(hinstEAPDll != NULL);
pfnEapConfig = (RASEAPINVOKECONFIGUI)GetProcAddress(hinstEAPDll,TEXT("RasEapInvokeConfigUI"));
pfnEapFreeMem= (RASEAPFREE)GetProcAddress(hinstEAPDll,TEXT("RasEapFreeMemory"));
CBR((pfnEapConfig != NULL) && (pfnEapFreeMem != NULL));
// Call into config UI
__try {
dwError = pfnEapConfig(pCurExt->dwExtensionType,
hDlg,
0, // flags TBD
pEapCbItemData->pbAuthData,
pEapCbItemData->dwAuthDataLen,
&pConnectionDataOut,
&dwSizeOfConnectionDataOut);
}
__except(WatsonReportFault(GetExceptionInformation(), EXCEPTION_EXECUTE_HANDLER))
{
}
CBR(dwError == ERROR_SUCCESS);
if (dwSizeOfConnectionDataOut && pConnectionDataOut)
{
if (pEapCbItemData->pbAuthData)
{
LocalFree(pEapCbItemData->pbAuthData);
}
pEapCbItemData->pbAuthData = LocalAlloc(LPTR, dwSizeOfConnectionDataOut);
CPR(pEapCbItemData->pbAuthData);
pEapCbItemData->dwAuthDataLen = dwSizeOfConnectionDataOut;
__try
{
memcpy(pEapCbItemData->pbAuthData,
pConnectionDataOut,dwSizeOfConnectionDataOut);
}
__except(WatsonReportFault(GetExceptionInformation(), EXCEPTION_EXECUTE_HANDLER))
{
LocalFree(pEapCbItemData->pbAuthData);
pEapCbItemData->pbAuthData = NULL;
pEapCbItemData->dwAuthDataLen = 0;
}
__try
{
pfnEapFreeMem(pConnectionDataOut);
}
__except(WatsonReportFault(GetExceptionInformation(), EXCEPTION_EXECUTE_HANDLER))
{
;
}
}
}
BOOL OnOKAuthentication(HWND hDlg, PWLAN_CFG_PROPS psProp, BOOL fValidate)
{
HRESULT hr = S_OK;
SHWZCNET wzcnet;
DWORD dwDisplayFlags = 0;
BOOL fApplyKey;
BOOL fVerified = FALSE;
DWORD dwMask = SHWZCF_SETMASK_AUTHENTICATION | SHWZCF_SETMASK_ENCRYPTION | SHWZCF_SETMASK_KEYINDEX;
// Get the UI settings
memcpy(&wzcnet, &psProp->wzcnet, sizeof(SHWZCNET));
hr = UpdateDataAuthentication(hDlg, &wzcnet, FALSE);
CHR(hr);
// Check for valid authentication and encryption configuration
if (fValidate &&
!SHWZCValidateSecurityConfig(wzcnet.dwAuthentication,
wzcnet.dwEncryptionType,
BOOLIFY(SHWZCF_NET_ADHOC & wzcnet.dwFlags)))
{
DisplayError(hDlg, IDS_WZC_INVALID_CONFIG, IDC_WZC_COMBO_AUTHENTICATION);
CBR(FALSE);
}
// Get the display flags
hr = SHWZCGetDisplayFlags(&wzcnet, &dwDisplayFlags);
CHR(hr);
// Only verify the key if the key material is touched
if (!(SHWZCF_UI_KEYDATA_DISABLED & dwDisplayFlags) &&
(SHWZCF_NET_KEYDATA & wzcnet.dwFlags) &&
(WZCDLG_PROPS_KEYTOUCHED & psProp->dwFlags))
{
TCHAR szKeyBuf[WZCCTL_MAX_WEPK_MATERIAL * 2 + 1];
DDX_Text(hDlg, IDC_WZC_EDIT_WEP, szKeyBuf, ARRAYSIZE(szKeyBuf), FALSE);
if(fValidate)
{
BOOL fDisplayError = FALSE;
if(TEXT('\0') == szKeyBuf[0])
{
// only adhoc networks can have an empty string as a key
if(BOOLIFY(SHWZCF_NET_ADHOC & psProp->wzcnet.dwFlags))
{
// make sure apply key doesn't get set. This way if the user validates this state, the wifi netkey will not display *'s when
// when editing the network.
wzcnet.dwFlags &= ~SHWZCF_NET_KEYDATA;
}
else
{
fDisplayError = TRUE;
}
}
else
{
if (SHWZCValidateKey(szKeyBuf, wzcnet.dwEncryptionType, wzcnet.dwAuthentication))
{
fVerified = TRUE;
}
else
{
fDisplayError = TRUE;
}
}
if(fDisplayError)
{
DisplayError(hDlg, IDS_WZC_INCORRECT_WEP_KEY, IDC_WZC_EDIT_WEP);
CBR(FALSE);
}
}
// Copy the key data into the buffer
hr = StringCchCopy(psProp->pszKey, ARRAYSIZE(psProp->pszKey), szKeyBuf);
CHRA(hr); // this should always work
}
// Apply the changes to the network
fApplyKey = (!(SHWZCF_NET_KEYDATA & wzcnet.dwFlags) || (WZCDLG_PROPS_KEYTOUCHED & psProp->dwFlags));
dwMask |= (fApplyKey ? SHWZCF_SETMASK_KEYDATA : 0);
hr = SHWZCCopySettings(&psProp->wzcnet, &wzcnet, dwMask);
CHR(hr);
// Success
psProp->dwMask |= dwMask;
if(fVerified)
{
// at this point we can say the WEP key is untouched since it's been verified
psProp->dwFlags &= ~WZCDLG_PROPS_KEYTOUCHED;
}
Error:
return SUCCEEDED(hr);
}
DWORD
EapTlsInvokeConfigUI(
IN DWORD dwEapTypeId,
IN HWND hwndParent,
IN DWORD dwFlags,
IN BYTE* pConnectionDataIn,
IN DWORD dwSizeOfConnectionDataIn,
OUT BYTE** ppConnectionDataOut,
OUT DWORD* pdwSizeOfConnectionDataOut
)
{
UNREFERENCED_PARAMETER(dwFlags);
EAPTLS_CONN_PROPERTIES_V1* pConnProp = NULL;
PCCERT_CONTEXT pCertContext = NULL;
HCERTSTORE hMyStore = NULL;
DWORD dwErr = NO_ERROR;
HRESULT hr = S_OK;
DWORD cbHash = 0, dwConnFlags;
BYTE bHash[MAX_HASH_SIZE], *pbHashCert = NULL;
BOOL bSuccess, fCapi2 = FALSE;
INT cnCerts = 0, nSelected = -1;
DWORD dwValidServerClert, dwType, cb;
hr = LoadCAPI2();
CHR(hr);
fCapi2 = TRUE;
dwConnFlags = (dwEapTypeId == PPP_EAP_PEAP) ? EAPTLS_CONN_FLAG_NO_CLIENT_CERT : 0;
cb = sizeof(dwValidServerClert);
if (ERROR_SUCCESS == SHRegQueryValueEx(HKEY_CURRENT_USER, c_szValidateServerCert,
(DWORD *)c_szRegistryKey, &dwType, (BYTE *)&dwValidServerClert, &cb))
{
CBR(REG_DWORD == dwType);
// dwValidServerClert = 0 - don't validate server certification
if (dwValidServerClert == 0)
{
dwConnFlags |= EAPTLS_CONN_FLAG_NO_VALIDATE_CERT; // we do not validate server cert by default
}
}
else
{
// We dvalidates server cert by default
}
pConnProp = InitConnectionData(pConnectionDataIn, dwSizeOfConnectionDataIn, dwConnFlags);
CPR(pConnProp);
hMyStore = pfnCertOpenStore(CERT_STORE_PROV_SYSTEM_W, CRYPT_ASN_ENCODING,
0, CERT_SYSTEM_STORE_CURRENT_USER, TEXT("MY"));
CBR(hMyStore);
// Enum on personal cert store
while (NULL != (pCertContext = pfnCertEnumCertificatesInStore(hMyStore, pCertContext)))
{
BYTE bHashTemp[MAX_HASH_SIZE];
DWORD cbHashTemp = ARRAYSIZE(bHashTemp);
bSuccess = pfnCertGetCertificateContextProperty(pCertContext, CERT_HASH_PROP_ID,
bHashTemp, &cbHashTemp);
if ( nSelected < 0 // There is matched cert
&& cbHashTemp
&& cbHashTemp == pConnProp->UserHash.cbHash // The size of certs are equal
&& memcmp(bHashTemp, pConnProp->UserHash.pbHash, cbHashTemp) == 0)
{
nSelected = cnCerts;
cbHash = cbHashTemp;
memcpy(bHash, bHashTemp, cbHash);
}
cnCerts++;
}
if (cnCerts == 0)
{
// There is no cert on the device, warrning!
MessageBox(SHGetLastActiveWindow(hwndParent),
(PTSTR)LoadString(HINST_RESDLL, IDS_NETUI_EAPTLS_NO_CERT, NULL, 0),
(PTSTR)LoadString(HINST_RESDLL, IDS_NETUI_WRN_TITLE_WARNING, NULL, 0),
MB_OK | MB_SETFOREGROUND);
dwErr = ERROR_NOT_FOUND;
}
else if (cnCerts > 0)
{
DWORD cbHashCert = 0;
// Need to let user choice one
hr = PickCertificateDlg(NULL, TEXT("MY"), c_szPickCertHelpLink,
(PTSTR)LoadString(HINST_RESDLL, IDS_NETUI_EAPTLS_DESC, NULL, 0),
bHash, cbHash,
&pbHashCert, &cbHashCert);
CHR(hr);
CBRA(cbHashCert <= MAX_HASH_SIZE);
memcpy(pConnProp->UserHash.pbHash, pbHashCert, cbHashCert);
pConnProp->UserHash.cbHash = cbHashCert;
*ppConnectionDataOut = (BYTE*)pConnProp;
*pdwSizeOfConnectionDataOut = pConnProp->dwSize;
}
Error:
pfnCertFreeCertificateContext(pCertContext);
pfnCertCloseStore(hMyStore, 0);
LocalFree(pbHashCert);
if (fCapi2)
{
FreeCAPI2();
}
return FAILED(hr) ? ERROR_NOT_FOUND : dwErr;
}
DWORD
RasEapInvokeInteractiveUI(
IN DWORD dwEapTypeId,
IN HWND hwndParent,
IN BYTE* pUIContextData,
IN DWORD dwSizeofUIContextData,
OUT BYTE** ppDataFromInteractiveUI,
OUT DWORD* pdwSizeOfDataFromInteractiveUI
)
{
HRESULT hr = E_FAIL; // assume not supported
UNREFERENCED_PARAMETER(dwSizeofUIContextData);
if (PPP_EAP_TLS == dwEapTypeId)
{
EAPEXTUI_INPUT *pExtUIInput;
*ppDataFromInteractiveUI = NULL;
*pdwSizeOfDataFromInteractiveUI = 0;
pExtUIInput = (EAPEXTUI_INPUT *)pUIContextData;
if (NULL != pExtUIInput
&& pExtUIInput->dwVersion == 1
&& pExtUIInput->dwSize >= sizeof(EAPEXTUI_INPUT)
)
{
hr = S_OK; // assume success
switch(pExtUIInput->dwCode)
{
default:
CBR(FALSE);
case EAPEXTUI_CODE_CLIENTAUTH_ERROR:
break;
case EAPEXTUI_CODE_SERVERAUTH_ERROR:
{
TCHAR szMutexName[64];
LPCTSTR pszErrorTitle;
LPCTSTR pszErrorString;
UINT uStringID;
UINT uType = MB_OK;
HANDLE hMutex;
if (pExtUIInput->fFlags & EAPEXTUI_FLAG_RESPONSE)
{
// response expected
uType = MB_YESNO;
}
switch (pExtUIInput->dwStatus)
{
case SEC_E_UNTRUSTED_ROOT:
uStringID = IDS_NETUI_UNKNOWN_ROOT_ERROR;
break;
case SEC_E_CERT_UNKNOWN:
uStringID = IDS_NETUI_UNKNOWN_CERT_ERROR;
break;
case SEC_E_CERT_EXPIRED:
uStringID = IDS_NETUI_CERT_EXPIRED_ERROR;
break;
default:
uStringID = IDS_NETUI_GENERIC_CERT_ERROR;
break;
}
pszErrorTitle = (LPCTSTR)LoadString(HINST_RESDLL, IDS_NETUI_SERVER_VALIDATION_ERROR, NULL, 0);
CBRA(NULL != pszErrorTitle);
pszErrorString = (LPCTSTR)LoadString(HINST_RESDLL, uStringID, NULL, 0);
CBRA(NULL != pszErrorString);
hr = StringCchPrintf(szMutexName, ARRAYSIZE(szMutexName),
TEXT("%s%X"), TEXT("IPInteractUI"), uStringID);
CHR(hr);
hMutex = CheckPrevInstance(szMutexName);
if(INVALID_HANDLE_VALUE != hMutex)
{
int nRet = MessageBox(SHGetLastActiveWindow(hwndParent),
pszErrorString, pszErrorTitle,
uType | MB_TOPMOST | MB_SETFOREGROUND);
CloseHandle(hMutex);
if (pExtUIInput->fFlags & EAPEXTUI_FLAG_RESPONSE)
{
// response expected
EAPEXTUI_OUTPUT *pExtUIOutput = (EAPEXTUI_OUTPUT *)LocalAlloc(LPTR, sizeof(EAPEXTUI_OUTPUT));
if (pExtUIOutput)
{
pExtUIOutput->dwVersion =1;
pExtUIOutput->dwSize = sizeof(EAPEXTUI_OUTPUT);
pExtUIOutput->dwValue = nRet;
*ppDataFromInteractiveUI = (PBYTE)pExtUIOutput;
*pdwSizeOfDataFromInteractiveUI = pExtUIOutput->dwSize;
}
}
}
} // case EAPEXTUI_CODE_SERVERAUTH_ERROR
break;
}
}
}
Error:
return SUCCEEDED(hr) ? NO_ERROR : ERROR_NOT_SUPPORTED;
}
void debayer_ccm_uyvy(unicap_data_buffer_t *destbuf, unicap_data_buffer_t *srcbuf,
debayer_data_t *data) {
int i, j;
int dest_offset = 0;
unsigned char *dest = destbuf->data;
unsigned char *source = srcbuf->data;
int width = destbuf->format.size.width;
int height = destbuf->format.size.height;
for (j = 2; j < height - 2; j += 2) {
int lineoffset = j * width;
dest_offset = j * width * 2 + 2;
for (i = 1; i < width - 2;) {
int r, g, b;
int g1 = source[lineoffset + i - 1];
int g2 = source[lineoffset + i + 1];
int g3 = source[(lineoffset + i) - width];
int g4 = source[lineoffset + i + width];
int d1 = ABS(g1 - g2);
int d2 = ABS(g3 - g4);
b = source[lineoffset + i];
r = (((int)source[((lineoffset + i) - width) + 1] +
(int)source[(lineoffset + i + width) + 1] +
(int)source[((lineoffset + i) - width) - 1] +
(int)source[(lineoffset + i + width) - 1]) /
4);
if (d1 < d2) {
g = (g1 + g2) / 2;
} else {
g = (g3 + g4) / 2;
}
if (data->use_ccm) {
r = CLIP((r * CRR(data->ccm) + g * CRG(data->ccm) + b * CRB(data->ccm)) / 1024);
g = CLIP((r * CGR(data->ccm) + g * CGG(data->ccm) + b * CGB(data->ccm)) / 1024);
b = CLIP((r * CBR(data->ccm) + g * CBG(data->ccm) + b * CBB(data->ccm)) / 1024);
} else if (data->use_rbgain) {
r = CLIP((r * data->rgain) / 1024);
b = CLIP((b * data->bgain) / 1024);
}
dest[dest_offset++] = YUV_V(r, g, b);
dest[dest_offset++] = YUV_Y(r, g, b);
i++;
g = g2;
b = ((int)source[(lineoffset + i) - 1] + (int)source[(lineoffset + i) + 1]) / 2;
r = ((int)source[(lineoffset + i) - width] + (int)source[lineoffset + i + width]) / 2;
if (data->use_ccm) {
r = CLIP((r * CRR(data->ccm) + g * CRG(data->ccm) + b * CRB(data->ccm)) / 1024);
g = CLIP((r * CGR(data->ccm) + g * CGG(data->ccm) + b * CGB(data->ccm)) / 1024);
b = CLIP((r * CBR(data->ccm) + g * CBG(data->ccm) + b * CBB(data->ccm)) / 1024);
} else if (data->use_rbgain) {
r = CLIP((r * data->rgain) / 1024);
b = CLIP((b * data->bgain) / 1024);
}
dest[dest_offset++] = YUV_U(r, g, b);
dest[dest_offset++] = YUV_Y(r, g, b);
i++;
}
lineoffset += width;
dest_offset = (j + 1) * width * 2 + 4;
for (i = 2; i < width - 3;) {
int r, g, b;
int g1 = source[lineoffset + i - 1];
int g2 = source[lineoffset + i + 1];
int g3 = source[(lineoffset + i) - width];
int g4 = source[lineoffset + i + width];
int d1 = ABS(g1 - g2);
int d2 = ABS(g3 - g4);
r = source[lineoffset + i];
if (d1 < d2) {
g = (g1 + g2) / 2;
}
else {
g = (g3 + g4) / 2;
}
b = (((int)source[((lineoffset + i) - width) + 1] +
(int)source[(lineoffset + i + width) + 1] +
(int)source[((lineoffset + i) - width) - 1] +
(int)source[(lineoffset + i + width) - 1]) /
4);
if (data->use_ccm) {
r = CLIP((r * CRR(data->ccm) + g * CRG(data->ccm) + b * CRB(data->ccm)) / 1024);
g = CLIP((r * CGR(data->ccm) + g * CGG(data->ccm) + b * CGB(data->ccm)) / 1024);
b = CLIP((r * CBR(data->ccm) + g * CBG(data->ccm) + b * CBB(data->ccm)) / 1024);
} else if (data->use_rbgain) {
r = CLIP((r * data->rgain) / 1024);
b = CLIP((b * data->bgain) / 1024);
}
dest[dest_offset++] = YUV_U(r, g, b);
dest[dest_offset++] = YUV_Y(r, g, b);
i++;
g = g2;
r = ((int)source[(lineoffset + i) - 1] + (int)source[(lineoffset + i) + 1]) / 2;
b = ((int)source[(lineoffset + i) - width] + (int)source[lineoffset + i + width]) / 2;
if (data->use_ccm) {
r = CLIP((r * CRR(data->ccm) + g * CRG(data->ccm) + b * CRB(data->ccm)) / 1024);
g = CLIP((r * CGR(data->ccm) + g * CGG(data->ccm) + b * CGB(data->ccm)) / 1024);
b = CLIP((r * CBR(data->ccm) + g * CBG(data->ccm) + b * CBB(data->ccm)) / 1024);
} else if (data->use_rbgain) {
r = CLIP((r * data->rgain) / 1024);
b = CLIP((b * data->bgain) / 1024);
}
dest[dest_offset++] = YUV_V(r, g, b);
dest[dest_offset++] = YUV_Y(r, g, b);
i++;
}
}
}
IPSTATE GetIPState(LPCTSTR pszAdapter, LPTSTR pszAddress, UINT cchAddress)
{
HRESULT hr = S_OK;
IPSTATE state = IPSTATE_DHCP;
ULONG ulAdapterIndex;
PIP_ADAPTER_INFO paiBuffer = NULL;
ULONG cbBuffer = 0;
DWORD dwError;
PIP_ADAPTER_INFO paiCurrent;
PIP_PER_ADAPTER_INFO pper = NULL;
// Check inputs
CBRAEx(NULL != pszAdapter, E_INVALIDARG);
// Get the adapter index
CBR(NO_ERROR == GetAdapterIndex(const_cast<LPWSTR>(pszAdapter), &ulAdapterIndex));
// Get the status of all connected adapters
cbBuffer = sizeof(IP_ADAPTER_INFO);
paiBuffer = (PIP_ADAPTER_INFO)LocalAlloc(LMEM_FIXED, cbBuffer);
CPR(paiBuffer);
while (ERROR_BUFFER_OVERFLOW == (dwError = GetAdaptersInfo(paiBuffer, &cbBuffer)))
{
PIP_ADAPTER_INFO paiTemp = (PIP_ADAPTER_INFO)LocalReAlloc(paiBuffer, cbBuffer, LMEM_MOVEABLE);
CPR(paiTemp);
paiBuffer = paiTemp;
}
CBR(NO_ERROR == dwError);
// Find our adapter index
for (paiCurrent = paiBuffer; paiCurrent; paiCurrent = paiCurrent->Next)
{
if (paiCurrent->Index == ulAdapterIndex)
{
break;
}
}
CBR(NULL != paiCurrent); // did we find it?
CBR(NULL != paiCurrent->CurrentIpAddress);
// Is this adapter using DHCP?
if (!paiCurrent->DhcpEnabled)
{
state = IPSTATE_CONNECTED;
}
else
{
// Get the per-adapter info
cbBuffer = sizeof(IP_PER_ADAPTER_INFO);
pper = (PIP_PER_ADAPTER_INFO)LocalAlloc(LMEM_FIXED, cbBuffer);
CPR(pper);
while (ERROR_BUFFER_OVERFLOW == (dwError = GetPerAdapterInfo(ulAdapterIndex, pper, &cbBuffer)))
{
PIP_PER_ADAPTER_INFO pperTemp = (PIP_PER_ADAPTER_INFO)LocalReAlloc(pper, cbBuffer, LMEM_MOVEABLE);
CPR(pperTemp);
pper = pperTemp;
}
CBR(NO_ERROR == dwError);
// Are we using an automatic IP?
if (pper->AutoconfigActive || IsAutoIPAddr(paiCurrent->CurrentIpAddress->IpAddress.String))
{
state = IPSTATE_AUTOIP;
}
}
// Optionally copy the IP address string to the output
if (NULL != pszAddress && 0 != cchAddress)
{
UINT cchInput = strlen(paiCurrent->CurrentIpAddress->IpAddress.String);
if (cchInput >= cchAddress)
{
cchInput = cchAddress - 1;
}
MultiByteToWideChar(CP_ACP, 0,
paiCurrent->CurrentIpAddress->IpAddress.String, cchInput,
pszAddress, cchAddress);
pszAddress[cchAddress-1] = TEXT('\0');
}
Error:
LocalFree(pper);
LocalFree(paiBuffer);
return (SUCCEEDED(hr) ? state : IPSTATE_DISCONNECTED);
}
