//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1997-1999.
//
// File: U T I L. C P P
//
// Contents: Utility functions shared within lanui
//
//
//----------------------------------------------------------------------------
#include "pch.h"
#pragma hdrstop
#include "resource.h"
#include "ncreg.h"
#include "ncnetcon.h"
#include "ncnetcfg.h"
#include "ncsetup.h"
#include "lanui.h"
#include "util.h"
#include "chklist.h"
#include "lanuiobj.h"
#include "ncui.h"
#include "ndispnp.h"
#include "ncperms.h"
#include "ncmisc.h"
#include "wzcsapi.h"
#include <raseapif.h>
#include <raserror.h>
#include "connutil.h"
#define INITGUID
#include "ncxclsid.h"
#undef INITGUID
extern const WCHAR c_szBiNdisAtm[];
extern const WCHAR c_szDevice[];
extern const WCHAR c_szInfId_MS_TCPIP[];
//+---------------------------------------------------------------------------
//
// Function Name: HrInitCheckboxListView
//
// Purpose: Initialize the list view for checkboxes.
//
// Arguments:
// hwndList[in]: Handle of the list view
// philStateIcons[out]: Image list for the list view
// pcild [in,optional] Image list data, created if necessary
//
// Returns: HRESULT, Error code.
//
// Notes:
//
HRESULT HrInitCheckboxListView(HWND hwndList, HIMAGELIST* philStateIcons, SP_CLASSIMAGELIST_DATA* pcild)
{
HRESULT hr = S_OK;
RECT rc;
LVCOLUMN lvc = {0};
HWND hwndHeader;
// Create small image lists
//
if(NULL == pcild)
{
pcild = new SP_CLASSIMAGELIST_DATA;
if(pcild)
{
hr = HrSetupDiGetClassImageList(pcild);
if (SUCCEEDED(hr))
{
AssertSz(pcild->ImageList, "No class image list data!");
// Save off image list data for use later
::SetWindowLongPtr(GetParent(hwndList), GWLP_USERDATA,
reinterpret_cast<LONG_PTR>(pcild));
}
else
{
TraceError("HrSetupDiGetClassImageList returns failure", hr);
hr = S_OK;
// delete this if we couldn't get the structure
delete pcild;
::SetWindowLongPtr(GetParent(hwndList), GWLP_USERDATA, 0);
}
}
else
{
hr = E_OUTOFMEMORY;
}
}
if(SUCCEEDED(hr))
{
ListView_SetImageList(hwndList, pcild->ImageList, LVSIL_SMALL);
// Set the shared image lists bit so the caller can destroy the class
// image lists itself
//
DWORD dwStyle = GetWindowLong(hwndList, GWL_STYLE);
SetWindowLong(hwndList, GWL_STYLE, (dwStyle | LVS_SHAREIMAGELISTS));
// Create state image lists
*philStateIcons = ImageList_LoadBitmapAndMirror(
_Module.GetResourceInstance(),
MAKEINTRESOURCE(IDB_CHECKSTATE),
16,
0,
PALETTEINDEX(6));
ListView_SetImageList(hwndList, *philStateIcons, LVSIL_STATE);
// First determine if we have already added a column before
// adding one.
//
hwndHeader = ListView_GetHeader( hwndList );
Assert( hwndHeader );
if ( (!hwndHeader) ||
(Header_GetItemCount(hwndHeader) == 0) )
{
GetClientRect(hwndList, &rc);
lvc.mask = LVCF_FMT | LVCF_WIDTH;
lvc.fmt = LVCFMT_LEFT;
lvc.cx = rc.right;
// $REVIEW(tongl 12\22\97): Fix for bug#127472
// lvc.cx = rc.right - GetSystemMetrics(SM_CXVSCROLL);
ListView_InsertColumn(hwndList, 0, &lvc);
}
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Function Name: HrInitListView
//
// Purpose: Initialize the list view.
// Iterate through all installed clients, services and protocols,
// insert into the list view with the correct binding state with
// the adapter used in this connection.
//
// Arguments:
// hwndList[in]: Handle of the list view
// pnc[in]: The writable INetcfg pointer
// pnccAdapter[in]: The INetcfgComponent pointer to the adapter used in this connection
//
// Returns: HRESULT, Error code.
//
// Notes:
//
HRESULT HrInitListView(HWND hwndList,
INetCfg* pnc,
INetCfgComponent * pnccAdapter,
ListBPObj * plistBindingPaths,
HIMAGELIST* philStateIcons)
{
HRESULT hr = S_OK;
SP_CLASSIMAGELIST_DATA *pcild;
Assert(hwndList);
Assert(pnc);
Assert(pnccAdapter);
Assert(plistBindingPaths);
Assert(philStateIcons);
pcild = (SP_CLASSIMAGELIST_DATA *)::GetWindowLongPtr(::GetParent(hwndList),
GWLP_USERDATA);
HrInitCheckboxListView(hwndList, philStateIcons, pcild);
hr = HrRefreshAll(hwndList, pnc, pnccAdapter, plistBindingPaths);
if (SUCCEEDED(hr))
{
// Selete the first item
ListView_SetItemState(hwndList, 0, LVIS_SELECTED|LVIS_FOCUSED, LVIS_SELECTED|LVIS_FOCUSED);
}
TraceError("HrInitListView", hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: UninitListView
//
// Purpose: Uninitializes the common component list view
//
// Arguments:
// hwndList [in] HWND of listview
//
// Returns: Nothing
//
// Author: danielwe 2 Feb 1998
//
// Notes:
//
VOID UninitListView(HWND hwndList)
{
SP_CLASSIMAGELIST_DATA * pcild;
Assert(hwndList);
// delete existing items in the list view
ListView_DeleteAllItems( hwndList );
pcild = reinterpret_cast<SP_CLASSIMAGELIST_DATA *>(
::GetWindowLongPtr(GetParent(hwndList), GWLP_USERDATA));
if (pcild)
{
// Destroy the class image list data
(VOID) HrSetupDiDestroyClassImageList(pcild);
delete pcild;
}
}
//+---------------------------------------------------------------------------
//
// Function Name: HrInsertComponent
//
// Purpose: Insert all installed, non-hidden and bindable components
// of a class to the list view
//
// Arguments:
//
// Returns: HRESULT, Error code.
//
// Notes:
//
HRESULT HrInsertComponent(
IN HWND hwndList,
IN const GUID* pGuidDevClass,
IN INetCfgComponent *pncc,
IN INetCfgComponent *pnccAdapter,
IN DWORD dwFlags,
IN ListBPObj * plistBindingPaths,
IN OUT INT* pnPos)
{
HRESULT hr = S_OK;
SP_CLASSIMAGELIST_DATA * pcild;
Assert(hwndList);
Assert(pGuidDevClass);
pcild = reinterpret_cast<SP_CLASSIMAGELIST_DATA *>
(::GetWindowLongPtr(GetParent(hwndList), GWLP_USERDATA));
// We should only list components that are bindable to the adapter
// Note: bindable means binding path exists, either enabled or disabled
INetCfgComponentBindings * pnccb;
hr = pncc->QueryInterface(IID_INetCfgComponentBindings, (LPVOID *)&pnccb);
if (S_OK == hr)
{
// Do this only for protocols !!
// $REVIEW(TongL 3/28/99), I included the 2 reasons on why we only filter
// non-bindable protocols below, in case someone ask again ..
// 1) (Originally per BillBe) The add component dialog filters out non-bindable
// protocols by matching binding interface names from INF, it can not easily do
// so for services/clients which could be several layers above the adapter.
// The property UI needs to be consistent because it's confusing to users if
// we allow them to add a component from a connection but don't let that
// component show up in the same connection's property UI.
// 2) (Per ShaunCo) After talking with Bill, we show protocols yet not clients
// services not to be consistent with the add component dialog, but because
// you cannot predict based on bindings alone whether a client or service will
// end up being involved with an adapter. example: i can install a service
// that doesn't bind and uses winsock to send data. It may be able to be configured
// differently for each adapter (and hence would need to show up for each adapter's
// connection) but you can't tell by any means whether its going to be invovled with
// that adapter or not. -- So you have to show all services and clients.
// A protocol, on the other hand, binds with adapters by definition. So, we know
// for the protocol's which will use an adapter and which won't.
// Special case: do now show filter components unless it is bindable,
// Raid 358865
DWORD dwFlags;
hr = pncc->GetCharacteristics(&dwFlags);
if ((SUCCEEDED(hr) && (dwFlags & NCF_FILTER)) ||
(GUID_DEVCLASS_NETTRANS == *pGuidDevClass))
{
// $REVIEW(ShaunCo 3/26/99)
// To see if the protocol is involved with the adapter, check the
// owner of each bindpath and see if its equal to the component
// we are considering inserting into the list view.
// Note the special case for ms_nwnb. It won't be involved in a
// direct binding to the adapter because it has NCF_DONTEXPOSELOWER,
// so we can't use IsBindableTo.
BOOL fProtocolIsInvolved = FALSE;
ListBPObj_ITER iter;
for (iter = plistBindingPaths->begin();
(iter != plistBindingPaths->end() && !fProtocolIsInvolved);
iter++)
{
INetCfgComponent* pScan;
hr = (*iter)->m_pncbp->GetOwner(&pScan);
if (S_OK == hr)
{
if (pScan == pncc)
{
fProtocolIsInvolved = TRUE;
}
ReleaseObj(pScan);
}
}
if (!fProtocolIsInvolved)
{
// Don't insert this protocol because it is not involved
// in the binding set for the adpater.
//
hr = S_FALSE;
}
}
if (S_OK == hr) // bindable, add to list
{
PWSTR pszwName;
hr = pncc->GetDisplayName(&pszwName);
if (SUCCEEDED(hr))
{
PWSTR pszwDesc;
// Special Case:
// If this is a Domain Controller,
// disable tcpip removal, Raid 263754
//
if (GUID_DEVCLASS_NETTRANS == *pGuidDevClass)
{
PWSTR pszwId;
hr = pncc->GetId (&pszwId);
if (SUCCEEDED(hr))
{
if (FEqualComponentId (c_szInfId_MS_TCPIP, pszwId))
{
NT_PRODUCT_TYPE pt;
RtlGetNtProductType (&pt);
if (NtProductLanManNt == pt)
{
dwFlags |= NCF_NOT_USER_REMOVABLE;
}
}
CoTaskMemFree (pszwId);
}
}
hr = pncc->GetHelpText(&pszwDesc);
if (SUCCEEDED(hr))
{
LV_ITEM lvi = {0};
lvi.mask = LVIF_TEXT | LVIF_IMAGE |
LVIF_STATE | LVIF_PARAM;
// Get the component's class image list index
if (pcild)
{
INT nIndex = 0;
(VOID) HrSetupDiGetClassImageIndex(pcild,
pGuidDevClass, &nIndex);
lvi.iImage = nIndex;
}
lvi.iItem = *pnPos;
NET_ITEM_DATA * pnid = new NET_ITEM_DATA;
if (pnid)
{
pnid->szwName = SzDupSz(pszwName);
pnid->szwDesc = SzDupSz(pszwDesc);
pnid->dwFlags = dwFlags;
AddRefObj(pnid->pncc = pncc);
pnid->pCompObj = new CComponentObj(pncc);
if (pnid->pCompObj)
{
hr = pnid->pCompObj->HrInit(plistBindingPaths);
if FAILED(hr)
{
TraceError("HrInsertComponent: failed to initialize a component object", hr);
hr = S_OK;
}
}
lvi.lParam = reinterpret_cast<LPARAM>(pnid);
lvi.pszText = pnid->szwName;
// We will refresh the state of the whole list in the end
UINT iChkIndex = SELS_CHECKED;
lvi.state = INDEXTOSTATEIMAGEMASK( iChkIndex );
INT ret;
ret = ListView_InsertItem(hwndList, &lvi);
(*pnPos)++;
CoTaskMemFree(pszwDesc);
}
}
CoTaskMemFree(pszwName);
}
}
ReleaseObj(pnccb);
}
TraceError("HrInsertComponent", S_FALSE == hr ? S_OK : hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Function Name: HrInsertComponents
//
// Purpose: Insert installed and non-hidden components
// of a class to the list view
//
// Arguments:
//
// Returns: HRESULT, Error code.
//
// Notes:
//
HRESULT HrInsertComponents(
IN HWND hwndList,
IN INetCfg* pnc,
IN const GUID* pGuidDevClass,
IN INetCfgComponent* pnccAdapter,
IN ListBPObj* plistBindingPaths,
IN OUT INT* pnPos)
{
Assert(hwndList);
HRESULT hr = S_OK;
CIterNetCfgComponent iterComp (pnc, pGuidDevClass);
INetCfgComponent* pncc;
while (SUCCEEDED(hr) && S_OK == (hr = iterComp.HrNext(&pncc)))
{
DWORD dwFlags;
hr = pncc->GetCharacteristics(&dwFlags);
// Make sure it's not hidden
if (SUCCEEDED(hr) && !(dwFlags & NCF_HIDDEN))
{
// This will AddRef pncc so the release below can still be
// there
hr = HrInsertComponent(
hwndList, pGuidDevClass, pncc, pnccAdapter,
dwFlags, plistBindingPaths, pnPos);
}
ReleaseObj(pncc);
}
if (SUCCEEDED(hr))
{
// Get rid of FALSE returns
hr = S_OK;
}
TraceError("HrInsertComponents", hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Function Name: HrRefreshListView
//
// Purpose: Iterate through all installed clients, services and protocols,
// insert into the list view with the correct binding state with
// the adapter used in this connection.
//
// Arguments:
// hwndList[in]: Handle of the list view
// pnc[in]: The writable INetcfg pointer
// pnccAdapter[in]: The INetcfgComponent pointer to the adapter used in this connection
//
// Returns: HRESULT, Error code.
//
// Notes:
//
HRESULT HrRefreshListView(HWND hwndList,
INetCfg* pnc,
INetCfgComponent * pnccAdapter,
ListBPObj * plistBindingPaths)
{
HRESULT hr;
INT nPos = 0;
Assert(hwndList);
// Clients
hr = HrInsertComponents(hwndList, pnc,
&GUID_DEVCLASS_NETCLIENT, pnccAdapter, plistBindingPaths,
&nPos);
if (SUCCEEDED(hr))
{
// Services
hr = HrInsertComponents(hwndList, pnc,
&GUID_DEVCLASS_NETSERVICE, pnccAdapter, plistBindingPaths,
&nPos);
}
if (SUCCEEDED(hr))
{
// Protocols
hr = HrInsertComponents(hwndList, pnc,
&GUID_DEVCLASS_NETTRANS, pnccAdapter, plistBindingPaths,
&nPos);
}
// Now refresh the state of all items
if (SUCCEEDED(hr))
{
hr = HrRefreshCheckListState(hwndList);
}
TraceError("HrRefreshListView", hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Function Name: HrLvGetSelectedComponent
//
// Purpose: Return pointer to the INetCfgComponent of the selected
// client, service or protocol
//
// Returns: S_OK if successful,
// S_FALSE if list view Macros returns failure
// (specific error not available).
//
// Notes:
//
HRESULT HrLvGetSelectedComponent(HWND hwndList,
INetCfgComponent ** ppncc)
{
HRESULT hr = S_FALSE;
Assert(hwndList);
*ppncc = NULL;
INT iSelected = ListView_GetNextItem(hwndList, -1, LVNI_SELECTED);
if (iSelected != -1)
{
LV_ITEM lvItem = {0};
lvItem.mask = LVIF_PARAM;
lvItem.iItem = iSelected;
if (ListView_GetItem(hwndList, &lvItem))
{
NET_ITEM_DATA * pnid;
pnid = reinterpret_cast<NET_ITEM_DATA *>(lvItem.lParam);
if (pnid)
{
hr = S_OK;
pnid->pncc->AddRef();
*ppncc = pnid->pncc;
}
}
}
TraceError("HrLvGetSelectedComponent", S_FALSE == hr ? S_OK : hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: LvDeleteItem
//
// Purpose: Handles deletion of the given item from the listview. Should
// be called in response to the LVN_DELETEITEM notification.
//
// Arguments:
// hwndList [in] Listview handle
// iItem [in] item that was deleted
//
// Returns: Nothing
//
// Author: danielwe 3 Nov 1997
//
// Notes:
//
VOID LvDeleteItem(HWND hwndList, int iItem)
{
LV_ITEM lvi = {0};
NET_ITEM_DATA * pnid;
lvi.mask = LVIF_PARAM;
lvi.iItem = iItem;
ListView_GetItem(hwndList, &lvi);
pnid = reinterpret_cast<NET_ITEM_DATA*>(lvi.lParam);
AssertSz(pnid, "No item data!?!?");
ReleaseObj(pnid->pncc);
delete(pnid->pCompObj);
delete pnid->szwName;
delete pnid->szwDesc;
delete pnid;
}
//+---------------------------------------------------------------------------
//
// Function Name: OnListClick
//
// Purpose:
//
// Returns:
//
INT OnListClick(HWND hwndList,
HWND hwndParent,
INetCfg *pnc,
IUnknown *punk,
INetCfgComponent *pnccAdapter,
ListBPObj * plistBindingPaths,
BOOL fDoubleClk,
BOOL fReadOnly)
{
INT iItem;
DWORD dwpts;
LV_HITTESTINFO lvhti;
// we have the location
dwpts = GetMessagePos();
lvhti.pt.x = LOWORD( dwpts );
lvhti.pt.y = HIWORD( dwpts );
MapWindowPoints(NULL , hwndList , (LPPOINT) &(lvhti.pt) , 1);
// get currently selected item
iItem = ListView_HitTest( hwndList, &lvhti );
// if no selection, or click not on state return false
if (-1 != iItem)
{
// set the current selection
ListView_SetItemState(hwndList, iItem, LVIS_SELECTED, LVIS_SELECTED);
if ( fDoubleClk )
{
if ((LVHT_ONITEMICON != (LVHT_ONITEMICON & lvhti.flags)) &&
(LVHT_ONITEMLABEL != (LVHT_ONITEMLABEL & lvhti.flags)) &&
(LVHT_ONITEMSTATEICON != (LVHT_ONITEMSTATEICON & lvhti.flags)) )
{
iItem = -1;
}
}
else // single click
{
if (LVHT_ONITEMSTATEICON != (LVHT_ONITEMSTATEICON & lvhti.flags))
{
iItem = -1;
}
}
if (-1 != iItem)
{
HRESULT hr = S_OK;
if ((fDoubleClk) &&
(LVHT_ONITEMSTATEICON != (LVHT_ONITEMSTATEICON & lvhti.flags)))
{
// only raise properties if the selected component has UI and
// is not disabled, and the current user has the permission to
// change properties.
LV_ITEM lvItem;
lvItem.mask = LVIF_PARAM;
lvItem.iItem = iItem;
lvItem.iSubItem = 0;
if (ListView_GetItem(hwndList, &lvItem))
{
NET_ITEM_DATA * pnid = NULL;
pnid = reinterpret_cast<NET_ITEM_DATA *>(lvItem.lParam);
if (pnid)
{
// is this component checked ?
if ((UNCHECKED != (pnid->pCompObj)->GetChkState()) &&
(pnid->dwFlags & NCF_HAS_UI) &&
FHasPermission(NCPERM_LanChangeProperties))
{
BOOL fShowProperties = TRUE;
if (FIsUserNetworkConfigOps())
{
LPWSTR pszwId;
hr = pnid->pncc->GetId(&pszwId);
if (SUCCEEDED(hr))
{
if (pszwId)
{
if (!FEqualComponentId (c_szInfId_MS_TCPIP, pszwId))
{
fShowProperties = FALSE;
}
else if (FEqualComponentId (c_szInfId_MS_TCPIP, pszwId))
{
fShowProperties = TRUE;
}
CoTaskMemFree(pszwId);
}
else
{
fShowProperties = FALSE;
}
}
else
{
fShowProperties = FALSE;
}
}
if (fShowProperties)
{
hr = HrLvProperties(hwndList, hwndParent, pnc, punk,
pnccAdapter, plistBindingPaths, NULL);
}
}
}
}
}
else
{
if (!fReadOnly)
{
hr = HrToggleLVItemState(hwndList, plistBindingPaths, iItem);
}
}
if FAILED(hr)
iItem = -1;
}
}
return( iItem );
}
//+---------------------------------------------------------------------------
//
// Function Name: HrToggleLVItemState
//
// Purpose:
//
// Returns:
//
HRESULT HrToggleLVItemState(HWND hwndList,
ListBPObj * plistBindingPaths,
INT iItem)
{
HRESULT hr = S_OK;
LV_ITEM lvItem;
NET_ITEM_DATA * pnid;
// we are interested in is the PARAM
lvItem.iItem = iItem;
lvItem.mask = LVIF_PARAM;
lvItem.iSubItem = 0;
ListView_GetItem( hwndList, &lvItem );
// get the item
pnid = (NET_ITEM_DATA *)lvItem.lParam;
// If the binding checkbox is available, then allow the toggle.
//
if (!(pnid->dwFlags & NCF_FIXED_BINDING) &&
FHasPermission(NCPERM_ChangeBindState))
{
if (pnid->pCompObj->GetChkState() == UNCHECKED) // toggle on
{
hr = pnid->pCompObj->HrCheck(plistBindingPaths);
if SUCCEEDED(hr)
{
hr = HrRefreshCheckListState(hwndList);
}
// "Ding" if the state of this item is still unchecked
if (pnid->pCompObj->GetChkState() == UNCHECKED)
{
#ifdef DBG
TraceTag(ttidLanUi, "Why is this component still disabled ???");
#endif
}
}
else // toggle off
{
hr = pnid->pCompObj->HrUncheck(plistBindingPaths);
if SUCCEEDED(hr)
{
hr = HrRefreshCheckListState(hwndList);
}
// "Ding" if the state of this item is not unchecked
if (pnid->pCompObj->GetChkState() != UNCHECKED)
{
#ifdef DBG
TraceTag(ttidLanUi, "Why is this component not disabled ???");
#endif
}
}
}
TraceError("HrToggleLVItemState", hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Function Name: OnListKeyDown
//
// Purpose:
//
// Returns:
//
INT OnListKeyDown(HWND hwndList, ListBPObj * plistBindingPaths, WORD wVKey)
{
INT iItem = -1;
if ((VK_SPACE == wVKey) && (GetAsyncKeyState(VK_MENU)>=0))
{
iItem = ListView_GetNextItem(hwndList, -1, LVNI_FOCUSED | LVNI_SELECTED);
// if no selection
if (-1 != iItem)
{
HRESULT hr = S_OK;
hr = HrToggleLVItemState(hwndList, plistBindingPaths, iItem);
if FAILED(hr)
iItem = -1;
}
}
return( iItem );
}
//+---------------------------------------------------------------------------
//
// Function Name: LvSetButtons
//
// Purpose: Set the correct status of Add, Remove, Property buttons,
// and the description text
//
// Returns:
//
VOID LvSetButtons(HWND hwndParent, HANDLES& h, BOOL fReadOnly, IUnknown * punk)
{
Assert(IsWindow(h.m_hList));
Assert(IsWindow(h.m_hAdd));
Assert(IsWindow(h.m_hRemove));
Assert(IsWindow(h.m_hProperty));
// enable Property button if valid and update description text
INT iSelected = ListView_GetNextItem(h.m_hList, -1, LVNI_SELECTED);
if (iSelected == -1) // Nothing selected or list empty
{
::EnableWindow(h.m_hAdd, !fReadOnly && FHasPermission(NCPERM_AddRemoveComponents));
if (!fReadOnly)
{
// if list is empty, set focus to the list view
if (0 == ListView_GetItemCount(h.m_hList))
{
// remove the default on the remove button
SendMessage(h.m_hRemove, BM_SETSTYLE, (WPARAM)BS_PUSHBUTTON, TRUE );
// move focus to the Add button
::SetFocus(h.m_hAdd);
}
}
::EnableWindow(h.m_hRemove, FALSE);
::EnableWindow(h.m_hProperty, FALSE);
if(h.m_hDescription)
{
::SetWindowText(h.m_hDescription, c_szEmpty);
}
}
else
{
// enable Add/Remove buttons
::EnableWindow(h.m_hAdd, !fReadOnly && FHasPermission(NCPERM_AddRemoveComponents));
LV_ITEM lvItem;
lvItem.mask = LVIF_PARAM;
lvItem.iItem = iSelected;
lvItem.iSubItem = 0;
if (ListView_GetItem(h.m_hList, &lvItem))
{
NET_ITEM_DATA * pnid = NULL;
pnid = reinterpret_cast<NET_ITEM_DATA *>(lvItem.lParam);
if (pnid)
{
if (fReadOnly)
{
::EnableWindow(h.m_hProperty, FALSE);
::EnableWindow(h.m_hRemove, FALSE);
}
else
{
// is this component checked ?
if (UNCHECKED != (pnid->pCompObj)->GetChkState())
{
BOOL fHasPropertyUi = FALSE;
HRESULT hr = S_OK;
INetCfgComponent * pncc;
LPWSTR pszwId;
hr = HrLvGetSelectedComponent(h.m_hList, &pncc);
if (S_OK == hr)
{
AssertSz(pncc, "No component selected?!?!");
hr = pncc->RaisePropertyUi(hwndParent, NCRP_QUERY_PROPERTY_UI, punk);
if (S_OK == hr)
{
fHasPropertyUi = TRUE;
}
ReleaseObj(pncc);
}
if (FIsUserNetworkConfigOps() && FHasPermission(NCPERM_LanChangeProperties))
{
hr = pncc->GetId(&pszwId);
if (SUCCEEDED(hr))
{
if (pszwId && !FEqualComponentId (c_szInfId_MS_TCPIP, pszwId))
{
::EnableWindow(h.m_hProperty, FALSE);
}
else if (pszwId && FEqualComponentId (c_szInfId_MS_TCPIP, pszwId) && fHasPropertyUi)
{
::EnableWindow(h.m_hProperty, TRUE);
}
}
}
else
{
::EnableWindow(h.m_hProperty,
fHasPropertyUi &&
FHasPermission(NCPERM_LanChangeProperties));
}
}
else
{
::EnableWindow(h.m_hProperty, FALSE);
}
// is this component user removable ?
::EnableWindow(h.m_hRemove,
!(pnid->dwFlags & NCF_NOT_USER_REMOVABLE) &&
FHasPermission(NCPERM_AddRemoveComponents));
}
// set description text
if(h.m_hDescription)
{
::SetWindowText(h.m_hDescription, (PCWSTR)pnid->szwDesc);
}
}
// Set focus to the list (336050)
SetFocus(h.m_hList);
}
}
return;
}
//+---------------------------------------------------------------------------
//
// Function: HrLvRemove
//
// Purpose: Handles the pressing of the Remove button. Should be called
// in responsed to the PSB_Remove message.
//
// Arguments:
// hwndLV [in] Handle of listview
// hwndParent [in] Handle of parent window
// pnc [in] INetCfg being used
// pnccAdapter [in] INetCfgComponent of adapter for the connection
//
// Returns: S_OK if success, Win32 or OLE error code otherwise
//
// Author: danielwe 3 Nov 1997
//
// Notes:
//
HRESULT HrLvRemove(HWND hwndLV, HWND hwndParent,
INetCfg *pnc, INetCfgComponent *pnccAdapter,
ListBPObj * plistBindingPaths)
{
HRESULT hr = S_OK;
INetCfgComponent * pncc;
hr = HrLvGetSelectedComponent(hwndLV, &pncc);
if (S_OK == hr)
{
hr = HrQueryUserAndRemoveComponent(hwndParent, pnc, pncc);
if (NETCFG_S_STILL_REFERENCED == hr)
{
hr = S_OK;
}
else
{
if (SUCCEEDED(hr))
{
HRESULT hrTmp = HrRefreshAll(hwndLV, pnc, pnccAdapter, plistBindingPaths);
if (S_OK != hrTmp)
hr = hrTmp;
}
}
ReleaseObj(pncc);
}
else
{
TraceTag(ttidLanUi, "HrLvGetSelectedComponent did not get a valid selection.");
}
TraceError("HrLvRemove", hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: HrLvAdd
//
// Purpose: Handles the pressing of the Add button. Should be called in
// response to the PSB_Add message.
//
// Arguments:
// hwndLV [in] Handle of listview
// hwndParent [in] Handle of parent window
// pnc [in] INetCfg being used
// pnccAdapter [in] INetCfgComponent of adapter for the connection
//
// Returns: S_OK if success, Win32 or OLE error code otherwise
//
// Author: danielwe 3 Nov 1997
//
// Notes:
//
HRESULT HrLvAdd(HWND hwndLV, HWND hwndParent, INetCfg *pnc,
INetCfgComponent *pnccAdapter,
ListBPObj * plistBindingPaths)
{
HRESULT hr;
CI_FILTER_INFO cfi;
ZeroMemory(&cfi, sizeof(cfi));
if (!pnccAdapter)
{
return E_INVALIDARG;
}
// We want to filter out any irrelvant protocols (i.e. protocols that
// won't bind to this adapter) so we need to send in a filter info
// struct with our information.
cfi.eFilter = FC_LAN; // Apply lan specific filtering
cfi.pIComp = pnccAdapter; // Filter against this adapter
INetCfgComponentBindings* pnccb;
hr = pnccAdapter->QueryInterface(IID_INetCfgComponentBindings,
reinterpret_cast<LPVOID *>(&pnccb));
if (SUCCEEDED(hr))
{
hr = pnccb->SupportsBindingInterface(NCF_UPPER, c_szBiNdisAtm);
if (S_OK == hr)
{
cfi.eFilter = FC_ATM; // Apply lan specific filtering
}
ReleaseObj(pnccb);
}
hr = HrDisplayAddComponentDialog(hwndParent, pnc, &cfi);
if ((S_OK == hr) || (NETCFG_S_REBOOT == hr))
{
HRESULT hrSave = hr;
// Refresh the list to reflect changes
hr = HrRefreshAll(hwndLV, pnc, pnccAdapter, plistBindingPaths);
if (SUCCEEDED(hr))
hr = hrSave;
}
else if (NETCFG_E_ACTIVE_RAS_CONNECTIONS == hr)
{
LvReportError(IDS_LANUI_REQUIRE_DISCONNECT_ADD, hwndParent, NULL, NULL);
}
else if (NETCFG_E_NEED_REBOOT == hr)
{
LvReportError(IDS_LANUI_REQUIRE_REBOOT_ADD, hwndParent, NULL, NULL);
}
else if (S_FALSE != hr)
{
PWSTR psz = NULL;
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
hr,
LANG_NEUTRAL,
(PWSTR)&psz,
0,
NULL))
{
LvReportError(IDS_LANUI_GENERIC_ADD_ERROR, hwndParent, NULL, psz);
GlobalFree(psz);
}
else
{
LvReportErrorHr(hr, IDS_LANUI_GENERIC_ADD_ERROR, hwndParent, NULL);
}
}
TraceError("HrLvAdd", hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: LvReportError
//
// Purpose: Reports a generic error based on the information passed in
//
// Arguments:
// ids [in] IDS of the string to be used as the text of the
// message box
// hwnd [in] Parent HWND
// szDesc [in] Display name of component
// szText [in] [Optional] If supplied, provides additional string
// for replacement. Can be NULL.
//
// Returns: Nothing
//
// Author: danielwe 6 Jan 1998
//
// Notes:
//
VOID LvReportError(INT ids, HWND hwnd, PCWSTR szDesc, PCWSTR szText)
{
if (szDesc && szText)
{
NcMsgBox(_Module.GetResourceInstance(), hwnd,
IDS_LANUI_ERROR_CAPTION, ids,
MB_ICONSTOP | MB_OK, szDesc, szText);
}
else if (szDesc)
{
NcMsgBox(_Module.GetResourceInstance(), hwnd,
IDS_LANUI_ERROR_CAPTION, ids,
MB_ICONSTOP | MB_OK, szDesc);
}
else if (szText)
{
NcMsgBox(_Module.GetResourceInstance(), hwnd,
IDS_LANUI_ERROR_CAPTION, ids,
MB_ICONSTOP | MB_OK, szText);
}
else
{
NcMsgBox(_Module.GetResourceInstance(), hwnd,
IDS_LANUI_ERROR_CAPTION, ids,
MB_ICONSTOP | MB_OK);
}
}
//+---------------------------------------------------------------------------
//
// Function: LvReportErrorHr
//
// Purpose: Reports a generic error based on the information passed in
//
// Arguments:
// hr [in] HRESULT error value to use in reporting the error
// ids [in] IDS of the string to be used as the text of the
// message box
// hwnd [in] Parent HWND
// szDesc [in] Display name of component
//
// Returns: Nothing
//
// Author: danielwe 14 Nov 1997
//
// Notes:
//
VOID LvReportErrorHr(HRESULT hr, INT ids, HWND hwnd, PCWSTR szDesc)
{
WCHAR szText[32];
static const WCHAR c_szFmt[] = L"0x%08X";
wsprintfW(szText, c_szFmt, hr);
LvReportError(ids, hwnd, szDesc, szText);
}
//+---------------------------------------------------------------------------
//
// Function: HrLvProperties
//
// Purpose: Handles the pressing of the Add button. Should be called in
// response to the PSB_Properties message.
//
// Arguments:
// hwndLV [in] Handle of listview
// hwndParent [in] Handle of parent window
// pnc [in] INetCfg being used
// punk [in] IUnknown for interface to query context information
// bChanged [out] Boolean indicating if something changed.
//
// Returns: S_OK if success, Win32 or OLE error code otherwise
//
// Author: danielwe 3 Nov 1997
//
// Notes:
//
HRESULT HrLvProperties(HWND hwndLV, HWND hwndParent, INetCfg *pnc,
IUnknown *punk, INetCfgComponent *pnccAdapter,
ListBPObj * plistBindingPaths,
BOOL *bChanged)
{
HRESULT hr = S_OK;
INetCfgComponent * pncc;
if ( bChanged )
{
*bChanged = FALSE;
}
hr = HrLvGetSelectedComponent(hwndLV, &pncc);
if (S_OK == hr)
{
AssertSz(pncc, "No component selected?!?!");
hr = pncc->RaisePropertyUi(hwndParent, NCRP_SHOW_PROPERTY_UI, punk);
// if components have been added or removed, we may need
// to refresh the whole list
if (S_OK == hr)
{
TraceTag(ttidLanUi, "Refreshing component list needed because other components are added or removed.");
hr = HrRefreshAll(hwndLV, pnc, pnccAdapter, plistBindingPaths);
if ( bChanged )
{
*bChanged = TRUE;
}
}
ReleaseObj(pncc);
}
else
{
TraceTag(ttidLanUi, "HrLvGetSelectedComponent did not return a valid selection.");
}
if (SUCCEEDED(hr))
{
// Normalize error result
hr = S_OK;
}
TraceError("HrLvProperties", hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: HrRefreshAll
//
// Purpose: Rebuilds the collection of BindingPathObj and the list view
//
// Arguments:
// hwndList [in] Handle of listview
// pnc [in] INetCfg being used
// pnccAdapter [in] INetCfgComponent of the adapter in this connection
// plistBindingPaths [in/out] The collection of BindingPathObj
//
// Returns: S_OK if success, Win32 or OLE error code otherwise
//
// Author: tongl 23 Nov 1997
//
// Notes:
//
HRESULT HrRefreshAll(HWND hwndList,
INetCfg* pnc,
INetCfgComponent * pnccAdapter,
ListBPObj * plistBindingPaths)
{
HRESULT hr = S_OK;
ReleaseAll(hwndList, plistBindingPaths);
hr = HrRebuildBindingPathObjCollection( pnccAdapter,
plistBindingPaths);
if SUCCEEDED(hr)
{
// Set the correct state on the BindingPathObject list
hr = HrRefreshBindingPathObjCollectionState(plistBindingPaths);
if SUCCEEDED(hr)
{
// Now refresh the list to reflect changes
hr = HrRefreshListView(hwndList, pnc, pnccAdapter, plistBindingPaths);
}
}
// $REVIEW(tongl 12\16\97): added so we always have a selection.
// Caller of this function can reset selection if they need to.
if (SUCCEEDED(hr))
{
// Selete the first item
ListView_SetItemState(hwndList, 0, LVIS_SELECTED, LVIS_SELECTED);
}
TraceError("HrRefreshAll", hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: ReleaseAll
//
// Purpose: Releases the INetCfgComponent and INetCfgBindingPath objects
//
// Arguments:
// hwndList [in] Handle of listview
// plistBindingPaths [in/out] The collection of BindingPathObj
//
// Author: tongl 18 Mar, 1998
//
// Notes:
//
VOID ReleaseAll(HWND hwndList,
ListBPObj * plistBindingPaths)
{
// first, clean up any existing objects in the list
FreeCollectionAndItem(*plistBindingPaths);
// delete existing items in the list view
ListView_DeleteAllItems( hwndList );
}
//+---------------------------------------------------------------------------
//
// Function: FValidatePageContents
//
// Purpose: Check error conditions before LAN property or wizard page
// exits
//
// Arguments:
// hwndDlg [in] Handle of dialog
// hwndList [in] Handle of the list view
// pnc [in] INetCfg
// pnccAdapter [in] INetCfgComponent
// plistBindignPaths [in] List of binding paths to this adater
//
// Returns: TRUE if there is a possible error and user wants to fix
// it before leaving the page. FALSE if no error or user
// chooses to move on.
//
// Author: tongl 17 Sept 1998
//
// Notes:
//
BOOL FValidatePageContents( HWND hwndDlg,
HWND hwndList,
INetCfg * pnc,
INetCfgComponent * pnccAdapter,
ListBPObj * plistBindingPaths)
{
HRESULT hr = S_OK;
// 1) Check if any protocol is enabled on this adapter
BOOL fEnabledProtocolExists = FALSE;
CIterNetCfgComponent iterProt(pnc, &GUID_DEVCLASS_NETTRANS);
INetCfgComponent* pnccTrans;
while (SUCCEEDED(hr) && !fEnabledProtocolExists &&
S_OK == (hr = iterProt.HrNext(&pnccTrans)))
{
HRESULT hrTmp;
INetCfgComponentBindings * pnccb;
hrTmp = pnccTrans->QueryInterface (
IID_INetCfgComponentBindings, (LPVOID*)&pnccb);
if (S_OK == hrTmp)
{
hrTmp = pnccb->IsBindableTo(pnccAdapter);
if (S_OK == hrTmp)
{
fEnabledProtocolExists = TRUE;
}
ReleaseObj(pnccb);
}
ReleaseObj(pnccTrans);
}
if (!fEnabledProtocolExists)
{
// warn the user
int nRet = NcMsgBox(
_Module.GetResourceInstance(),
hwndDlg,
IDS_LANUI_NOPROTOCOL_CAPTION,
IDS_LANUI_NOPROTOCOL,
MB_APPLMODAL|MB_ICONINFORMATION|MB_YESNO
);
if (nRet == IDYES)
{
return TRUE;
}
}
// 2) Check if any component on the display list is in an intent check state
// If so, it means these components are actually disabled and will not be
// displayed as checked the next time the UI is refreshed.
tstring strCompList = c_szEmpty;
// for each item in the list view
int nlvCount = ListView_GetItemCount(hwndList);
LV_ITEM lvItem;
for (int i=0; i< nlvCount; i++)
{
lvItem.iItem = i;
lvItem.iSubItem = 0;
lvItem.mask = LVIF_PARAM;
if (ListView_GetItem(hwndList, &lvItem))
{
NET_ITEM_DATA * pnid;
pnid = reinterpret_cast<NET_ITEM_DATA *>(lvItem.lParam);
if (pnid)
{
// get the component object associated with this item
CComponentObj * pCompObj = pnid->pCompObj;
if (pCompObj)
{
if (INTENT_CHECKED == pCompObj->m_CheckState)
{
PWSTR pszwName;
hr = pCompObj->m_pncc->GetDisplayName(&pszwName);
if (SUCCEEDED(hr))
{
if (!strCompList.empty())
strCompList += SzLoadIds(IDS_NEWLINE);
strCompList += pszwName;
delete pszwName;
}
}
}
}
}
}
if (!strCompList.empty())
{
// warn the user
int nRet = NcMsgBox(
_Module.GetResourceInstance(),
hwndDlg,
IDS_LANUI_ERROR_CAPTION,
IDS_LANUI_INTENTCHECK,
MB_APPLMODAL|MB_ICONINFORMATION|MB_YESNO,
strCompList.c_str());
if (nRet == IDNO)
{
hr = HrRefreshAll(hwndList, pnc, pnccAdapter, plistBindingPaths);
return TRUE;
}
}
return FALSE;
}
//+---------------------------------------------------------------------------
//
// EAPOL related util functions
//
//+---------------------------------------------------------------------------
// Location of EAPOL Parameters Service
static WCHAR cszEapKeyEapolServiceParams[] = L"Software\\Microsoft\\EAPOL\\Parameters\\General" ;
static WCHAR cszInterfaceList[] = L"InterfaceList";
//+---------------------------------------------------------------------------
//
// Function called to retrieve the connection data for an interface for a
// specific EAP type and SSID (if any). Data is stored in the HKLM hive
//
// Input arguments:
// pwszGUID - GUID string for the interface
// dwEapTypeId - EAP type for which connection data is to be stored
// dwSizeOfSSID - Size of Special identifier if any for the EAP blob
// pwszSSID - Special identifier if any for the EAP blob
//
// Return values:
// pbConnInfo - pointer to binary EAP connection data blob
// dwInfoSize - pointer to size of EAP connection blob
//
//
HRESULT
HrElGetCustomAuthData (
IN WCHAR *pwszGUID,
IN DWORD dwEapTypeId,
IN DWORD dwSizeOfSSID,
IN BYTE *pbSSID,
IN OUT BYTE *pbConnInfo,
IN OUT DWORD *pdwInfoSize
)
{
DWORD dwRetCode = ERROR_SUCCESS;
HRESULT hr = S_OK;
do
{
dwRetCode = WZCEapolGetCustomAuthData (
NULL,
pwszGUID,
dwEapTypeId,
dwSizeOfSSID,
pbSSID,
pbConnInfo,
pdwInfoSize
);
if (dwRetCode == ERROR_BUFFER_TOO_SMALL)
{
hr = E_OUTOFMEMORY;
dwRetCode = ERROR_SUCCESS;
}
} while (FALSE);
if (dwRetCode != ERROR_SUCCESS)
{
hr = HRESULT_FROM_WIN32(dwRetCode);
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Function called to set the connection data for an interface for a specific
// EAP type and SSID (if any). Data will be stored in the HKLM hive
//
// Input arguments:
// pwszGUID - pinter to GUID string for the interface
// dwEapTypeId - EAP type for which connection data is to be stored
// dwSizeOfSSID - Size of Special identifier if any for the EAP blob
// pwszSSID - Special identifier if any for the EAP blob
// pbConnInfo - pointer to binary EAP connection data blob
// dwInfoSize - Size of EAP connection blob
//
// Return values:
//
HRESULT
HrElSetCustomAuthData (
IN WCHAR *pwszGUID,
IN DWORD dwEapTypeId,
IN DWORD dwSizeOfSSID,
IN BYTE *pbSSID,
IN PBYTE pbConnInfo,
IN DWORD dwInfoSize
)
{
DWORD dwRetCode = ERROR_SUCCESS;
HRESULT hr = S_OK;
do
{
dwRetCode = WZCEapolSetCustomAuthData (
NULL,
pwszGUID,
dwEapTypeId,
dwSizeOfSSID,
pbSSID,
pbConnInfo,
dwInfoSize
);
} while (FALSE);
if (dwRetCode != ERROR_SUCCESS)
{
hr = HRESULT_FROM_WIN32(dwRetCode);
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Function called to retrieve the EAPOL parameters for an interface
//
// Input arguments:
// pwszGUID - GUID string for the interface
//
// Return values:
// pdwDefaultEAPType - default EAP type for interface
// pIntfParams - Interface parameters
//
HRESULT
HrElGetInterfaceParams (
IN WCHAR *pwszGUID,
IN OUT EAPOL_INTF_PARAMS *pIntfParams
)
{
DWORD dwRetCode = ERROR_SUCCESS;
HRESULT hr = S_OK;
do
{
dwRetCode = WZCEapolGetInterfaceParams (
NULL,
pwszGUID,
pIntfParams
);
} while (FALSE);
if (dwRetCode != ERROR_SUCCESS)
{
hr = HRESULT_FROM_WIN32(dwRetCode);
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Function called to set the EAPOL parameters for an interface
//
// Input arguments:
// pwszGUID - GUID string for the interface
// pIntfParams - Interface parameters
//
// Return values:
//
HRESULT
HrElSetInterfaceParams (
IN WCHAR *pwszGUID,
IN EAPOL_INTF_PARAMS *pIntfParams
)
{
DWORD dwRetCode = ERROR_SUCCESS;
HRESULT hr = S_OK;
do
{
dwRetCode = WZCEapolSetInterfaceParams (
NULL,
pwszGUID,
pIntfParams
);
} while (FALSE);
if (dwRetCode != ERROR_SUCCESS)
{
hr = HRESULT_FROM_WIN32(dwRetCode);
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Set selection in listbox 'hwndLb' to 'nIndex' and notify parent as if
// user had clicked the item which Windows doesn't do for some reason.
//
VOID
ComboBox_SetCurSelNotify (
IN HWND hwndLb,
IN INT nIndex
)
{
ComboBox_SetCurSel( hwndLb, nIndex );
SendMessage(
GetParent( hwndLb ),
WM_COMMAND,
(WPARAM )MAKELONG(
(WORD )GetDlgCtrlID( hwndLb ), (WORD )CBN_SELCHANGE ),
(LPARAM )hwndLb );
}
//+---------------------------------------------------------------------------
//
// Set the width of the drop-down list 'hwndLb' to the width of the
// longest item (or the width of the list box if that's wider).
//
VOID
ComboBox_AutoSizeDroppedWidth (
IN HWND hwndLb
)
{
HDC hdc;
HFONT hfont;
TCHAR* psz;
SIZE size;
DWORD cch;
DWORD dxNew;
DWORD i;
hfont = (HFONT )SendMessage( hwndLb, WM_GETFONT, 0, 0 );
if (!hfont)
return;
hdc = GetDC( hwndLb );
if (!hdc)
return;
SelectObject( hdc, hfont );
dxNew = 0;
for (i = 0; psz = ComboBox_GetPsz( hwndLb, i ); ++i)
{
cch = lstrlen( psz );
if (GetTextExtentPoint32( hdc, psz, cch, &size ))
{
if (dxNew < (DWORD )size.cx)
dxNew = (DWORD )size.cx;
}
free ( psz );
}
ReleaseDC( hwndLb, hdc );
// Allow for the spacing on left and right added by the control.
dxNew += 6;
// Figure out if the vertical scrollbar will be displayed and, if so,
// allow for it's width.
{
RECT rectD;
RECT rectU;
DWORD dyItem;
DWORD cItemsInDrop;
DWORD cItemsInList;
GetWindowRect( hwndLb, &rectU );
SendMessage( hwndLb, CB_GETDROPPEDCONTROLRECT, 0, (LPARAM )&rectD );
dyItem = (DWORD)SendMessage( hwndLb, CB_GETITEMHEIGHT, 0, 0 );
cItemsInDrop = (rectD.bottom - rectU.bottom) / dyItem;
cItemsInList = ComboBox_GetCount( hwndLb );
if (cItemsInDrop < cItemsInList)
dxNew += GetSystemMetrics( SM_CXVSCROLL );
}
SendMessage( hwndLb, CB_SETDROPPEDWIDTH, dxNew, 0 );
}
//+---------------------------------------------------------------------------
//
// Adds data item 'pItem' with displayed text 'pszText' to listbox
// 'hwndLb'. The item is added sorted if the listbox has LBS_SORT style,
// or to the end of the list otherwise. If the listbox has LB_HASSTRINGS
// style, 'pItem' is a null terminated string, otherwise it is any user
// defined data.
//
// Returns the index of the item in the list or negative if error.
//
INT
ComboBox_AddItem(
IN HWND hwndLb,
IN LPCTSTR pszText,
IN VOID* pItem
)
{
INT nIndex;
nIndex = ComboBox_AddString( hwndLb, pszText );
if (nIndex >= 0)
ComboBox_SetItemData( hwndLb, nIndex, pItem );
return nIndex;
}
//+---------------------------------------------------------------------------
//
// Returns the address of the 'nIndex'th item context in 'hwndLb' or NULL
// if none.
//
VOID*
ComboBox_GetItemDataPtr (
IN HWND hwndLb,
IN INT nIndex
)
{
LRESULT lResult;
if (nIndex < 0)
return NULL;
lResult = ComboBox_GetItemData( hwndLb, nIndex );
if (lResult < 0)
return NULL;
return (VOID* )lResult;
}
//+---------------------------------------------------------------------------
//
// Returns heap block containing the text contents of the 'nIndex'th item
// of combo box 'hwnd' or NULL. It is caller's responsibility to Free the
// returned string.
//
TCHAR*
ComboBox_GetPsz (
IN HWND hwnd,
IN INT nIndex
)
{
INT cch;
TCHAR* psz;
cch = ComboBox_GetLBTextLen( hwnd, nIndex );
if (cch < 0)
return NULL;
psz = new TCHAR[( cch + 1)];
if (psz)
{
*psz = TEXT('\0');
ComboBox_GetLBText( hwnd, nIndex, psz );
}
return psz;
}
static WCHAR WZCSVC_SERVICE_NAME[] = L"WZCSVC";
//+---------------------------------------------------------------------------
//
// ElCanEapolRunOnInterface:
//
// Function to verify if EAPOL can ever be started on an interface
//
// Returns TRUE if:
// WZCSVC service is running and WZCSVC has bound to the interface
//
//
BOOL
ElCanEapolRunOnInterface (
IN INetConnection *pconn
)
{
SC_HANDLE hServiceCM = NULL;
SC_HANDLE hWZCSVCService = NULL;
SERVICE_STATUS WZCSVCServiceStatus;
WCHAR wszGuid[c_cchGuidWithTerm];
NETCON_PROPERTIES* pProps = NULL;
BOOL fIsOK = TRUE;
DWORD dwType = 0;
DWORD dwSizeOfList = 0;
WCHAR *pwszRegInterfaceList = NULL;
DWORD dwDisposition = 0;
HKEY hkey = NULL;
EAPOL_INTF_PARAMS EapolIntfParams;
LONG lError = ERROR_SUCCESS;
DWORD dwRetCode = NO_ERROR;
HRESULT hr = S_OK;
do
{
//
// Query status of WZCSVC service
// Do not display tab if WZCSVC service is not running
//
if ((hServiceCM = OpenSCManager ( NULL, NULL, GENERIC_READ ))
== NULL)
{
dwRetCode = GetLastError ();
TraceTag (ttidLanUi, "ElCanEapolRunOnInterface: OpenSCManager failed with error %ld",
dwRetCode);
fIsOK = FALSE;
break;
}
if ((hWZCSVCService =
OpenService ( hServiceCM, WZCSVC_SERVICE_NAME, GENERIC_READ ))
== NULL)
{
dwRetCode = GetLastError ();
TraceTag (ttidLanUi, "ElCanEapolRunOnInterface: OpenService failed with error %ld",
dwRetCode);
fIsOK = FALSE;
break;
}
if (!QueryServiceStatus ( hWZCSVCService, &WZCSVCServiceStatus ))
{
dwRetCode = GetLastError ();
TraceTag (ttidLanUi, "ElCanEapolRunOnInterface: StartService failed with error %ld",
dwRetCode);
fIsOK = FALSE;
break;
}
if ( WZCSVCServiceStatus.dwCurrentState != SERVICE_RUNNING )
{
TraceTag (ttidLanUi, "ElCanEapolRunOnInterface: WZCSVC service not running !!!");
fIsOK = FALSE;
break;
}
TraceTag (ttidLanUi, "ElCanEapolRunOnInterface: WZCSVC service is indeed running !!!");
if (!CloseServiceHandle ( hWZCSVCService ))
{
dwRetCode = GetLastError ();
TraceTag (ttidLanUi, "ElCanEapolRunOnInterface: CloseService failed with error %ld",
dwRetCode);
fIsOK = FALSE;
break;
}
hWZCSVCService = NULL;
if (!CloseServiceHandle ( hServiceCM ))
{
dwRetCode = GetLastError ();
TraceTag (ttidLanUi, "ElCanEapolRunOnInterface: CloseService failed with error %ld",
dwRetCode);
fIsOK = FALSE;
break;
}
hServiceCM = NULL;
//
// Check if NDISUIO is bound to interface
//
hr = pconn->GetProperties (&pProps);
if (SUCCEEDED(hr))
{
if (::StringFromGUID2 (pProps->guidId, wszGuid, c_cchGuidWithTerm)
== 0)
{
TraceTag (ttidLanUi, "ElCanEapolRunOnInterface: StringFromGUID2 failed");
fIsOK = FALSE;
FreeNetconProperties(pProps);
break;
}
FreeNetconProperties(pProps);
}
else
{
break;
}
// Fetch InterfaceList from registry
// Search for GUID string in registry
// Get handle to
// HKLM\Software\Microsoft\EAPOL\Parameters\Interfaces\General
hr = HrRegCreateKeyEx (
HKEY_LOCAL_MACHINE,
cszEapKeyEapolServiceParams,
REG_OPTION_NON_VOLATILE,
KEY_READ,
NULL,
&hkey,
&dwDisposition);
if (!SUCCEEDED (hr))
{
TraceTag (ttidLanUi, "ElCanEapolRunOnInterface: Error in HrRegCreateKeyEx for base key, %ld",
LresFromHr(hr));
fIsOK = FALSE;
break;
}
// Query the value of
// ...\EAPOL\Parameters\Interfaces\General\InterfaceList key
dwSizeOfList = 0;
hr = HrRegQueryValueEx (
hkey,
cszInterfaceList,
&dwType,
NULL,
&dwSizeOfList);
if (SUCCEEDED (hr))
{
pwszRegInterfaceList = (WCHAR *) new BYTE [dwSizeOfList];
if (pwszRegInterfaceList == NULL)
{
hr = E_OUTOFMEMORY;
fIsOK = FALSE;
break;
}
hr = HrRegQueryValueEx (
hkey,
cszInterfaceList,
&dwType,
(LPBYTE)pwszRegInterfaceList,
&dwSizeOfList);
if (!SUCCEEDED(hr))
{
TraceTag (ttidLanUi, "ElCanEapolRunOnInterface: Error in HrRegQueryValueEx acquiring value for InterfaceList, %ld",
LresFromHr(hr));
break;
}
TraceTag (ttidLanUi, "ElCanEapolRunOnInterface: Query value succeeded = %ws, size=%ld, search GUID = %ws",
pwszRegInterfaceList, dwSizeOfList, wszGuid);
}
else
{
TraceTag (ttidLanUi, "ElCanEapolRunOnInterface: Error in HrRegQueryValueEx size estimation for InterfaceList, %ld",
LresFromHr(hr));
fIsOK = FALSE;
break;
}
if (wcsstr (pwszRegInterfaceList, wszGuid))
{
TraceTag (ttidLanUi, "ElCanEapolRunOnInterface interface found in interface list !!!");
}
else
{
TraceTag (ttidLanUi, "ElCanEapolRunOnInterface interface *not* found in interface list !!!");
fIsOK = FALSE;
break;
}
} while (FALSE);
if (hkey != NULL)
{
RegSafeCloseKey (hkey);
}
if (pwszRegInterfaceList != NULL)
{
free (pwszRegInterfaceList);
}
if (hWZCSVCService != NULL)
{
if (!CloseServiceHandle ( hWZCSVCService ))
{
dwRetCode = GetLastError ();
TraceTag (ttidLanUi, "ElCanEapolRunOnInterface: CloseService failed with error %ld",
dwRetCode);
}
}
if (hServiceCM != NULL)
{
if (!CloseServiceHandle ( hServiceCM ))
{
dwRetCode = GetLastError ();
TraceTag (ttidLanUi, "ElCanEapolRunOnInterface: CloseService failed with error %ld",
dwRetCode);
}
}
return fIsOK;
}
#ifdef ENABLETRACE
//+---------------------------------------------------------------------------
//
// Function: PrintBindingPath
//
// Purpose: Prints the binding path ID and a list of component IDs on
// the path from top down
//
// Arguments:
//
// Returns:
//
// Author: tongl 26 Nov 1997
//
// Notes:
//
VOID PrintBindingPath (
TRACETAGID ttidToTrace,
INetCfgBindingPath* pncbp,
PCSTR pszaExtraText)
{
Assert (pncbp);
if (!pszaExtraText)
{
pszaExtraText = "";
}
const WCHAR c_szSept[] = L"->";
tstring strPath;
INetCfgComponent * pnccNetComponent;
PWSTR pszwCompId;
HRESULT hr;
// Get the top component
hr = pncbp->GetOwner(&pnccNetComponent);
if (SUCCEEDED(hr))
{
hr = pnccNetComponent->GetId(&pszwCompId);
if SUCCEEDED(hr)
{
strPath += pszwCompId;
CoTaskMemFree(pszwCompId);
}
}
ReleaseObj(pnccNetComponent);
// Get Comp ID for other component on the path
CIterNetCfgBindingInterface ncbiIter(pncbp);
INetCfgBindingInterface * pncbi;
//Go through interfaces of the binding path
while (SUCCEEDED(hr) && (hr = ncbiIter.HrNext(&pncbi)) == S_OK)
{
strPath += c_szSept;
// Get the lower component
hr = pncbi->GetLowerComponent(&pnccNetComponent);
if(SUCCEEDED(hr))
{
hr = pnccNetComponent->GetId(&pszwCompId);
if (SUCCEEDED(hr))
{
strPath += pszwCompId;
CoTaskMemFree(pszwCompId);
}
}
ReleaseObj(pnccNetComponent);
ReleaseObj(pncbi);
}
if (hr == S_FALSE) // We just got to the end of the loop
hr = S_OK;
BOOL fEnabled = (S_OK == pncbp->IsEnabled());
// Now print the path and ID
char szaBuf[1024];
wsprintfA (szaBuf, "[%s] %S: %s",
(fEnabled) ? "x" : " ",
strPath.c_str(),
pszaExtraText);
TraceTag (ttidToTrace, szaBuf);
TraceError ("PrintBindingPath", hr);
}
#endif //ENABLETRACE