You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3242 lines
105 KiB
3242 lines
105 KiB
#include "pch.h"
|
|
#pragma hdrstop
|
|
|
|
#include <shellapi.h>
|
|
#include <rasdlg.h>
|
|
#include "sautil.h"
|
|
#include "resource.h"
|
|
#include "beacon.h"
|
|
#include "htmlhelp.h"
|
|
#include "lm.h"
|
|
#include <shlobj.h>
|
|
|
|
// global(s)
|
|
HINSTANCE g_hinstDll;
|
|
LPCTSTR g_contextId = NULL;
|
|
|
|
|
|
// external(s)
|
|
extern "C" {
|
|
extern BOOL WINAPI LinkWindow_RegisterClass();
|
|
}
|
|
|
|
// static(s)
|
|
static DWORD g_adwSaHelp[] =
|
|
{
|
|
CID_SA_PB_Shared, HID_SA_PB_Shared,
|
|
CID_SA_GB_Shared, -1,
|
|
CID_SA_PB_DemandDial, HID_SA_PB_DemandDial,
|
|
CID_SA_PB_Settings, HID_SA_PB_Settings,
|
|
CID_SA_GB_PrivateLan, -1,
|
|
// CID_SA_ST_PrivateLan, HID_SA_LB_PrivateLan,
|
|
CID_SA_LB_PrivateLan, HID_SA_LB_PrivateLan,
|
|
CID_FW_PB_Firewalled, HID_FW_PB_Firewalled,
|
|
CID_SA_ST_ICFLink, HID_SA_ST_ICFLink,
|
|
CID_SA_EB_PrivateLan, HID_SA_EB_PrivateLan,
|
|
CID_SA_PB_Beacon, HID_SA_PB_Beacon,
|
|
CID_SA_ST_ICSLink, HID_SA_ST_ICSLink,
|
|
CID_SA_ST_HNWLink, HID_SA_ST_HNWLink,
|
|
0, 0
|
|
};
|
|
static TCHAR g_pszFirewallRegKey[] = TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\HomeNetworking\\PersonalFirewall");
|
|
static TCHAR g_pszDisableFirewallWarningValue[] = TEXT("ShowDisableFirewallWarning");
|
|
|
|
// replacement for (private) PBENTRY
|
|
typedef struct _BILLSPBENTRY
|
|
{
|
|
TCHAR pszPhonebookPath[MAX_PATH];
|
|
TCHAR pszEntryName[RAS_MaxEntryName];
|
|
DWORD dwType;
|
|
GUID guidId; // somewhere for pGuid to point
|
|
GUID* pGuid;
|
|
DWORD dwfExcludedProtocols;
|
|
} BILLSPBENTRY;
|
|
|
|
// Phonebook Entry common block.
|
|
//
|
|
typedef struct _EINFO
|
|
{
|
|
// RAS API arguments.
|
|
//
|
|
TCHAR* pszPhonebook;
|
|
TCHAR* pszEntry;
|
|
// RASENTRYDLG* pApiArgs;
|
|
HWND hwndOwner; // bhanlon: so that EuHomenetCommit error dialogs work.
|
|
|
|
// Set true by property sheet or wizard when changes should be committed
|
|
// before returning from the API. Does not apply in ShellOwned-mode where
|
|
// the API returns before the property sheet is dismissed.
|
|
//
|
|
// BOOL fCommit;
|
|
|
|
// Set if we have been called via RouterEntryDlg.
|
|
//
|
|
BOOL fRouter;
|
|
|
|
// Set if fRouter is TRUE and pszRouter refers to a remote machine.
|
|
//
|
|
// BOOL fRemote;
|
|
|
|
// Set if pszRouter is an NT4 steelhead machine. Valid only
|
|
// if fRouter is true.
|
|
//
|
|
// BOOL fNt4Router;
|
|
|
|
//Set if pszRouter is an Windows 2000 machine, Valid only if
|
|
// fRouter is true
|
|
// BOOL fW2kRouter;
|
|
|
|
// The name of the server in "\\server" form or NULL if none (or if
|
|
// 'fRouter' is not set).
|
|
//
|
|
// TCHAR* pszRouter;
|
|
|
|
// Set by the add entry or add interface wizards if user chooses to end
|
|
// the wizard and go edit the properties directly. When this flag is set
|
|
// the wizard should *not* call EuFree before returning.
|
|
//
|
|
// BOOL fChainPropertySheet;
|
|
|
|
// Phonebook settings read from the phonebook file. All access should be
|
|
// thru 'pFile' as 'file' will only be used in cases where the open
|
|
// phonebook is not passed thru the reserved word hack.
|
|
//
|
|
// PBFILE* pFile;
|
|
// PBFILE file;
|
|
|
|
// Global preferences read via phonebook library. All access should be
|
|
// thru 'pUser' as 'user' will only be used in cases where the preferences
|
|
// are not passed thru the reserved word hack.
|
|
//
|
|
// PBUSER* pUser;
|
|
// PBUSER user;
|
|
|
|
// Set if "no user before logon" mode.
|
|
//
|
|
// BOOL fNoUser;
|
|
|
|
// Set by the add-entry wizard if the selected port is an X.25 PAD.
|
|
//
|
|
// BOOL fPadSelected;
|
|
|
|
// Set if there are multiple devices configured, i.e. if the UI is running
|
|
// in the multiple device mode. This is implicitly false in VPN and
|
|
// Direct modes.
|
|
//
|
|
// BOOL fMultipleDevices;
|
|
|
|
// Link storing the List of PBPHONEs and alternate options for shared
|
|
// phone number mode. This allows user to change the port/device to
|
|
// another link without losing the phone number he typed.
|
|
//
|
|
// DTLNODE* pSharedNode;
|
|
|
|
// The node being edited (still in the list), and the original entry name
|
|
// for use in comparison later. These are valid in "edit" case only.
|
|
//
|
|
// DTLNODE* pOldNode;
|
|
// TCHAR szOldEntryName[ RAS_MaxEntryName + 1 ];
|
|
|
|
// The work entry node containing and a shortcut pointer to the entry
|
|
// inside.
|
|
//
|
|
// DTLNODE* pNode;
|
|
// PBENTRY* pEntry;
|
|
BILLSPBENTRY* pEntry;
|
|
|
|
// The master list of configured ports used by EuChangeEntryType to
|
|
// construct an appropriate sub-list of PBLINKs in the work entry node.
|
|
//
|
|
// DTLLIST* pListPorts;
|
|
|
|
// The "current" device. This value is NULL for multilink entries. It
|
|
// is the device that the entry will use if no change is made. We compare
|
|
// the current device to the device selected from the general tab to know
|
|
// when it is appropriate to update the phonebook's "preferred" device.
|
|
//
|
|
// TCHAR* pszCurDevice;
|
|
// TCHAR* pszCurPort;
|
|
|
|
// Set true if there are no ports of the current entry type configured,
|
|
// not including any bogus "uninstalled" ports added to the link list so
|
|
// the rest of the code can assume there is at least one link.
|
|
//
|
|
// BOOL fNoPortsConfigured;
|
|
|
|
// Dial-out user info for router; used by AiWizard. Used to set interface
|
|
// credentials via MprAdminInterfaceSetCredentials.
|
|
//
|
|
// TCHAR* pszRouterUserName;
|
|
// TCHAR* pszRouterDomain;
|
|
// TCHAR* pszRouterPassword;
|
|
|
|
// Dial-in user info for router (optional); used by AiWizard. Used to
|
|
// create dial-in user account via NetUserAdd; the user name for the
|
|
// account is the interface (phonebook entry) name.
|
|
//
|
|
// BOOL fAddUser;
|
|
// TCHAR* pszRouterDialInPassword;
|
|
|
|
// Home networking settings for the entry.
|
|
//
|
|
BOOL fComInitialized;
|
|
IHNetConnection *pHNetConn;
|
|
IHNetCfgMgr *pHNetCfgMgr;
|
|
BOOL fShowHNetPages;
|
|
HRESULT hShowHNetPagesResult;
|
|
|
|
// ICS settings for the entry
|
|
//
|
|
IHNetIcsSettings *pIcsSettings;
|
|
BOOL fOtherShared;
|
|
BOOL fShared;
|
|
BOOL fNewShared;
|
|
BOOL fDemandDial;
|
|
BOOL fNewDemandDial;
|
|
BOOL fNewBeaconControl;
|
|
BOOL fResetPrivateAdapter;
|
|
IHNetConnection *pPrivateLanConnection;
|
|
IHNetConnection **rgPrivateConns;
|
|
IHNetIcsPublicConnection *pOldSharedConnection;
|
|
DWORD dwLanCount;
|
|
LONG lxCurrentPrivate;
|
|
|
|
// Firewall settings for the entry
|
|
//
|
|
BOOL fFirewalled;
|
|
BOOL fNewFirewalled;
|
|
|
|
// AboladeG - security level of the current user.
|
|
// Set true if the user is an administrator/power user.
|
|
// This is required by several pages, both in the wizard
|
|
// and in the property sheet.
|
|
//
|
|
BOOL fIsUserAdminOrPowerUser;
|
|
|
|
// Set if strong encryption is supported by NDISWAN, as determined in
|
|
// EuInit.
|
|
//
|
|
BOOL fStrongEncryption;
|
|
|
|
// Set whent the VPN "first connect" controls should be read-only, e.g. in
|
|
// the dialer's Properties button is pressed in the middle of a double
|
|
// dial.
|
|
//
|
|
// BOOL fDisableFirstConnect;
|
|
|
|
//Used in the IPSec Policy in the Security tab for a VPN connection
|
|
//
|
|
// BOOL fPSKCached;
|
|
// TCHAR szPSK[PWLEN + 1];
|
|
|
|
|
|
// Flags to track whether to save the default Internet connection
|
|
//
|
|
// BOOL fDefInternetPersonal;
|
|
// BOOL fDefInternetGlobal;
|
|
|
|
// Default credentials
|
|
//
|
|
// TCHAR* pszDefUserName;
|
|
// TCHAR* pszDefPassword;
|
|
}
|
|
EINFO;
|
|
|
|
// Phonebook Entry property sheet context block. All property pages refer to
|
|
// the single context block is associated with the sheet.
|
|
//
|
|
typedef struct
|
|
_PEINFO
|
|
{
|
|
// Common input arguments.
|
|
//
|
|
EINFO* pArgs;
|
|
|
|
// Property sheet dialog and property page handles. 'hwndFirstPage' is
|
|
// the handle of the first property page initialized. This is the page
|
|
// that allocates and frees the context block.
|
|
//
|
|
// Note the "Network" page is missing. This "NCPA" page, developed
|
|
// separately by ShaunCo, does not use this shared area for page specfic
|
|
// controls, instead returning users selections via the "penettab.h"
|
|
// interface.
|
|
//
|
|
HWND hwndDlg;
|
|
// HWND hwndFirstPage;
|
|
// HWND hwndGe;
|
|
// HWND hwndOe;
|
|
// HWND hwndLo;
|
|
HWND hwndSa;
|
|
// HWND hwndFw;
|
|
|
|
// General page.
|
|
//
|
|
// HWND hwndLvDevices;
|
|
// HWND hwndLbDevices;
|
|
// HWND hwndPbUp;
|
|
// HWND hwndPbDown;
|
|
// HWND hwndCbSharedPhoneNumbers;
|
|
// HWND hwndPbConfigureDevice;
|
|
// HWND hwndGbPhoneNumber;
|
|
// HWND hwndStAreaCodes;
|
|
// HWND hwndClbAreaCodes;
|
|
// HWND hwndStCountryCodes;
|
|
// HWND hwndLbCountryCodes;
|
|
// HWND hwndStPhoneNumber;
|
|
// HWND hwndEbPhoneNumber;
|
|
// HWND hwndCbUseDialingRules;
|
|
// HWND hwndPbDialingRules;
|
|
// HWND hwndPbAlternates;
|
|
// HWND hwndCbShowIcon;
|
|
|
|
// HWND hwndEbHostName;
|
|
// HWND hwndCbDialAnotherFirst;
|
|
// HWND hwndLbDialAnotherFirst;
|
|
|
|
// HWND hwndEbBroadbandService;
|
|
|
|
// Options page.
|
|
//
|
|
// HWND hwndCbDisplayProgress;
|
|
// HWND hwndCbPreviewUserPw;
|
|
// HWND hwndCbPreviewDomain;
|
|
// HWND hwndCbPreviewNumber;
|
|
// HWND hwndEbRedialAttempts;
|
|
// HWND hwndLbRedialTimes;
|
|
// HWND hwndLbIdleTimes;
|
|
// HWND hwndCbRedialOnDrop;
|
|
// HWND hwndGbMultipleDevices;
|
|
// HWND hwndLbMultipleDevices;
|
|
// HWND hwndPbConfigureDialing;
|
|
// HWND hwndPbX25;
|
|
// HWND hwndPbTunnel;
|
|
// HWND hwndRbPersistent; // only for fRouter
|
|
// HWND hwndRbDemandDial; // only for fRouter
|
|
|
|
// Security page.
|
|
//
|
|
// HWND hwndGbSecurityOptions;
|
|
// HWND hwndRbTypicalSecurity;
|
|
// HWND hwndStAuths;
|
|
// HWND hwndLbAuths;
|
|
// HWND hwndCbUseWindowsPw;
|
|
// HWND hwndCbEncryption;
|
|
// HWND hwndRbAdvancedSecurity;
|
|
// HWND hwndStAdvancedText;
|
|
// HWND hwndPbAdvanced;
|
|
// HWND hwndPbIPSec; //Only for VPN
|
|
// HWND hwndGbScripting;
|
|
// HWND hwndCbRunScript;
|
|
// HWND hwndCbTerminal;
|
|
// HWND hwndLbScripts;
|
|
// HWND hwndPbEdit;
|
|
// HWND hwndPbBrowse;
|
|
|
|
// Networking page.
|
|
//
|
|
// HWND hwndLbServerType;
|
|
// HWND hwndPbSettings;
|
|
// HWND hwndLvComponents;
|
|
// HWND hwndPbAdd;
|
|
// HWND hwndPbRemove;
|
|
// HWND hwndPbProperties;
|
|
// HWND hwndDescription;
|
|
|
|
// Shared Access page.
|
|
//
|
|
HWND hwndSaPbShared;
|
|
HWND hwndSaGbShared;
|
|
HWND hwndSaGbPrivateLan;
|
|
HWND hwndSaEbPrivateLan;
|
|
HWND hwndSaLbPrivateLan;
|
|
HWND hwndSaSfPrivateLan;
|
|
HWND hwndSaPbDemandDial;
|
|
HWND hwndSaPbFirewalled;
|
|
|
|
// Indicates that the informational popup noting that SLIP does not
|
|
// support any authentication settings should appear the next time the
|
|
// Security page is activated.
|
|
//
|
|
// BOOL fShowSlipPopup;
|
|
|
|
// The "restore" states of the typical security mode listbox and
|
|
// checkboxes. Initialized in LoInit and set whenever the controls are
|
|
// disabled.
|
|
//
|
|
// DWORD iLbAuths;
|
|
// BOOL fUseWindowsPw;
|
|
// BOOL fEncryption;
|
|
|
|
// MoveUp/MoveDown icons, for enabled/disabled cases.
|
|
//
|
|
// HANDLE hiconUpArr;
|
|
// HANDLE hiconDnArr;
|
|
// HANDLE hiconUpArrDis;
|
|
// HANDLE hiconDnArrDis;
|
|
|
|
// The currently displayed link node, i.e. either the node of the selected
|
|
// device or the shared node. This is a shortcut for GeAlternates, that
|
|
// keeps all the lookup code in GeUpdatePhoneNumberFields.
|
|
//
|
|
// DTLNODE* pCurLinkNode;
|
|
|
|
// The currently selected device. Used to store phone number information
|
|
// for the just unselected device when a new device is selected.
|
|
//
|
|
// INT iDeviceSelected;
|
|
|
|
// Complex phone number helper context block, and a flag indicating if the
|
|
// block has been initialized.
|
|
//
|
|
// CUINFO cuinfo;
|
|
// BOOL fCuInfoInitialized;
|
|
|
|
// After dial scripting helper context block, and a flag indicating if the
|
|
// block has been initialized.
|
|
//
|
|
// SUINFO suinfo;
|
|
// BOOL fSuInfoInitialized;
|
|
|
|
// Flags whether the user authorized a reboot after installing or removing
|
|
// and networking component.
|
|
//
|
|
// BOOL fRebootAlreadyRequested;
|
|
|
|
// List of area codes passed CuInit plus all strings retrieved with
|
|
// CuGetInfo. The list is an editing duplicate of the one from the
|
|
// PBUSER.
|
|
//
|
|
// DTLLIST* pListAreaCodes;
|
|
|
|
// Stash/restore values for Options page checkboxes.
|
|
//
|
|
// BOOL fPreviewUserPw;
|
|
// BOOL fPreviewDomain;
|
|
|
|
// Set when user changes to "Typical smartcard" security. This causes the
|
|
// registry based association of EAP per-user information to be discarded,
|
|
// sort of like flushing cached credentials.
|
|
//
|
|
// BOOL fDiscardEapUserData;
|
|
|
|
// Set true on the first click of the Typical or Advanced radio button on
|
|
// the security page, false before. The first click is the one
|
|
// artificially generated in LoInit. The Advanced click handler uses the
|
|
// information to avoid incorrectly adopting the Typical defaults in the
|
|
// case of Advanced settings.
|
|
//
|
|
// BOOL fAuthRbInitialized;
|
|
|
|
// Used by the networking page
|
|
//
|
|
// INetCfg* pNetCfg;
|
|
// BOOL fInitCom;
|
|
// BOOL fReadOnly; // Netcfg was initialized in
|
|
// read-only mode
|
|
// BOOL fNonAdmin; // Run in non-admin mode (406630)
|
|
// BOOL fNetCfgLock;// NetCfg needs to be unlocked
|
|
// when uninited.
|
|
// SP_CLASSIMAGELIST_DATA cild;
|
|
// INetConnectionUiUtilities * pNetConUtilities;
|
|
// IUnknown* punkUiInfoCallback;
|
|
|
|
// Set if COM has been initialized (necessary for calls to netshell).
|
|
//
|
|
// BOOL fComInitialized;
|
|
|
|
// Keep track of whether we have shown this warning, or if it was disabled by the user
|
|
//
|
|
BOOL fShowDisableFirewallWarning;
|
|
|
|
// r/w memory for indirect propsheet dialog
|
|
LPDLGTEMPLATE lpdt;
|
|
}
|
|
PEINFO;
|
|
|
|
// local protos
|
|
INT_PTR CALLBACK SaDlgProc (IN HWND hwnd, IN UINT unMsg, IN WPARAM wparam, IN LPARAM lparam);
|
|
BOOL SaCommand (IN PEINFO* pInfo, IN WORD wNotification, IN WORD wId, IN HWND hwndCtrl);
|
|
BOOL SaInit (IN HWND hwndPage);
|
|
|
|
// more local protos
|
|
PEINFO* PeContext(IN HWND hwndPage);
|
|
BOOL SaIsAdapterDHCPEnabled(IN IHNetConnection* pConnection);
|
|
INT_PTR CALLBACK SaDisableFirewallWarningDlgProc(IN HWND hwnd, IN UINT unMsg, IN WPARAM wparam, IN LPARAM lparam);
|
|
HRESULT PeInit (GUID * pGuid, PEINFO ** ppEI);
|
|
DWORD EuInit (IN RASENTRY * pRE, IN TCHAR* pszPhonebook, IN TCHAR* pszEntry, IN RASENTRYDLG* pArgs, IN BOOL fRouter, OUT EINFO** ppInfo, OUT DWORD* pdwOp);
|
|
BOOL FIsUserAdminOrPowerUser (void);
|
|
void PeTerm (PEINFO * pEI);
|
|
VOID EuFree (IN EINFO* pInfo);
|
|
BOOL PeApply (IN HWND hwndPage);
|
|
BOOL EuCommit(IN EINFO* pInfo);
|
|
DWORD EuHomenetCommitSettings(IN EINFO* pInfo);
|
|
|
|
LRESULT CALLBACK CenterDlgOnOwnerCallWndProc (int code, WPARAM wparam, LPARAM lparam);
|
|
TCHAR* PszFromId(IN HINSTANCE hInstance,IN DWORD dwStringId);
|
|
|
|
HRESULT APIENTRY HrCreateNetConnectionUtilities(INetConnectionUiUtilities ** ppncuu);
|
|
|
|
VOID VerifyConnTypeAndCreds(IN PEINFO* pInfo);
|
|
DWORD FindEntryCredentials(IN TCHAR* pszPath, IN TCHAR* pszEntryName, OUT BOOL* pfUser, OUT BOOL* pfGlobal);
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Shared Access property page
|
|
// Listed alphabetically following dialog proc
|
|
//----------------------------------------------------------------------------
|
|
|
|
INT_PTR CALLBACK
|
|
SaDlgProc(
|
|
IN HWND hwnd,
|
|
IN UINT unMsg,
|
|
IN WPARAM wparam,
|
|
IN LPARAM lparam )
|
|
|
|
// DialogProc callback for the Shared Access page of the Entry property
|
|
// sheet.
|
|
// Parameters and return value are as described for standard windows
|
|
// 'DialogProc's.
|
|
//
|
|
{
|
|
#if 0
|
|
TRACE4( "SaDlgProc(h=$%x,m=$%x,w=$%x,l=$%x)",
|
|
(DWORD )hwnd, (DWORD )unMsg, (DWORD )wparam, (DWORD )lparam );
|
|
#endif
|
|
|
|
switch (unMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
// hang pPEINFO off prop
|
|
PROPSHEETPAGEW * pPSP = (PROPSHEETPAGEW *)lparam;
|
|
SetProp (hwnd, g_contextId, (HANDLE)pPSP->lParam);
|
|
return SaInit( hwnd );
|
|
}
|
|
|
|
case WM_NCDESTROY:
|
|
{
|
|
PEINFO* pInfo = PeContext( hwnd );
|
|
if (pInfo)
|
|
PeTerm (pInfo);
|
|
RemoveProp (hwnd, g_contextId);
|
|
GlobalDeleteAtom ((ATOM)g_contextId);
|
|
g_contextId = NULL;
|
|
break;
|
|
}
|
|
|
|
case WM_HELP:
|
|
case WM_CONTEXTMENU:
|
|
{
|
|
ContextHelp( g_adwSaHelp, hwnd, unMsg, wparam, lparam );
|
|
break;
|
|
}
|
|
|
|
case WM_COMMAND:
|
|
{
|
|
PEINFO* pInfo = PeContext( hwnd );
|
|
ASSERT(pInfo);
|
|
if (pInfo == NULL)
|
|
{
|
|
break;
|
|
}
|
|
|
|
return SaCommand(
|
|
pInfo, HIWORD( wparam ), LOWORD( wparam ),(HWND )lparam );
|
|
}
|
|
|
|
case WM_NOTIFY:
|
|
{
|
|
switch (((NMHDR* )lparam)->code)
|
|
{
|
|
case PSN_APPLY:
|
|
{
|
|
PeApply (hwnd);
|
|
return TRUE;
|
|
}
|
|
|
|
case PSN_KILLACTIVE:
|
|
{
|
|
PEINFO* pInfo;
|
|
|
|
TRACE("SwKILLACTIVE");
|
|
pInfo = PeContext( hwnd );
|
|
ASSERT(pInfo);
|
|
if (pInfo == NULL)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if ( Button_GetCheck( pInfo->hwndSaPbShared )
|
|
&& (!pInfo->pArgs->fShared || (pInfo->pArgs->fResetPrivateAdapter && 0 != pInfo->pArgs->dwLanCount)))
|
|
{
|
|
IHNetConnection* pPrivateConn = NULL;
|
|
|
|
if(1 < pInfo->pArgs->dwLanCount) // if the combobox is showing make sure they selected a valid adapter
|
|
{
|
|
INT item = ComboBox_GetCurSel( pInfo->hwndSaLbPrivateLan );
|
|
if (item != CB_ERR)
|
|
{
|
|
pPrivateConn = (IHNetConnection*)ComboBox_GetItemData( pInfo->hwndSaLbPrivateLan, item );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pPrivateConn = pInfo->pArgs->rgPrivateConns[0];
|
|
|
|
}
|
|
|
|
if(NULL == pPrivateConn)
|
|
{
|
|
MSGARGS msgargs;
|
|
ASSERT(1 < pInfo->pArgs->dwLanCount);
|
|
|
|
ZeroMemory( &msgargs, sizeof(msgargs) );
|
|
msgargs.dwFlags = MB_OK | MB_ICONWARNING;
|
|
MsgDlg( pInfo->hwndDlg, SID_SA_SelectAdapterError, &msgargs );
|
|
SetWindowLong( hwnd, DWLP_MSGRESULT, PSNRET_INVALID );
|
|
return TRUE;
|
|
}
|
|
|
|
if(!pInfo->pArgs->fOtherShared && FALSE == SaIsAdapterDHCPEnabled(pPrivateConn))
|
|
{
|
|
// if shared access is being turned on for the first time,
|
|
// explain its implications.
|
|
//
|
|
|
|
MSGARGS msgargs;
|
|
UINT unId;
|
|
ZeroMemory( &msgargs, sizeof(msgargs) );
|
|
msgargs.dwFlags = MB_YESNO | MB_ICONINFORMATION;
|
|
unId = MsgDlg( pInfo->hwndDlg, SID_EnableSharedAccess, &msgargs );
|
|
if (unId == IDNO)
|
|
SetWindowLong( hwnd, DWLP_MSGRESULT, TRUE );
|
|
else
|
|
SetWindowLong( hwnd, DWLP_MSGRESULT, FALSE );
|
|
}
|
|
}
|
|
|
|
if ( TRUE == pInfo->pArgs->fFirewalled && TRUE == pInfo->fShowDisableFirewallWarning && FALSE == Button_GetCheck( pInfo->hwndSaPbFirewalled ) )
|
|
{
|
|
INT_PTR nDialogResult;
|
|
pInfo->fShowDisableFirewallWarning = FALSE;
|
|
nDialogResult = DialogBox(g_hinstDll, MAKEINTRESOURCE(DID_SA_DisableFirewallWarning), hwnd, SaDisableFirewallWarningDlgProc);
|
|
if(-1 != nDialogResult && IDYES != nDialogResult)
|
|
{
|
|
Button_SetCheck ( pInfo->hwndSaPbFirewalled, TRUE );
|
|
SaCommand( pInfo, BN_CLICKED, CID_FW_PB_Firewalled, pInfo->hwndSaPbFirewalled );
|
|
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
case NM_CLICK:
|
|
case NM_RETURN:
|
|
{
|
|
HWND hPropertySheetWindow = GetParent(hwnd);
|
|
if(NULL != hPropertySheetWindow)
|
|
{
|
|
if(CID_SA_ST_HNWLink == wparam)
|
|
{
|
|
ShellExecute(NULL,TEXT("open"),TEXT("rundll32"), TEXT("hnetwiz.dll,HomeNetWizardRunDll"),NULL,SW_SHOW);
|
|
PostMessage(hPropertySheetWindow, WM_COMMAND, MAKEWPARAM(IDCANCEL, 0), (LPARAM) GetDlgItem(hPropertySheetWindow, IDCANCEL));
|
|
}
|
|
else if(CID_SA_ST_ICFLink == wparam || CID_SA_ST_ICSLink == wparam)
|
|
{
|
|
LPTSTR pszHelpTopic = CID_SA_ST_ICFLink == wparam ? TEXT("netcfg.chm::/hnw_understanding_firewall.htm") : TEXT("netcfg.chm::/Share_conn_overvw.htm");
|
|
HtmlHelp(NULL, pszHelpTopic, HH_DISPLAY_TOPIC, 0);
|
|
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL
|
|
SaCommand(
|
|
IN PEINFO* pInfo,
|
|
IN WORD wNotification,
|
|
IN WORD wId,
|
|
IN HWND hwndCtrl )
|
|
|
|
// Called on WM_COMMAND. 'PInfo' is the dialog context. 'WNotification'
|
|
// is the notification code of the command. 'wId' is the control/menu
|
|
// identifier of the command. 'HwndCtrl' is the control window handle of
|
|
// the command.
|
|
//
|
|
// Returns true if processed message, false otherwise.
|
|
//
|
|
{
|
|
TRACE3( "SaCommand(n=%d,i=%d,c=$%x)",
|
|
(DWORD )wNotification, (DWORD )wId, (ULONG_PTR )hwndCtrl );
|
|
|
|
switch (wId)
|
|
{
|
|
case CID_FW_PB_Firewalled:
|
|
{
|
|
BOOL fFirewalled = Button_GetCheck( pInfo->hwndSaPbFirewalled );
|
|
EnableWindow(
|
|
GetDlgItem( pInfo->hwndSa, CID_SA_PB_Settings ), fFirewalled || Button_GetCheck( pInfo->hwndSaPbShared ));
|
|
return TRUE;
|
|
}
|
|
|
|
case CID_SA_PB_Shared:
|
|
{
|
|
BOOL fShared = Button_GetCheck( pInfo->hwndSaPbShared );
|
|
EnableWindow( pInfo->hwndSaPbDemandDial, fShared );
|
|
EnableWindow( GetDlgItem(pInfo->hwndSa, CID_SA_PB_Beacon), fShared );
|
|
EnableWindow(
|
|
GetDlgItem( pInfo->hwndSa, CID_SA_PB_Settings ), fShared || Button_GetCheck( pInfo->hwndSaPbFirewalled ));
|
|
if (fShared && !pInfo->pArgs->fShared)
|
|
{
|
|
MSGARGS msgargs;
|
|
IEnumHNetIcsPublicConnections *pEnum;
|
|
IHNetIcsPublicConnection *pOldIcsConn;
|
|
IHNetConnection *pOldConn;
|
|
LPWSTR pszwOldName = NULL;
|
|
HRESULT hr;
|
|
hr = pInfo->pArgs->pIcsSettings->EnumIcsPublicConnections (&pEnum);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ULONG ulCount;
|
|
|
|
VerifyConnTypeAndCreds(pInfo);
|
|
|
|
hr = pEnum->Next(
|
|
1,
|
|
&pOldIcsConn,
|
|
&ulCount
|
|
);
|
|
|
|
if (SUCCEEDED(hr) && 1 == ulCount)
|
|
{
|
|
hr = pOldIcsConn->QueryInterface(
|
|
IID_IHNetConnection,
|
|
(void**)&pOldConn
|
|
);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Transer pOldIcsConn reference
|
|
//
|
|
pInfo->pArgs->fOtherShared = TRUE;
|
|
pInfo->pArgs->pOldSharedConnection = pOldIcsConn;
|
|
|
|
hr = pOldConn->GetName (&pszwOldName);
|
|
pOldConn->Release();
|
|
}
|
|
else
|
|
{
|
|
pOldIcsConn->Release();
|
|
}
|
|
}
|
|
|
|
pEnum->Release();
|
|
}
|
|
|
|
if (SUCCEEDED(hr) && NULL != pszwOldName)
|
|
{
|
|
ZeroMemory( &msgargs, sizeof(msgargs) );
|
|
msgargs.apszArgs[ 0 ] = pszwOldName;
|
|
msgargs.apszArgs[ 1 ] = pInfo->pArgs->pEntry->pszEntryName;
|
|
msgargs.dwFlags = MB_OK | MB_ICONINFORMATION;
|
|
MsgDlg( pInfo->hwndDlg, SID_ChangeSharedConnection, &msgargs );
|
|
CoTaskMemFree( pszwOldName );
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
case CID_SA_PB_Settings:
|
|
{
|
|
HNetSharingAndFirewallSettingsDlg(
|
|
pInfo->hwndDlg,
|
|
pInfo->pArgs->pHNetCfgMgr,
|
|
Button_GetCheck( pInfo->hwndSaPbFirewalled ),
|
|
pInfo->pArgs->pHNetConn
|
|
);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL
|
|
SaInit(
|
|
IN HWND hwndPage )
|
|
|
|
// Called on WM_INITDIALOG. 'hwndPage' is the handle of the property
|
|
// page.
|
|
//
|
|
// Return false if focus was set, true otherwise.
|
|
//
|
|
{
|
|
PEINFO* pInfo;
|
|
INetConnectionUiUtilities* pncuu = NULL;
|
|
OSVERSIONINFOEXW verInfo = {0};
|
|
ULONGLONG ConditionMask = 0;
|
|
|
|
TRACE( "SaInit" );
|
|
|
|
pInfo = PeContext( hwndPage );
|
|
if (!pInfo)
|
|
{
|
|
return TRUE;
|
|
}
|
|
_ASSERT (pInfo->hwndDlg == NULL);
|
|
pInfo->pArgs->hwndOwner = pInfo->hwndDlg = GetParent (hwndPage);
|
|
_ASSERT (pInfo->hwndDlg);
|
|
|
|
// Initialize page-specific context information.
|
|
//
|
|
pInfo->hwndSa = hwndPage;
|
|
pInfo->hwndSaPbShared = GetDlgItem( hwndPage, CID_SA_PB_Shared );
|
|
ASSERT( pInfo->hwndSaPbShared );
|
|
pInfo->hwndSaGbShared = GetDlgItem( hwndPage, CID_SA_GB_Shared );
|
|
ASSERT( pInfo->hwndSaGbShared );
|
|
pInfo->hwndSaGbPrivateLan = GetDlgItem( hwndPage, CID_SA_GB_PrivateLan );
|
|
ASSERT( pInfo->hwndSaGbPrivateLan );
|
|
pInfo->hwndSaEbPrivateLan = GetDlgItem( hwndPage, CID_SA_EB_PrivateLan );
|
|
ASSERT( pInfo->hwndSaEbPrivateLan );
|
|
pInfo->hwndSaLbPrivateLan = GetDlgItem( hwndPage, CID_SA_LB_PrivateLan );
|
|
ASSERT( pInfo->hwndSaLbPrivateLan );
|
|
pInfo->hwndSaSfPrivateLan = GetDlgItem( hwndPage, CID_SA_SF_PrivateLan );
|
|
ASSERT( pInfo->hwndSaSfPrivateLan );
|
|
pInfo->hwndSaPbDemandDial = GetDlgItem( hwndPage, CID_SA_PB_DemandDial );
|
|
ASSERT( pInfo->hwndSaPbDemandDial );
|
|
pInfo->hwndSaPbFirewalled = GetDlgItem( hwndPage, CID_FW_PB_Firewalled );
|
|
ASSERT( pInfo->hwndSaPbFirewalled );
|
|
|
|
// Initialize checks.
|
|
//
|
|
|
|
// Check if ZAW is denying access to the Shared Access UI
|
|
//
|
|
if (FAILED(HrCreateNetConnectionUtilities(&pncuu)))
|
|
{
|
|
ASSERT(NULL == pncuu);
|
|
}
|
|
|
|
if(NULL == pncuu || TRUE == pncuu->UserHasPermission (NCPERM_PersonalFirewallConfig))
|
|
{
|
|
HKEY hFirewallKey;
|
|
Button_SetCheck( pInfo->hwndSaPbFirewalled, pInfo->pArgs->fFirewalled );
|
|
SaCommand( pInfo, BN_CLICKED, CID_FW_PB_Firewalled, pInfo->hwndSaPbFirewalled );
|
|
|
|
pInfo->fShowDisableFirewallWarning = TRUE;
|
|
if(ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER, g_pszFirewallRegKey, 0, KEY_QUERY_VALUE, &hFirewallKey))
|
|
{
|
|
DWORD dwValue;
|
|
DWORD dwType;
|
|
DWORD dwSize = sizeof(dwValue);
|
|
if(ERROR_SUCCESS == RegQueryValueEx(hFirewallKey, g_pszDisableFirewallWarningValue, NULL, &dwType, (BYTE*)&dwValue, &dwSize))
|
|
{
|
|
if(REG_DWORD == dwType && TRUE == dwValue)
|
|
{
|
|
pInfo->fShowDisableFirewallWarning = FALSE;
|
|
}
|
|
}
|
|
RegCloseKey(hFirewallKey);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
EnableWindow(pInfo->hwndSaPbFirewalled, FALSE);
|
|
}
|
|
|
|
|
|
// Initialize the page's appearance.
|
|
// If there are multiple private LAN connections, below the 'shared access'
|
|
// checkbox we display either
|
|
// (a) a drop-list of LAN connections if the connection is not shared, or
|
|
// (b) a disabled edit-control with the current private LAN.
|
|
// This involves moving everything in the 'on-demand dialing' groupbox
|
|
// downward on the page at run-time.
|
|
// To achieve this, we use a hidden static control to tell us the position
|
|
// to which the groupbox should be moved.
|
|
//
|
|
|
|
BOOL fPolicyAllowsSharing = TRUE;
|
|
if(NULL != pncuu && FALSE == pncuu->UserHasPermission (NCPERM_ShowSharedAccessUi))
|
|
{
|
|
fPolicyAllowsSharing = FALSE;
|
|
}
|
|
|
|
if (pInfo->pArgs->dwLanCount == 0)
|
|
{
|
|
ShowWindow(pInfo->hwndSaGbShared, SW_HIDE);
|
|
ShowWindow(pInfo->hwndSaPbShared, SW_HIDE);
|
|
ShowWindow(pInfo->hwndSaPbDemandDial, SW_HIDE);
|
|
ShowWindow(GetDlgItem(hwndPage, CID_SA_PB_Shared), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hwndPage, CID_SA_ST_ICSLink), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hwndPage, CID_SA_PB_Beacon), SW_HIDE);
|
|
}
|
|
else if(FALSE == fPolicyAllowsSharing)
|
|
{
|
|
// if policy disables ICS just gray the checkbox
|
|
EnableWindow(pInfo->hwndSaPbShared, FALSE);
|
|
EnableWindow(pInfo->hwndSaPbDemandDial, FALSE);
|
|
EnableWindow(GetDlgItem(hwndPage, CID_SA_PB_Beacon), FALSE);
|
|
}
|
|
else if (pInfo->pArgs->dwLanCount > 1)
|
|
{
|
|
INT cy;
|
|
HDWP hdwp;
|
|
DWORD i;
|
|
INT item;
|
|
RECT rc, rcFrame;
|
|
IHNetConnection **rgPrivateConns;
|
|
LPWSTR pszwName;
|
|
HRESULT hr;
|
|
|
|
// get the reference-frame and group-box coordinates
|
|
//
|
|
GetWindowRect( pInfo->hwndSaSfPrivateLan, &rcFrame );
|
|
GetWindowRect( pInfo->hwndSaPbDemandDial, &rc );
|
|
cy = rcFrame.top - rc.top;
|
|
|
|
// move each control down by the amount in 'cy'
|
|
//
|
|
hdwp = BeginDeferWindowPos(3);
|
|
|
|
if(NULL != hdwp)
|
|
{
|
|
|
|
|
|
GetWindowRect( pInfo->hwndSaPbDemandDial, &rc);
|
|
MapWindowPoints(NULL, hwndPage, (LPPOINT)&rc, 2);
|
|
DeferWindowPos(hdwp, pInfo->hwndSaPbDemandDial, NULL,
|
|
rc.left, rc.top + cy, 0, 0, SWP_NOSIZE|SWP_NOZORDER);
|
|
|
|
HWND hBeaconCheck = GetDlgItem(hwndPage, CID_SA_PB_Beacon);
|
|
GetWindowRect( hBeaconCheck, &rc);
|
|
MapWindowPoints(NULL, hwndPage, (LPPOINT)&rc, 2);
|
|
DeferWindowPos(hdwp, hBeaconCheck, NULL,
|
|
rc.left, rc.top + cy, 0, 0, SWP_NOSIZE|SWP_NOZORDER);
|
|
|
|
HWND hICSLink = GetDlgItem(hwndPage, CID_SA_ST_ICSLink);
|
|
GetWindowRect( hICSLink, &rc);
|
|
MapWindowPoints(NULL, hwndPage, (LPPOINT)&rc, 2);
|
|
DeferWindowPos(hdwp, hICSLink, NULL,
|
|
rc.left, rc.top + cy, 0, 0, SWP_NOSIZE|SWP_NOZORDER);
|
|
|
|
EndDeferWindowPos(hdwp);
|
|
}
|
|
|
|
// hide the smaller shared-access group box, show the larger version,
|
|
// and display either the drop-list or the edit-control.
|
|
//
|
|
rgPrivateConns = (IHNetConnection **)pInfo->pArgs->rgPrivateConns;
|
|
ShowWindow( pInfo->hwndSaGbShared, SW_HIDE );
|
|
ShowWindow( pInfo->hwndSaGbPrivateLan, SW_SHOW );
|
|
ShowWindow(GetDlgItem(hwndPage, CID_SA_ST_HomeConnection), SW_SHOW);
|
|
EnableWindow(GetDlgItem(hwndPage, CID_SA_ST_HomeConnection), TRUE);
|
|
|
|
if (pInfo->pArgs->fShared && !pInfo->pArgs->fResetPrivateAdapter)
|
|
{
|
|
ShowWindow( pInfo->hwndSaEbPrivateLan, SW_SHOW );
|
|
|
|
// Fill in name of current private connection
|
|
//
|
|
|
|
hr = rgPrivateConns[pInfo->pArgs->lxCurrentPrivate]->GetName (&pszwName);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
SetWindowText(
|
|
pInfo->hwndSaEbPrivateLan, pszwName );
|
|
|
|
CoTaskMemFree( pszwName );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ShowWindow( pInfo->hwndSaLbPrivateLan, SW_SHOW );
|
|
|
|
// Add the bogus entry to the combobox
|
|
|
|
pszwName = PszFromId( g_hinstDll, SID_SA_SelectAdapter );
|
|
ASSERT(pszwName);
|
|
|
|
item = ComboBox_AddString( pInfo->hwndSaLbPrivateLan, pszwName );
|
|
if (item != CB_ERR && item != CB_ERRSPACE)
|
|
{
|
|
ComboBox_SetItemData( pInfo->hwndSaLbPrivateLan, item, NULL ); // ensure item data is null for validation purposes
|
|
}
|
|
|
|
// fill the combobox with LAN names
|
|
//
|
|
for (i = 0; i < pInfo->pArgs->dwLanCount; i++)
|
|
{
|
|
hr = rgPrivateConns[i]->GetName (&pszwName);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
item =
|
|
ComboBox_AddString(
|
|
pInfo->hwndSaLbPrivateLan, pszwName );
|
|
|
|
if (item != CB_ERR)
|
|
{
|
|
ComboBox_SetItemData(
|
|
pInfo->hwndSaLbPrivateLan, item, rgPrivateConns[i] );
|
|
}
|
|
|
|
CoTaskMemFree( pszwName );
|
|
}
|
|
}
|
|
|
|
ComboBox_SetCurSel( pInfo->hwndSaLbPrivateLan, 0 );
|
|
}
|
|
}
|
|
|
|
if(NULL != pncuu)
|
|
{
|
|
pncuu->Release();
|
|
}
|
|
|
|
// Initialize checks.
|
|
//
|
|
|
|
BOOL fBeaconControl = TRUE;
|
|
|
|
HKEY hKey;
|
|
DWORD dwError = RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGKEY_SHAREDACCESSCLIENTKEYPATH, 0, KEY_QUERY_VALUE, &hKey);
|
|
if(ERROR_SUCCESS == dwError) // if this fails we assume it is on, set the box, and commit on apply
|
|
{
|
|
DWORD dwType;
|
|
DWORD dwData = 0;
|
|
DWORD dwSize = sizeof(dwData);
|
|
dwError = RegQueryValueEx(hKey, REGVAL_SHAREDACCESSCLIENTENABLECONTROL, 0, &dwType, reinterpret_cast<LPBYTE>(&dwData), &dwSize);
|
|
if(ERROR_SUCCESS == dwError && REG_DWORD == dwType && 0 == dwData)
|
|
{
|
|
fBeaconControl = FALSE;
|
|
}
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
Button_SetCheck( pInfo->hwndSaPbShared, pInfo->pArgs->fShared );
|
|
Button_SetCheck( pInfo->hwndSaPbDemandDial, pInfo->pArgs->fDemandDial );
|
|
Button_SetCheck(GetDlgItem(hwndPage, CID_SA_PB_Beacon), fBeaconControl);
|
|
|
|
EnableWindow( pInfo->hwndSaPbDemandDial, pInfo->pArgs->fShared && fPolicyAllowsSharing);
|
|
EnableWindow( GetDlgItem(hwndPage, CID_SA_PB_Beacon), pInfo->pArgs->fShared && fPolicyAllowsSharing );
|
|
EnableWindow( GetDlgItem( pInfo->hwndSa, CID_SA_PB_Settings ), pInfo->pArgs->fShared || pInfo->pArgs->fFirewalled );
|
|
|
|
|
|
//if the machine is personal or workstation show the HNW link
|
|
verInfo.dwOSVersionInfoSize = sizeof(verInfo);
|
|
verInfo.wProductType = VER_NT_WORKSTATION;
|
|
|
|
VER_SET_CONDITION(ConditionMask, VER_PRODUCT_TYPE, VER_LESS_EQUAL);
|
|
|
|
if(0 != VerifyVersionInfo(&verInfo, VER_PRODUCT_TYPE, ConditionMask))
|
|
{
|
|
|
|
// but only if not on a domain
|
|
LPWSTR pszNameBuffer;
|
|
NETSETUP_JOIN_STATUS BufferType;
|
|
|
|
if(NERR_Success == NetGetJoinInformation(NULL, &pszNameBuffer, &BufferType))
|
|
{
|
|
NetApiBufferFree(pszNameBuffer);
|
|
if(NetSetupDomainName != BufferType)
|
|
{
|
|
ShowWindow(GetDlgItem(hwndPage, CID_SA_ST_HNWLink), SW_SHOW);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Making sure that Beacon checkbox is enabled only for
|
|
// Pro and Per Types of the OS.
|
|
//
|
|
VER_SET_CONDITION(ConditionMask, VER_PRODUCT_TYPE, VER_EQUAL);
|
|
|
|
if ( 0 == VerifyVersionInfo(&verInfo, VER_PRODUCT_TYPE, ConditionMask) &&
|
|
ERROR_OLD_WIN_VERSION == GetLastError() )
|
|
{
|
|
ShowWindow(GetDlgItem(hwndPage, CID_SA_PB_Beacon), SW_HIDE);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
INT_PTR CALLBACK
|
|
SaDisableFirewallWarningDlgProc(
|
|
IN HWND hwnd,
|
|
IN UINT unMsg,
|
|
IN WPARAM wparam,
|
|
IN LPARAM lparam )
|
|
{
|
|
switch(unMsg)
|
|
{
|
|
case WM_COMMAND:
|
|
{
|
|
switch(LOWORD(wparam))
|
|
{
|
|
case IDYES:
|
|
case IDNO:
|
|
if(BST_CHECKED == IsDlgButtonChecked(hwnd, CID_SA_PB_DisableFirewallWarning))
|
|
{
|
|
HKEY hFirewallKey;
|
|
if(ERROR_SUCCESS == RegCreateKeyEx(HKEY_CURRENT_USER, g_pszFirewallRegKey, 0, NULL, 0, KEY_SET_VALUE, NULL, &hFirewallKey, NULL))
|
|
{
|
|
DWORD dwValue = TRUE;
|
|
RegSetValueEx(hFirewallKey, g_pszDisableFirewallWarningValue, 0, REG_DWORD, (CONST BYTE*)&dwValue, sizeof(dwValue));
|
|
RegCloseKey(hFirewallKey);
|
|
}
|
|
}
|
|
|
|
// fallthru
|
|
case IDCANCEL:
|
|
EndDialog(hwnd, LOWORD(wparam));
|
|
break;
|
|
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL SaIsAdapterDHCPEnabled(IHNetConnection* pConnection)
|
|
{
|
|
HRESULT hr;
|
|
BOOL fDHCP = FALSE;
|
|
GUID* pAdapterGuid;
|
|
hr = pConnection->GetGuid (&pAdapterGuid);
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
LPOLESTR pAdapterName;
|
|
hr = StringFromCLSID(*pAdapterGuid, &pAdapterName);
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
SIZE_T Length = wcslen(pAdapterName);
|
|
LPSTR pszAnsiAdapterName = (LPSTR)Malloc(Length + 1);
|
|
if(NULL != pszAnsiAdapterName)
|
|
{
|
|
if(0 != WideCharToMultiByte(CP_ACP, 0, pAdapterName, (int)(Length + 1), pszAnsiAdapterName, (int)(Length + 1), NULL, NULL))
|
|
{
|
|
HMODULE hIpHelper;
|
|
hIpHelper = LoadLibrary(L"iphlpapi");
|
|
if(NULL != hIpHelper)
|
|
{
|
|
DWORD (WINAPI *pGetAdaptersInfo)(PIP_ADAPTER_INFO, PULONG);
|
|
|
|
pGetAdaptersInfo = (DWORD (WINAPI*)(PIP_ADAPTER_INFO, PULONG)) GetProcAddress(hIpHelper, "GetAdaptersInfo");
|
|
if(NULL != pGetAdaptersInfo)
|
|
{
|
|
ULONG ulSize = 0;
|
|
if(ERROR_BUFFER_OVERFLOW == pGetAdaptersInfo(NULL, &ulSize))
|
|
{
|
|
PIP_ADAPTER_INFO pInfo = (PIP_ADAPTER_INFO)Malloc(ulSize);
|
|
if(NULL != pInfo)
|
|
{
|
|
if(ERROR_SUCCESS == pGetAdaptersInfo(pInfo, &ulSize))
|
|
{
|
|
PIP_ADAPTER_INFO pAdapterInfo = pInfo;
|
|
do
|
|
{
|
|
if(0 == lstrcmpA(pszAnsiAdapterName, pAdapterInfo->AdapterName))
|
|
{
|
|
fDHCP = !!pAdapterInfo->DhcpEnabled;
|
|
break;
|
|
}
|
|
|
|
} while(NULL != (pAdapterInfo = pAdapterInfo->Next));
|
|
}
|
|
Free(pInfo);
|
|
}
|
|
}
|
|
}
|
|
FreeLibrary(hIpHelper);
|
|
}
|
|
}
|
|
Free(pszAnsiAdapterName);
|
|
}
|
|
CoTaskMemFree(pAdapterName);
|
|
}
|
|
CoTaskMemFree(pAdapterGuid);
|
|
}
|
|
|
|
return fDHCP;
|
|
}
|
|
|
|
PEINFO* PeContext (IN HWND hwndPage)
|
|
{
|
|
// Retrieve the property sheet context from a property page handle.
|
|
//
|
|
// return (PEINFO* )GetProp( GetParent( hwndPage ), g_contextId );
|
|
// now hanging our stuff off our window (since it's not shared)
|
|
return (PEINFO* )GetProp( hwndPage, g_contextId );
|
|
}
|
|
|
|
void PeTerm (PEINFO * pEI)
|
|
{
|
|
_ASSERT (pEI);
|
|
_ASSERT (pEI->pArgs);
|
|
_ASSERT (pEI->pArgs->pEntry);
|
|
|
|
Free (pEI->pArgs->pEntry); // BILLSPBENTRY
|
|
EuFree (pEI->pArgs);
|
|
if (pEI->lpdt)
|
|
Free (pEI->lpdt);
|
|
Free (pEI);
|
|
}
|
|
|
|
VOID
|
|
EuFree(
|
|
IN EINFO* pInfo )
|
|
|
|
// Releases 'pInfo' and associated resources.
|
|
//
|
|
{
|
|
TCHAR* psz;
|
|
// INTERNALARGS* piargs;
|
|
|
|
// piargs = (INTERNALARGS* )pInfo->pApiArgs->reserved;
|
|
|
|
// Don't clean up the phonebook and user preferences if they arrived via
|
|
// the secret hack.
|
|
//
|
|
// if (!piargs)
|
|
// {
|
|
// if (pInfo->pFile)
|
|
// {
|
|
// ClosePhonebookFile( pInfo->pFile );
|
|
// }
|
|
|
|
// if (pInfo->pUser)
|
|
// {
|
|
// DestroyUserPreferences( pInfo->pUser );
|
|
// }
|
|
// }
|
|
|
|
// if (pInfo->pListPorts)
|
|
// {
|
|
// DtlDestroyList( pInfo->pListPorts, DestroyPortNode );
|
|
// }
|
|
// Free(pInfo->pszCurDevice);
|
|
// Free(pInfo->pszCurPort);
|
|
|
|
// if (pInfo->pNode)
|
|
// {
|
|
// DestroyEntryNode( pInfo->pNode );
|
|
// }
|
|
|
|
// Free router-information
|
|
//
|
|
// Free( pInfo->pszRouter );
|
|
// Free( pInfo->pszRouterUserName );
|
|
// Free( pInfo->pszRouterDomain );
|
|
|
|
// if (pInfo->pSharedNode)
|
|
// {
|
|
// DestroyLinkNode( pInfo->pSharedNode );
|
|
// }
|
|
|
|
// psz = pInfo->pszRouterPassword;
|
|
// if (psz)
|
|
// {
|
|
// ZeroMemory( psz, lstrlen( psz ) * sizeof(TCHAR) );
|
|
// Free( psz );
|
|
// }
|
|
|
|
// psz = pInfo->pszRouterDialInPassword;
|
|
// if (psz)
|
|
// {
|
|
// ZeroMemory( psz, lstrlen( psz ) * sizeof(TCHAR) );
|
|
// Free( psz );
|
|
// }
|
|
|
|
// Free credentials stuff
|
|
// Free(pInfo->pszDefUserName);
|
|
// Free(pInfo->pszDefPassword);
|
|
|
|
// Free home networking information
|
|
//
|
|
if (pInfo->rgPrivateConns)
|
|
{
|
|
UINT i;
|
|
|
|
for (i = 0; i < pInfo->dwLanCount; i++)
|
|
{
|
|
if (pInfo->rgPrivateConns[i])
|
|
{
|
|
pInfo->rgPrivateConns[i]->Release();
|
|
}
|
|
}
|
|
|
|
CoTaskMemFree(pInfo->rgPrivateConns);
|
|
}
|
|
|
|
if (pInfo->pHNetConn)
|
|
{
|
|
pInfo->pHNetConn->Release();
|
|
}
|
|
|
|
if (pInfo->pIcsSettings)
|
|
{
|
|
pInfo->pIcsSettings->Release();
|
|
}
|
|
|
|
if (pInfo->pOldSharedConnection)
|
|
{
|
|
pInfo->pOldSharedConnection->Release();
|
|
}
|
|
|
|
if (pInfo->pHNetCfgMgr)
|
|
{
|
|
pInfo->pHNetCfgMgr->Release();
|
|
}
|
|
|
|
if (pInfo->fComInitialized)
|
|
{
|
|
CoUninitialize();
|
|
}
|
|
|
|
Free( pInfo );
|
|
}
|
|
|
|
// helper
|
|
HRESULT GetRasEntry (TCHAR * pszPhonebook, TCHAR * pszEntry, RASENTRY ** ppRE)
|
|
{
|
|
*ppRE = NULL;
|
|
|
|
DWORD dwSize = 0;
|
|
DWORD dwErr = RasGetEntryProperties (pszPhonebook, pszEntry, NULL, &dwSize, NULL, NULL);
|
|
if (dwErr != ERROR_BUFFER_TOO_SMALL)
|
|
return HRESULT_FROM_WIN32(dwErr);
|
|
_ASSERT (dwSize != 0);
|
|
|
|
RASENTRY * pRE = (RASENTRY*)Malloc (dwSize);
|
|
if (!pRE)
|
|
return E_OUTOFMEMORY;
|
|
|
|
ZeroMemory (pRE, dwSize);
|
|
pRE->dwSize = sizeof(RASENTRY);
|
|
|
|
dwErr = RasGetEntryProperties (pszPhonebook, pszEntry, pRE, &dwSize, NULL, NULL);
|
|
if (dwErr) {
|
|
Free (pRE);
|
|
return HRESULT_FROM_WIN32(dwErr);
|
|
}
|
|
*ppRE = pRE;
|
|
return S_OK;
|
|
}
|
|
|
|
// wrapper....
|
|
HRESULT PeInit (GUID * pGuid, PEINFO ** ppEI)
|
|
{
|
|
_ASSERT (pGuid);
|
|
_ASSERT (ppEI);
|
|
|
|
*ppEI = (PEINFO *)Malloc (sizeof(PEINFO));
|
|
if (!*ppEI)
|
|
return E_OUTOFMEMORY;
|
|
ZeroMemory (*ppEI, sizeof(PEINFO));
|
|
|
|
CComPtr<IHNetConnection> spHNetConn = NULL;
|
|
CComPtr<IHNetCfgMgr> spHNetCfgMgr = NULL;
|
|
HRESULT hr = CoCreateInstance (CLSID_HNetCfgMgr,
|
|
NULL,
|
|
CLSCTX_ALL,
|
|
__uuidof(IHNetCfgMgr), // &IID_IHNetCfgMgr,
|
|
(void**)&spHNetCfgMgr);
|
|
if (SUCCEEDED(hr)) {
|
|
// Convert the entry to an IHNetConnection
|
|
hr = spHNetCfgMgr->GetIHNetConnectionForGuid (
|
|
pGuid, FALSE, TRUE, &spHNetConn);
|
|
}
|
|
if (SUCCEEDED(hr)) {
|
|
// the code below assumes UNICODE....
|
|
TCHAR * pszPhonebook = NULL;
|
|
TCHAR * pszEntry = NULL;
|
|
hr = spHNetConn->GetName (&pszEntry);
|
|
if (hr == S_OK)
|
|
hr = spHNetConn->GetRasPhonebookPath (&pszPhonebook);
|
|
|
|
if (hr == S_OK) {
|
|
// get RASENTRY dwType and guidId fields for code below
|
|
RASENTRY * pRE = NULL;
|
|
hr = GetRasEntry (pszPhonebook, pszEntry, &pRE);
|
|
if (pRE) {
|
|
DWORD dwOp = 0;
|
|
DWORD dwError = EuInit (pRE,
|
|
pszPhonebook,
|
|
pszEntry,
|
|
NULL, // IN RASENTRYDLG* pArgs,
|
|
FALSE, // IN BOOL fRouter,
|
|
&(*ppEI)->pArgs,
|
|
&dwOp);
|
|
if (dwError != 0) {
|
|
_ASSERT (dwOp != 0);
|
|
_ASSERT (!*ppEI);
|
|
if (HRESULT_SEVERITY(dwError))
|
|
hr = dwError;
|
|
else
|
|
hr = HRESULT_FROM_WIN32 (dwError);
|
|
} else {
|
|
_ASSERT (dwOp == 0);
|
|
_ASSERT (*ppEI);
|
|
}
|
|
Free (pRE);
|
|
}
|
|
}
|
|
if (pszPhonebook) CoTaskMemFree (pszPhonebook);
|
|
if (pszEntry) CoTaskMemFree (pszEntry);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
DWORD
|
|
EuInit(
|
|
IN RASENTRY * pRE,
|
|
IN TCHAR* pszPhonebook,
|
|
IN TCHAR* pszEntry,
|
|
IN RASENTRYDLG* pArgs,
|
|
IN BOOL fRouter,
|
|
OUT EINFO** ppInfo,
|
|
OUT DWORD* pdwOp )
|
|
|
|
// Allocates '*ppInfo' data for use by the property sheet or wizard.
|
|
// 'PszPhonebook', 'pszEntry', and 'pArgs', are the arguments passed by
|
|
// user to the API. 'FRouter' is set if running in "router mode", clear
|
|
// for the normal "dial-out" mode. '*pdwOp' is set to the operation code
|
|
// associated with any error.
|
|
//
|
|
// Returns 0 if successful, or an error code. If non-null '*ppInfo' is
|
|
// returned caller must eventually call EuFree to release the returned
|
|
// block.
|
|
//
|
|
{
|
|
DWORD dwErr;
|
|
EINFO* pInfo;
|
|
// INTERNALARGS* piargs;
|
|
|
|
*ppInfo = NULL;
|
|
*pdwOp = 0;
|
|
|
|
pInfo = (EINFO*)Malloc( sizeof(EINFO) );
|
|
if (!pInfo)
|
|
{
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
ZeroMemory( pInfo, sizeof(*pInfo ) );
|
|
|
|
/*
|
|
bhanlon: I'm filling out what used to be a PBENTRY with a
|
|
BILLSPBENTRY struct. This needs to be freed....
|
|
*/
|
|
pInfo->pEntry = (BILLSPBENTRY *)Malloc (sizeof(BILLSPBENTRY));
|
|
if (!pInfo->pEntry) {
|
|
Free (pInfo);
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
_tcsncpy (pInfo->pEntry->pszEntryName, pszEntry, RAS_MaxEntryName);
|
|
_tcsncpy (pInfo->pEntry->pszPhonebookPath, pszPhonebook, MAX_PATH);
|
|
pInfo->pEntry->pGuid = &pInfo->pEntry->guidId;
|
|
pInfo->pEntry->dwfExcludedProtocols = 0;
|
|
pInfo->pEntry->dwType = pRE->dwType;
|
|
pInfo->pEntry->guidId = pRE->guidId;
|
|
|
|
*ppInfo = pInfo;
|
|
pInfo->pszPhonebook = pszPhonebook;
|
|
pInfo->pszEntry = pszEntry;
|
|
// pInfo->pApiArgs = pArgs;
|
|
pInfo->fRouter = fRouter;
|
|
|
|
// piargs = (INTERNALARGS *)pArgs->reserved;
|
|
|
|
// if (pInfo->fRouter)
|
|
// {
|
|
// LPTSTR pszRouter;
|
|
// DWORD dwVersion;
|
|
|
|
// ASSERT(piargs);
|
|
|
|
// pszRouter = RemoteGetServerName(piargs->hConnection);
|
|
|
|
// pmay: 348623
|
|
//
|
|
// Note that RemoteGetServerName is guarenteed to return
|
|
// NULL for local box, non-NULL for remote
|
|
//
|
|
// pInfo->fRemote = !!pszRouter;
|
|
|
|
// if(NULL == pszRouter)
|
|
// {
|
|
// pszRouter = TEXT("");
|
|
// }
|
|
|
|
// pInfo->pszRouter = StrDupTFromW(pszRouter);
|
|
|
|
// Find out if we're focused on an nt4 router
|
|
// pInfo->fNt4Router = FALSE;
|
|
// IsNt40Machine( pszRouter, &(pInfo->fNt4Router) );
|
|
|
|
// dwVersion = ((RAS_RPC *)(piargs->hConnection))->dwVersion;
|
|
|
|
// pInfo->fNt4Router = !!(VERSION_40 == dwVersion );
|
|
//Find out if the remote server is a win2k machine
|
|
//
|
|
// pInfo->fW2kRouter = !!(VERSION_50 == dwVersion );
|
|
// }
|
|
|
|
// Load the user preferences, or figure out that caller has already loaded
|
|
// them.
|
|
//
|
|
// if (piargs && !piargs->fInvalid)
|
|
// {
|
|
// // We've received user preferences and the "no user" status via the
|
|
// // secret hack.
|
|
// //
|
|
// pInfo->pUser = piargs->pUser;
|
|
// pInfo->fNoUser = piargs->fNoUser;
|
|
// pInfo->pFile = piargs->pFile;
|
|
// pInfo->fDisableFirstConnect = piargs->fDisableFirstConnect;
|
|
// }
|
|
// else
|
|
// {
|
|
// DWORD dwReadPbkFlags = 0;
|
|
|
|
// // Read user preferences from registry.
|
|
// //
|
|
// dwErr = g_pGetUserPreferences(
|
|
// (piargs) ? piargs->hConnection : NULL,
|
|
// &pInfo->user,
|
|
// (pInfo->fRouter) ? UPM_Router : UPM_Normal );
|
|
// if (dwErr != 0)
|
|
// {
|
|
// *pdwOp = SID_OP_LoadPrefs;
|
|
// return dwErr;
|
|
// }
|
|
|
|
// pInfo->pUser = &pInfo->user;
|
|
|
|
// if(pInfo->fRouter)
|
|
// {
|
|
// pInfo->file.hConnection = piargs->hConnection;
|
|
// dwReadPbkFlags |= RPBF_Router;
|
|
// }
|
|
|
|
// if(pInfo->fNoUser)
|
|
// {
|
|
// dwReadPbkFlags |= RPBF_NoUser;
|
|
// }
|
|
|
|
// Load and parse the phonebook file.
|
|
//
|
|
// dwErr = ReadPhonebookFile(
|
|
// pInfo->pszPhonebook, &pInfo->user, NULL,
|
|
// dwReadPbkFlags,
|
|
// &pInfo->file );
|
|
// if (dwErr != 0)
|
|
// {
|
|
// *pdwOp = SID_OP_LoadPhonebook;
|
|
// return dwErr;
|
|
// }
|
|
|
|
// pInfo->pFile = &pInfo->file;
|
|
// }
|
|
|
|
// Determine if strong encryption is supported. Export laws prevent it in
|
|
// some versions of the system.
|
|
//
|
|
{
|
|
// ULONG ulCaps;
|
|
// RAS_NDISWAN_DRIVER_INFO info;
|
|
//
|
|
// ZeroMemory( &info, sizeof(info) );
|
|
// ASSERT( g_pRasGetNdiswanDriverCaps );
|
|
// dwErr = g_pRasGetNdiswanDriverCaps(
|
|
// (piargs) ? piargs->hConnection : NULL, &info );
|
|
// if (dwErr == 0)
|
|
// {
|
|
// pInfo->fStrongEncryption =
|
|
// !!(info.DriverCaps & RAS_NDISWAN_128BIT_ENABLED);
|
|
// }
|
|
// else
|
|
{
|
|
pInfo->fStrongEncryption = FALSE;
|
|
}
|
|
}
|
|
|
|
// Load the list of ports.
|
|
//
|
|
// dwErr = LoadPortsList2(
|
|
// (piargs) ? piargs->hConnection : NULL,
|
|
// &pInfo->pListPorts,
|
|
// pInfo->fRouter );
|
|
// if (dwErr != 0)
|
|
// {
|
|
// TRACE1( "LoadPortsList=%d", dwErr );
|
|
// *pdwOp = SID_OP_RetrievingData;
|
|
// return dwErr;
|
|
// }
|
|
|
|
// Set up work entry node.
|
|
//
|
|
// if (pInfo->pApiArgs->dwFlags & RASEDFLAG_AnyNewEntry)
|
|
// {
|
|
// DTLNODE* pNodeL;
|
|
// DTLNODE* pNodeP;
|
|
// PBLINK* pLink;
|
|
// PBPORT* pPort;
|
|
// // New entry mode, so 'pNode' set to default settings.
|
|
// //
|
|
// pInfo->pNode = CreateEntryNode( TRUE );
|
|
// if (!pInfo->pNode)
|
|
// {
|
|
// TRACE( "CreateEntryNode failed" );
|
|
// *pdwOp = SID_OP_RetrievingData;
|
|
// return dwErr;
|
|
// }
|
|
|
|
// // Store entry within work node stored in context for convenience
|
|
// // elsewhere.
|
|
// //
|
|
// pInfo->pEntry = (PBENTRY* )DtlGetData( pInfo->pNode );
|
|
// ASSERT( pInfo->pEntry );
|
|
|
|
// if (pInfo->fRouter)
|
|
// {
|
|
// Set router specific defaults.
|
|
//
|
|
// pInfo->pEntry->dwIpNameSource = ASRC_None;
|
|
// pInfo->pEntry->dwRedialAttempts = 0;
|
|
|
|
// Since this is a new entry, setup a proposed entry name.
|
|
// This covers the case when the wizard is not used to
|
|
// create the entry and the property sheet has no way to enter
|
|
// the name.
|
|
// ASSERT( !pInfo->pEntry->pszEntryName );
|
|
// GetDefaultEntryName( pInfo->pFile,
|
|
// RASET_Phone,
|
|
// pInfo->fRouter,
|
|
// &pInfo->pEntry->pszEntryName );
|
|
|
|
// Disable MS client and File and Print services by default
|
|
//
|
|
// EnableOrDisableNetComponent( pInfo->pEntry, TEXT("ms_msclient"),
|
|
// FALSE);
|
|
// EnableOrDisableNetComponent( pInfo->pEntry, TEXT("ms_server"),
|
|
// FALSE);
|
|
// }
|
|
|
|
// Use caller's default name, if any.
|
|
//
|
|
// if (pInfo->pszEntry)
|
|
// {
|
|
// pInfo->pEntry->pszEntryName = StrDup( pInfo->pszEntry );
|
|
// }
|
|
|
|
// Set the default entry type to "phone", i.e. modems, ISDN, X.26 etc.
|
|
// This may be changed to "VPN" or "direct" by the new entry wizard
|
|
// after the initial wizard page.
|
|
//
|
|
// EuChangeEntryType( pInfo, RASET_Phone );
|
|
// }
|
|
// else
|
|
// {
|
|
// DTLNODE* pNode;
|
|
|
|
// Edit or clone entry mode, so 'pNode' set to entry's current
|
|
// settings.
|
|
//
|
|
// pInfo->pOldNode = EntryNodeFromName(
|
|
// pInfo->pFile->pdtllistEntries, pInfo->pszEntry );
|
|
|
|
// if ( !pInfo->pOldNode
|
|
// && !pInfo->fRouter)
|
|
// {
|
|
|
|
// if(NULL == pInfo->pszPhonebook)
|
|
// {
|
|
//
|
|
// Close the phonebook file we opened above.
|
|
// we will try to find the entry name in the
|
|
// per user phonebook file.
|
|
//
|
|
// ClosePhonebookFile(&pInfo->file);
|
|
|
|
// pInfo->pFile = NULL;
|
|
|
|
//
|
|
// Attempt to find the file in users profile
|
|
//
|
|
// dwErr = GetPbkAndEntryName(
|
|
// NULL,
|
|
// pInfo->pszEntry,
|
|
// 0,
|
|
// &pInfo->file,
|
|
// &pInfo->pOldNode);
|
|
|
|
// if(ERROR_SUCCESS != dwErr)
|
|
// {
|
|
// *pdwOp = SID_OP_RetrievingData;
|
|
// return ERROR_CANNOT_FIND_PHONEBOOK_ENTRY;
|
|
// }
|
|
|
|
// pInfo->pFile = &pInfo->file;
|
|
// }
|
|
// else
|
|
// {
|
|
// *pdwOp = SID_OP_RetrievingData;
|
|
// return ERROR_CANNOT_FIND_PHONEBOOK_ENTRY;
|
|
// }
|
|
// }
|
|
|
|
// if(NULL != pInfo->pOldNode)
|
|
// {
|
|
// PBENTRY *pEntry = (PBENTRY *) DtlGetData(pInfo->pOldNode);
|
|
|
|
// Before cloning or editing make sure that for dial up
|
|
// connections, share File And Print is disabled.
|
|
//
|
|
// if( ((RASET_Phone == pEntry->dwType)
|
|
// || (RASET_Broadband == pEntry->dwType))
|
|
// && (!pEntry->fShareMsFilePrint))
|
|
// {
|
|
// EnableOrDisableNetComponent( pEntry, TEXT("ms_server"),
|
|
// FALSE);
|
|
// }
|
|
// }
|
|
|
|
// if(NULL != pInfo->pOldNode)
|
|
// {
|
|
// if (pInfo->pApiArgs->dwFlags & RASEDFLAG_CloneEntry)
|
|
// {
|
|
// pInfo->pNode = CloneEntryNode( pInfo->pOldNode );
|
|
// }
|
|
// else
|
|
// {
|
|
// pInfo->pNode = DuplicateEntryNode( pInfo->pOldNode );
|
|
// }
|
|
// }
|
|
|
|
// if (!pInfo->pNode)
|
|
// {
|
|
// TRACE( "DuplicateEntryNode failed" );
|
|
// *pdwOp = SID_OP_RetrievingData;
|
|
// return ERROR_NOT_ENOUGH_MEMORY;
|
|
// }
|
|
|
|
// Store entry within work node stored in context for convenience
|
|
// elsewhere.
|
|
//
|
|
// pInfo->pEntry = (PBENTRY* )DtlGetData( pInfo->pNode );
|
|
|
|
// Save original entry name for comparison later.
|
|
//
|
|
// lstrcpyn(
|
|
// pInfo->szOldEntryName,
|
|
// pInfo->pEntry->pszEntryName,
|
|
// RAS_MaxEntryName + 1);
|
|
|
|
// For router, want unconfigured ports to show up as "unavailable" so
|
|
// they stand out to user who has been directed to change them.
|
|
//
|
|
// if (pInfo->fRouter)
|
|
// {
|
|
// DTLNODE* pNodeL;
|
|
// PBLINK* pLink;
|
|
|
|
// pNodeL = DtlGetFirstNode( pInfo->pEntry->pdtllistLinks );
|
|
// pLink = (PBLINK* )DtlGetData( pNodeL );
|
|
|
|
// if (!pLink->pbport.fConfigured)
|
|
// {
|
|
// Free( pLink->pbport.pszDevice );
|
|
// pLink->pbport.pszDevice = NULL;
|
|
// }
|
|
// }
|
|
|
|
// pmay: 277801
|
|
//
|
|
// Remember the "current" device if this entry was last saved
|
|
// as single link.
|
|
//
|
|
// if (DtlGetNodes(pInfo->pEntry->pdtllistLinks) == 1)
|
|
// {
|
|
// DTLNODE* pNodeL;
|
|
// PBLINK* pLink;
|
|
|
|
// pNodeL = DtlGetFirstNode( pInfo->pEntry->pdtllistLinks );
|
|
// pLink = (PBLINK* )DtlGetData( pNodeL );
|
|
|
|
// if (pLink->pbport.pszDevice && pLink->pbport.pszPort)
|
|
// {
|
|
// pInfo->pszCurDevice =
|
|
// StrDup(pLink->pbport.pszDevice);
|
|
// pInfo->pszCurPort =
|
|
// StrDup(pLink->pbport.pszPort);
|
|
// }
|
|
// }
|
|
|
|
// Append all non-configured ports of the entries type to the list of
|
|
// links. This is for the convenience of the UI. The non-configured
|
|
// ports are removed after editing prior to saving.
|
|
//
|
|
// AppendDisabledPorts( pInfo, pInfo->pEntry->dwType );
|
|
// }
|
|
|
|
// Set up the phone number storage for shared phone number mode.
|
|
// Initialize it to a copy of the information from the first link which at
|
|
// startup will always be enabled. Note the Dial case with non-0
|
|
// dwSubEntry is an exception, but in that case the pSharedNode anyway.
|
|
//
|
|
// {
|
|
// DTLNODE* pNode;
|
|
|
|
// pInfo->pSharedNode = CreateLinkNode();
|
|
// if (!pInfo->pSharedNode)
|
|
// {
|
|
// *pdwOp = SID_OP_RetrievingData;
|
|
// return ERROR_NOT_ENOUGH_MEMORY;
|
|
// }
|
|
|
|
// ASSERT( pInfo->pSharedNode );
|
|
// pNode = DtlGetFirstNode( pInfo->pEntry->pdtllistLinks );
|
|
// ASSERT( pNode );
|
|
// CopyLinkPhoneNumberInfo( pInfo->pSharedNode, pNode );
|
|
// }
|
|
|
|
// Load the current shared-access (and firewall) settings
|
|
//
|
|
if (!pInfo->fRouter)
|
|
{
|
|
HRESULT hr;
|
|
HNET_CONN_PROPERTIES *pProps;
|
|
|
|
// Make sure COM is initialized on this thread.
|
|
//
|
|
hr = CoInitializeEx(
|
|
NULL,
|
|
COINIT_MULTITHREADED | COINIT_DISABLE_OLE1DDE
|
|
);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pInfo->fComInitialized = TRUE;
|
|
}
|
|
else if (RPC_E_CHANGED_MODE == hr)
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Create the home networking configuration manager
|
|
//
|
|
hr = CoCreateInstance(
|
|
CLSID_HNetCfgMgr,
|
|
NULL,
|
|
CLSCTX_ALL,
|
|
__uuidof(IHNetCfgMgr),
|
|
(void**)&pInfo->pHNetCfgMgr);
|
|
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Get the IHNetIcsSettings interface
|
|
//
|
|
|
|
hr = pInfo->pHNetCfgMgr->QueryInterface(
|
|
__uuidof(IHNetIcsSettings), (void**)&pInfo->pIcsSettings);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Convert the entry to an IHNetConnection
|
|
//
|
|
|
|
hr = pInfo->pHNetCfgMgr->GetIHNetConnectionForGuid(
|
|
pInfo->pEntry->pGuid, FALSE, TRUE,
|
|
&pInfo->pHNetConn);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Determine whether this entry is already shared;
|
|
// skip the check for new entries.
|
|
//
|
|
if (pInfo->pEntry->pszEntryName)
|
|
{
|
|
hr = pInfo->pHNetConn->GetProperties (&pProps);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pInfo->fShared = pProps->fIcsPublic;
|
|
pInfo->fFirewalled = pProps->fFirewalled;
|
|
CoTaskMemFree(pProps);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pInfo->fShared = FALSE;
|
|
pInfo->fFirewalled = FALSE;
|
|
}
|
|
|
|
pInfo->fNewShared = pInfo->fShared;
|
|
pInfo->fNewFirewalled = pInfo->fFirewalled;
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Obtain an array of possible ICS private connections
|
|
//
|
|
hr = pInfo->pIcsSettings->GetPossiblePrivateConnections(
|
|
pInfo->pHNetConn,
|
|
&pInfo->dwLanCount,
|
|
&pInfo->rgPrivateConns,
|
|
&pInfo->lxCurrentPrivate
|
|
);
|
|
|
|
RasQuerySharedAutoDial(&pInfo->fDemandDial);
|
|
pInfo->fNewDemandDial = pInfo->fDemandDial;
|
|
pInfo->fResetPrivateAdapter =
|
|
pInfo->fShared && -1 == pInfo->lxCurrentPrivate;
|
|
}
|
|
|
|
pInfo->hShowHNetPagesResult = hr;
|
|
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
pInfo->fShowHNetPages = TRUE;
|
|
}
|
|
}
|
|
|
|
// if (pInfo->fRouter)
|
|
// {
|
|
// pInfo->pEntry->dwfExcludedProtocols |= NP_Nbf;
|
|
// }
|
|
|
|
// AboladeG - capture the security level of the current user.
|
|
//
|
|
pInfo->fIsUserAdminOrPowerUser = FIsUserAdminOrPowerUser();
|
|
|
|
return 0;
|
|
}
|
|
|
|
BOOL
|
|
FIsUserAdminOrPowerUser()
|
|
{
|
|
SID_IDENTIFIER_AUTHORITY SidAuth = SECURITY_NT_AUTHORITY;
|
|
PSID psid;
|
|
BOOL fIsMember = FALSE;
|
|
BOOL fRet = FALSE;
|
|
SID sidLocalSystem = { 1, 1,
|
|
SECURITY_NT_AUTHORITY,
|
|
SECURITY_LOCAL_SYSTEM_RID };
|
|
|
|
|
|
// Check to see if running under local system first
|
|
//
|
|
if (!CheckTokenMembership( NULL, &sidLocalSystem, &fIsMember ))
|
|
{
|
|
TRACE( "CheckTokenMemberShip for local system failed.");
|
|
fIsMember = FALSE;
|
|
}
|
|
|
|
fRet = fIsMember;
|
|
|
|
if (!fIsMember)
|
|
{
|
|
// Allocate a SID for the Administrators group and check to see
|
|
// if the user is a member.
|
|
//
|
|
if (AllocateAndInitializeSid( &SidAuth, 2,
|
|
SECURITY_BUILTIN_DOMAIN_RID,
|
|
DOMAIN_ALIAS_RID_ADMINS,
|
|
0, 0, 0, 0, 0, 0,
|
|
&psid ))
|
|
{
|
|
if (!CheckTokenMembership( NULL, psid, &fIsMember ))
|
|
{
|
|
TRACE( "CheckTokenMemberShip for admins failed.");
|
|
fIsMember = FALSE;
|
|
}
|
|
|
|
FreeSid( psid );
|
|
|
|
// Changes to the Windows 2000 permission model mean that regular Users
|
|
// on workstations are in the power user group. So we no longer want to
|
|
// check for power user.
|
|
#if 0
|
|
if (!fIsMember)
|
|
{
|
|
// They're not a member of the Administrators group so allocate a
|
|
// SID for the Power Users group and check to see
|
|
// if the user is a member.
|
|
//
|
|
if (AllocateAndInitializeSid( &SidAuth, 2,
|
|
SECURITY_BUILTIN_DOMAIN_RID,
|
|
DOMAIN_ALIAS_RID_POWER_USERS,
|
|
0, 0, 0, 0, 0, 0,
|
|
&psid ))
|
|
{
|
|
if (!CheckTokenMembership( NULL, psid, &fIsMember ))
|
|
{
|
|
TRACE( "CheckTokenMemberShip for power users failed.");
|
|
fIsMember = FALSE;
|
|
}
|
|
|
|
FreeSid( psid );
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
fRet = fIsMember;
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
BOOL PeApply (IN HWND hwndPage)
|
|
{
|
|
// Saves the contents of the property sheet. 'HwndPage is the handle of a
|
|
// property page. Pops up any errors that occur.
|
|
//
|
|
// Returns true is page can be dismissed, false otherwise.
|
|
//
|
|
DWORD dwErr;
|
|
PEINFO* pInfo;
|
|
BILLSPBENTRY* pEntry;
|
|
|
|
TRACE( "PeApply" );
|
|
|
|
pInfo = PeContext( hwndPage );
|
|
ASSERT( pInfo );
|
|
if (pInfo == NULL)
|
|
{
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
pEntry = pInfo->pArgs->pEntry;
|
|
ASSERT( pEntry );
|
|
|
|
// Save General page fields.
|
|
//
|
|
// ASSERT( pInfo->hwndGe );
|
|
// {
|
|
// DTLNODE* pNode;
|
|
|
|
// Retrieve the lone common control.
|
|
//
|
|
// pEntry->fShowMonitorIconInTaskBar =
|
|
// Button_GetCheck( pInfo->hwndCbShowIcon );
|
|
|
|
// if (pEntry->dwType == RASET_Phone)
|
|
// {
|
|
// DWORD dwCount;
|
|
|
|
// dwCount = GeSaveLvDeviceChecks( pInfo );
|
|
|
|
// Don't allow the user to deselect all of the
|
|
// devices
|
|
// if ( (pInfo->pArgs->fMultipleDevices) && (dwCount == 0) )
|
|
// {
|
|
// MsgDlg( hwndPage, SID_SelectDevice, NULL );
|
|
// PropSheet_SetCurSel ( pInfo->hwndDlg, pInfo->hwndGe, 0 );
|
|
// SetFocus ( pInfo->hwndLvDevices );
|
|
// return FALSE;
|
|
// }
|
|
|
|
// Save the "shared phone number" setting. As usual, single
|
|
// device mode implies shared mode, allowing things to fall
|
|
// through correctly.
|
|
//
|
|
// if (pInfo->pArgs->fMultipleDevices)
|
|
// {
|
|
// pEntry->fSharedPhoneNumbers =
|
|
// Button_GetCheck( pInfo->hwndCbSharedPhoneNumbers );
|
|
// }
|
|
// else
|
|
// {
|
|
// pEntry->fSharedPhoneNumbers = TRUE;
|
|
// }
|
|
|
|
// Set the phone number set for the first phone number of the
|
|
// current link (shared or selected) to the contents of the phone
|
|
// number controls.
|
|
//
|
|
// GeGetPhoneFields( pInfo, pInfo->pCurLinkNode );
|
|
|
|
// Swap lists, saving updates to caller's global list of area
|
|
// codes. Caller's original list will be destroyed by PeTerm.
|
|
//
|
|
// if (pInfo->pListAreaCodes)
|
|
// {
|
|
// DtlSwapLists(
|
|
// pInfo->pArgs->pUser->pdtllistAreaCodes,
|
|
// pInfo->pListAreaCodes );
|
|
// pInfo->pArgs->pUser->fDirty = TRUE;
|
|
// }
|
|
// }
|
|
// else if (pEntry->dwType == RASET_Vpn)
|
|
// {
|
|
// DTLNODE* pNode;
|
|
// PBLINK* pLink;
|
|
// PBPHONE* pPhone;
|
|
|
|
// Save host name, i.e. the VPN phone number.
|
|
//
|
|
// pNode = DtlGetFirstNode( pEntry->pdtllistLinks );
|
|
// ASSERT( pNode );
|
|
// pLink = (PBLINK* )DtlGetData( pNode );
|
|
// pNode = FirstPhoneNodeFromPhoneList( pLink->pdtllistPhones );
|
|
|
|
// if(NULL == pNode)
|
|
// {
|
|
// return FALSE;
|
|
// }
|
|
|
|
// pPhone = (PBPHONE* )DtlGetData( pNode );
|
|
// Free0( pPhone->pszPhoneNumber );
|
|
// pPhone->pszPhoneNumber = GetText( pInfo->hwndEbHostName );
|
|
// FirstPhoneNodeToPhoneList( pLink->pdtllistPhones, pNode );
|
|
|
|
// Any prequisite entry selection change has been saved already.
|
|
// Just need to toss it if disabled.
|
|
//
|
|
// if (!Button_GetCheck( pInfo->hwndCbDialAnotherFirst ))
|
|
// {
|
|
// Free0( pEntry->pszPrerequisiteEntry );
|
|
// pEntry->pszPrerequisiteEntry = NULL;
|
|
// Free0( pEntry->pszPrerequisitePbk );
|
|
// pEntry->pszPrerequisitePbk = NULL;
|
|
// }
|
|
// }
|
|
// else if (pEntry->dwType == RASET_Broadband)
|
|
// {
|
|
// DTLNODE* pNode;
|
|
// PBLINK* pLink;
|
|
// PBPHONE* pPhone;
|
|
|
|
// Save service name, i.e. the broadband phone number.
|
|
//
|
|
// pNode = DtlGetFirstNode( pEntry->pdtllistLinks );
|
|
// ASSERT( pNode );
|
|
// pLink = (PBLINK* )DtlGetData( pNode );
|
|
// pNode = FirstPhoneNodeFromPhoneList( pLink->pdtllistPhones );
|
|
|
|
// if(NULL == pNode)
|
|
// {
|
|
// return FALSE;
|
|
// }
|
|
|
|
// pPhone = (PBPHONE* )DtlGetData( pNode );
|
|
// Free0( pPhone->pszPhoneNumber );
|
|
// pPhone->pszPhoneNumber = GetText( pInfo->hwndEbBroadbandService );
|
|
// FirstPhoneNodeToPhoneList( pLink->pdtllistPhones, pNode );
|
|
// }
|
|
// else if (pEntry->dwType == RASET_Direct)
|
|
// {
|
|
// DTLNODE* pNode;
|
|
// PBLINK* pLink;
|
|
|
|
// The currently enabled device is the one
|
|
// that should be used for the connection. Only
|
|
// one device will be enabled (DnUpdateSelectedDevice).
|
|
// for (pNode = DtlGetFirstNode( pEntry->pdtllistLinks );
|
|
// pNode;
|
|
// pNode = DtlGetNextNode( pNode ))
|
|
// {
|
|
// pLink = (PBLINK* )DtlGetData( pNode );
|
|
// ASSERT(pLink);
|
|
|
|
// if ( pLink->fEnabled )
|
|
// break;
|
|
// }
|
|
|
|
// If we found a link successfully, deal with it
|
|
// now.
|
|
// if ( pLink && pLink->fEnabled ) {
|
|
// if (pLink->pbport.pbdevicetype == PBDT_ComPort)
|
|
// MdmInstallNullModem (pLink->pbport.pszPort);
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// Save Options page fields.
|
|
//
|
|
// if (pInfo->hwndOe)
|
|
// {
|
|
// UINT unValue;
|
|
// BOOL f;
|
|
// INT iSel;
|
|
|
|
// pEntry->fShowDialingProgress =
|
|
// Button_GetCheck( pInfo->hwndCbDisplayProgress );
|
|
|
|
// Note: The'fPreviewUserPw', 'fPreviewDomain' fields are updated as
|
|
// they are changed.
|
|
|
|
// pEntry->fPreviewPhoneNumber =
|
|
// Button_GetCheck( pInfo->hwndCbPreviewNumber );
|
|
|
|
// unValue = GetDlgItemInt(
|
|
// pInfo->hwndOe, CID_OE_EB_RedialAttempts, &f, FALSE );
|
|
// if (f && unValue <= 999999999)
|
|
// {
|
|
// pEntry->dwRedialAttempts = unValue;
|
|
// }
|
|
|
|
// iSel = ComboBox_GetCurSel( pInfo->hwndLbRedialTimes );
|
|
// pEntry->dwRedialSeconds =
|
|
// (DWORD )ComboBox_GetItemData( pInfo->hwndLbRedialTimes, iSel );
|
|
|
|
// iSel = ComboBox_GetCurSel( pInfo->hwndLbIdleTimes );
|
|
// pEntry->lIdleDisconnectSeconds =
|
|
// (LONG )ComboBox_GetItemData( pInfo->hwndLbIdleTimes, iSel );
|
|
|
|
// if (pInfo->pArgs->fRouter)
|
|
// {
|
|
// pEntry->fRedialOnLinkFailure =
|
|
// Button_GetCheck( pInfo->hwndRbPersistent );
|
|
// }
|
|
// else
|
|
// {
|
|
// pEntry->fRedialOnLinkFailure =
|
|
// Button_GetCheck( pInfo->hwndCbRedialOnDrop );
|
|
// }
|
|
|
|
// Note: dwDialMode is saved as changed.
|
|
// Note: X.25 settings are saved at OK on that dialog.
|
|
// }
|
|
|
|
// Save Security page fields.
|
|
//
|
|
// if (pInfo->hwndLo)
|
|
// {
|
|
// if (Button_GetCheck( pInfo->hwndRbTypicalSecurity ))
|
|
// {
|
|
// LoSaveTypicalAuthSettings( pInfo );
|
|
|
|
// if (pEntry->dwTypicalAuth == TA_CardOrCert)
|
|
// {
|
|
/*
|
|
// Toss any existing advanced EAP configuration remnants when
|
|
// typical smartcard, per bug 262702 and VBaliga email.
|
|
//
|
|
Free0( pEntry->pCustomAuthData );
|
|
pEntry->pCustomAuthData = NULL;
|
|
pEntry->cbCustomAuthData = 0;
|
|
|
|
*/
|
|
// (void) DwSetCustomAuthData(
|
|
// pEntry,
|
|
// 0,
|
|
// NULL);
|
|
|
|
// TRACE( "RasSetEapUserData" );
|
|
// ASSERT( g_pRasGetEntryDialParams );
|
|
// g_pRasSetEapUserData(
|
|
// INVALID_HANDLE_VALUE,
|
|
// pInfo->pArgs->pFile->pszPath,
|
|
// pEntry->pszEntryName,
|
|
// NULL,
|
|
// 0 );
|
|
// TRACE( "RasSetEapUserData done" );
|
|
// }
|
|
// }
|
|
|
|
// if (pEntry->dwType == RASET_Phone)
|
|
// {
|
|
// Free0( pEntry->pszScriptAfter );
|
|
// SuGetInfo( &pInfo->suinfo,
|
|
// &pEntry->fScriptAfter,
|
|
// &pEntry->fScriptAfterTerminal,
|
|
// &pEntry->pszScriptAfter );
|
|
// }
|
|
// }
|
|
|
|
// Save Network page fields.
|
|
// We won't have anything to do if we never initialized pNetCfg.
|
|
//
|
|
// if (pInfo->pNetCfg)
|
|
// {
|
|
// HRESULT hr;
|
|
|
|
// Update the phone book entry with the enabled state of the components.
|
|
// Do this by enumerating the components from the list view item data
|
|
// and consulting the check state for each.
|
|
//
|
|
// NeSaveBindingChanges(pInfo);
|
|
|
|
// hr = INetCfg_Apply (pInfo->pNetCfg);
|
|
// if (((NETCFG_S_REBOOT == hr) || (pInfo->fRebootAlreadyRequested)) &&
|
|
// pInfo->pNetConUtilities)
|
|
// {
|
|
// DWORD dwFlags = QUFR_REBOOT;
|
|
// if (!pInfo->fRebootAlreadyRequested)
|
|
// dwFlags |= QUFR_PROMPT;
|
|
|
|
//$TODO NULL caption?
|
|
// INetConnectionUiUtilities_QueryUserForReboot (
|
|
// pInfo->pNetConUtilities, pInfo->hwndDlg, NULL, dwFlags);
|
|
// }
|
|
// }
|
|
|
|
// Save Shared Access page fields
|
|
//
|
|
if (pInfo->hwndSa)
|
|
{
|
|
// record the (new) sharing and demand-dial settings
|
|
//
|
|
pInfo->pArgs->fNewShared =
|
|
Button_GetCheck( pInfo->hwndSaPbShared );
|
|
pInfo->pArgs->fNewDemandDial =
|
|
Button_GetCheck( pInfo->hwndSaPbDemandDial );
|
|
pInfo->pArgs->fNewBeaconControl =
|
|
Button_GetCheck( GetDlgItem(pInfo->hwndSa, CID_SA_PB_Beacon) );
|
|
|
|
// we only look at the private-lan drop list
|
|
// if the user just turned on sharing, since that's the only time
|
|
// we display the drop-list to begin with. we also need to look if
|
|
// we need to reset the private adapter
|
|
//
|
|
if ((pInfo->pArgs->fNewShared && !pInfo->pArgs->fShared)
|
|
|| pInfo->pArgs->fResetPrivateAdapter)
|
|
{
|
|
if (pInfo->pArgs->dwLanCount > 1)
|
|
{
|
|
INT item = ComboBox_GetCurSel( pInfo->hwndSaLbPrivateLan );
|
|
if (item != CB_ERR)
|
|
{
|
|
pInfo->pArgs->pPrivateLanConnection =
|
|
(IHNetConnection*)ComboBox_GetItemData(
|
|
pInfo->hwndSaLbPrivateLan, item );
|
|
}
|
|
}
|
|
else if (pInfo->pArgs->dwLanCount)
|
|
{
|
|
ASSERT(pInfo->pArgs->rgPrivateConns);
|
|
|
|
pInfo->pArgs->pPrivateLanConnection =
|
|
pInfo->pArgs->rgPrivateConns[0];
|
|
}
|
|
}
|
|
|
|
// Save Firewall fields
|
|
//
|
|
pInfo->pArgs->fNewFirewalled =
|
|
Button_GetCheck( pInfo->hwndSaPbFirewalled );
|
|
}
|
|
|
|
#if 0 //!!!
|
|
if ((fLocalPad || iPadSelection != 0)
|
|
&& (!pEntry->pszX25Address || IsAllWhite( pEntry->pszX25Address )))
|
|
{
|
|
// Address field is blank with X.25 dial-up or local PAD chosen.
|
|
//
|
|
MsgDlg( pInfo->hwndDlg, SID_NoX25Address, NULL );
|
|
PropSheet_SetCurSel( pInfo->hwndDlg, NULL, PE_XsPage );
|
|
SetFocus( pInfo->hwndEbX25Address );
|
|
Edit_SetSel( pInfo->hwndEbX25Address, 0, -1 );
|
|
return FALSE;
|
|
}
|
|
#endif
|
|
|
|
// Make sure proprietary ISDN options are disabled if more than one link
|
|
// is enabled. The proprietary ISDN option is only meaningful when
|
|
// calling a down-level server that needs Digiboard channel aggragation
|
|
// instead of PPP multi-link.
|
|
//
|
|
// {
|
|
// DTLNODE* pNode;
|
|
// DWORD cIsdnLinks;
|
|
|
|
// cIsdnLinks = 0;
|
|
// for (pNode = DtlGetFirstNode( pEntry->pdtllistLinks );
|
|
// pNode;
|
|
// pNode = DtlGetNextNode( pNode ))
|
|
// {
|
|
// PBLINK* pLink = (PBLINK* )DtlGetData( pNode );
|
|
// ASSERT(pLink);
|
|
|
|
// if (pLink->fEnabled && pLink->pbport.pbdevicetype == PBDT_Isdn)
|
|
// {
|
|
// ++cIsdnLinks;
|
|
// }
|
|
// }
|
|
|
|
// if (cIsdnLinks > 1)
|
|
// {
|
|
// for (pNode = DtlGetFirstNode( pEntry->pdtllistLinks );
|
|
// pNode;
|
|
// pNode = DtlGetNextNode( pNode ))
|
|
// {
|
|
// PBLINK* pLink = (PBLINK* )DtlGetData( pNode );
|
|
// ASSERT(pLink);
|
|
|
|
// if (pLink->fEnabled && pLink->fProprietaryIsdn)
|
|
// {
|
|
// pLink->fProprietaryIsdn = FALSE;
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// Inform user that edits to the connected entry won't take affect until
|
|
// the entry is hung up and re-dialed, per PierreS's insistence.
|
|
//
|
|
// if (HrasconnFromEntry( pInfo->pArgs->pFile->pszPath, pEntry->pszEntryName ))
|
|
// {
|
|
// MsgDlg( pInfo->hwndDlg, SID_EditConnected, NULL );
|
|
// }
|
|
|
|
// It's a valid new/changed entry. Commit the changes to the phonebook
|
|
// and preferences. This occurs immediately in "ShellOwned" mode where
|
|
// the RasEntryDlg API has already returned, but is otherwise deferred
|
|
// until the API is ready to return.
|
|
//
|
|
// if (pInfo->pArgs->pApiArgs->dwFlags & RASEDFLAG_ShellOwned)
|
|
// {
|
|
EuCommit( pInfo->pArgs );
|
|
// }
|
|
// else
|
|
// {
|
|
// pInfo->pArgs->fCommit = TRUE;
|
|
// }
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL EuCommit(IN EINFO* pInfo )
|
|
{
|
|
// Commits the new or changed entry node to the phonebook file and list.
|
|
// Also adds the area code to the per-user list, if indicated. 'PInfo' is
|
|
// the common entry information block.
|
|
//
|
|
// Returns true if successful, false otherwise.
|
|
//
|
|
DWORD dwErr;
|
|
// BOOL fEditMode;
|
|
// BOOL fChangedNameInEditMode;
|
|
|
|
// If shared phone number, copy the phone number information from the
|
|
// shared link to each enabled link.
|
|
//
|
|
// if (pInfo->pEntry->fSharedPhoneNumbers)
|
|
// {
|
|
// DTLNODE* pNode;
|
|
|
|
// ASSERT( pInfo->pEntry->dwType == RASET_Phone );
|
|
|
|
// for (pNode = DtlGetFirstNode( pInfo->pEntry->pdtllistLinks );
|
|
// pNode;
|
|
// pNode = DtlGetNextNode( pNode ))
|
|
// {
|
|
// PBLINK* pLink = (PBLINK* )DtlGetData( pNode );
|
|
// ASSERT(pLink);
|
|
|
|
// if (pLink->fEnabled)
|
|
// {
|
|
// CopyLinkPhoneNumberInfo( pNode, pInfo->pSharedNode );
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// Delete all disabled link nodes.
|
|
//
|
|
// if (pInfo->fMultipleDevices)
|
|
// {
|
|
// DTLNODE* pNode;
|
|
|
|
// pNode = DtlGetFirstNode( pInfo->pEntry->pdtllistLinks );
|
|
// while (pNode)
|
|
// {
|
|
// PBLINK* pLink = (PBLINK* )DtlGetData( pNode );
|
|
// DTLNODE* pNextNode = DtlGetNextNode( pNode );
|
|
|
|
// if (!pLink->fEnabled)
|
|
// {
|
|
// DtlRemoveNode( pInfo->pEntry->pdtllistLinks, pNode );
|
|
// DestroyLinkNode( pNode );
|
|
// }
|
|
|
|
// pNode = pNextNode;
|
|
// }
|
|
// }
|
|
|
|
// pmay: 277801
|
|
//
|
|
// Update the preferred device if the one selected is different
|
|
// from the device this page was initialized with.
|
|
//
|
|
// if ((pInfo->fMultipleDevices) &&
|
|
// (DtlGetNodes(pInfo->pEntry->pdtllistLinks) == 1))
|
|
// {
|
|
// DTLNODE* pNodeL;
|
|
// PBLINK* pLink;
|
|
// BOOL bUpdatePref = FALSE;
|
|
|
|
// pNodeL = DtlGetFirstNode( pInfo->pEntry->pdtllistLinks );
|
|
// pLink = (PBLINK*) DtlGetData( pNodeL );
|
|
|
|
// TRACE( "Mult devs, only one selected -- check preferred dev." );
|
|
|
|
// if ((pInfo->pszCurDevice == NULL) || (pInfo->pszCurPort == NULL))
|
|
// {
|
|
// TRACE( "No preferred device. Resetting preferred to current." );
|
|
// bUpdatePref = TRUE;
|
|
// }
|
|
// else if (
|
|
// (lstrcmpi(pInfo->pszCurDevice, pLink->pbport.pszDevice)) ||
|
|
// (lstrcmpi(pInfo->pszCurPort, pLink->pbport.pszPort)))
|
|
// {
|
|
// TRACE( "New device selected as preferred device" );
|
|
// bUpdatePref = TRUE;
|
|
// }
|
|
// if (bUpdatePref)
|
|
// {
|
|
// Free0(pInfo->pEntry->pszPreferredDevice);
|
|
// Free0(pInfo->pEntry->pszPreferredPort);
|
|
|
|
// pInfo->pEntry->pszPreferredDevice =
|
|
// StrDup(pLink->pbport.pszDevice);
|
|
// pInfo->pEntry->pszPreferredPort =
|
|
// StrDup(pLink->pbport.pszPort);
|
|
// }
|
|
// }
|
|
|
|
// Save preferences if they've changed.
|
|
//
|
|
// if (pInfo->pUser->fDirty)
|
|
// {
|
|
// INTERNALARGS *pIArgs = (INTERNALARGS *)pInfo->pApiArgs->reserved;
|
|
|
|
// if (g_pSetUserPreferences(
|
|
// (pIArgs) ? pIArgs->hConnection : NULL,
|
|
// pInfo->pUser,
|
|
// (pInfo->fRouter) ? UPM_Router : UPM_Normal ) != 0)
|
|
// {
|
|
// return FALSE;
|
|
// }
|
|
// }
|
|
|
|
// Save the changed phonebook entry.
|
|
//
|
|
// pInfo->pEntry->fDirty = TRUE;
|
|
|
|
// The final name of the entry is output to caller via API structure.
|
|
//
|
|
// lstrcpyn(
|
|
// pInfo->pApiArgs->szEntry,
|
|
// pInfo->pEntry->pszEntryName,
|
|
// RAS_MaxEntryName + 1);
|
|
|
|
// Delete the old node if in edit mode, then add the new node.
|
|
//
|
|
// EuGetEditFlags( pInfo, &fEditMode, &fChangedNameInEditMode );
|
|
|
|
// if (fEditMode)
|
|
// {
|
|
// DtlDeleteNode( pInfo->pFile->pdtllistEntries, pInfo->pOldNode );
|
|
// }
|
|
|
|
// DtlAddNodeLast( pInfo->pFile->pdtllistEntries, pInfo->pNode );
|
|
// pInfo->pNode = NULL;
|
|
|
|
// Write the change to the phone book file.
|
|
//
|
|
// dwErr = WritePhonebookFile( pInfo->pFile,
|
|
// (fChangedNameInEditMode) ? pInfo->szOldEntryName : NULL );
|
|
|
|
// if (dwErr != 0)
|
|
// {
|
|
// ErrorDlg( pInfo->pApiArgs->hwndOwner, SID_OP_WritePhonebook, dwErr,
|
|
// NULL );
|
|
// // shaunco - fix RAID 171651 by assigning dwErr to callers structure.
|
|
// pInfo->pApiArgs->dwError = dwErr;
|
|
// return FALSE;
|
|
// }
|
|
|
|
// Notify through rasman that the entry has changed
|
|
//
|
|
// if(pInfo->pApiArgs->dwFlags & (RASEDFLAG_AnyNewEntry | RASEDFLAG_CloneEntry))
|
|
// {
|
|
// dwErr = DwSendRasNotification(
|
|
// ENTRY_ADDED,
|
|
// pInfo->pEntry,
|
|
// pInfo->pFile->pszPath);
|
|
// }
|
|
// else
|
|
// {
|
|
// dwErr = DwSendRasNotification(
|
|
// ENTRY_MODIFIED,
|
|
// pInfo->pEntry,
|
|
// pInfo->pFile->pszPath);
|
|
|
|
// }
|
|
|
|
// Ignore the error returned from DwSendRasNotification - we don't want
|
|
// to fail the operation in this case. The worst case scenario is that
|
|
// the connections folder won't refresh automatically.
|
|
//
|
|
// dwErr = ERROR_SUCCESS;
|
|
|
|
// If EuCommit is being called as a result of completing the "new demand
|
|
// dial interface" wizard, then we need to create the new demand dial
|
|
// interface now.
|
|
//
|
|
// if ( EuRouterInterfaceIsNew( pInfo ) )
|
|
// {
|
|
//Create Router MPR interface and save user credentials
|
|
//like UserName, Domain and Password
|
|
//IPSec credentials are save in EuCredentialsCommitRouterIPSec
|
|
//
|
|
|
|
// dwErr = EuRouterInterfaceCreate( pInfo );
|
|
|
|
// If we weren't successful at commiting the interface's
|
|
// credentials, then delete the new phonebook entry.
|
|
//
|
|
// if ( dwErr != NO_ERROR )
|
|
// {
|
|
// WritePhonebookFile( pInfo->pFile, pInfo->pApiArgs->szEntry );
|
|
// pInfo->pApiArgs->dwError = dwErr;
|
|
// return FALSE;
|
|
// }
|
|
|
|
// }
|
|
|
|
// Now save any per-connection credentials
|
|
//
|
|
// dwErr = EuCredentialsCommit( pInfo );
|
|
|
|
// If we weren't successful at commiting the interface's
|
|
// credentials, then delete the new phonebook entry.
|
|
//
|
|
// if ( dwErr != NO_ERROR )
|
|
// {
|
|
// ErrorDlg( pInfo->pApiArgs->hwndOwner,
|
|
// SID_OP_CredCommit,
|
|
// dwErr,
|
|
// NULL );
|
|
|
|
// pInfo->pApiArgs->dwError = dwErr;
|
|
|
|
// return FALSE;
|
|
// }
|
|
|
|
// Save the default Internet connection settings as appropriate. Igonre
|
|
// the error returned as failure to set the connection as default need
|
|
// not prevent the connection/interface creation.
|
|
//
|
|
// dwErr = EuInternetSettingsCommitDefault( pInfo );
|
|
// dwErr = NO_ERROR;
|
|
|
|
// If the user edited/created a router-phonebook entry, store the bitmask
|
|
// of selected network-protocols in 'reserved2'.
|
|
//
|
|
// if (pInfo->fRouter)
|
|
// {
|
|
// pInfo->pApiArgs->reserved2 =
|
|
// ((NP_Ip | NP_Ipx) & ~pInfo->pEntry->dwfExcludedProtocols);
|
|
// }
|
|
|
|
// Commit the user's changes to home networking settings.
|
|
// Ignore the return value.
|
|
//
|
|
dwErr = EuHomenetCommitSettings(pInfo);
|
|
dwErr = NO_ERROR;
|
|
|
|
// pInfo->pApiArgs->dwError = 0;
|
|
return TRUE;
|
|
}
|
|
|
|
DWORD EuHomenetCommitSettings(IN EINFO* pInfo)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG ulcPublic;
|
|
ULONG ulcPrivate;
|
|
BOOL fPrivateConfigured = FALSE;
|
|
HNET_CONN_PROPERTIES *pProps;
|
|
DWORD dwErr = NO_ERROR;
|
|
BOOL fConflictMessageDisplayed = FALSE;
|
|
|
|
|
|
if (pInfo->fRouter)
|
|
{
|
|
return NO_ERROR;
|
|
}
|
|
|
|
if (!!pInfo->fShared != !!pInfo->fNewShared)
|
|
{
|
|
if (pInfo->fShared)
|
|
{
|
|
hr = pInfo->pIcsSettings->DisableIcs (&ulcPublic, &ulcPrivate);
|
|
}
|
|
else
|
|
{
|
|
// Check to see if the private connection is
|
|
// already properly configured
|
|
//
|
|
|
|
hr = pInfo->pPrivateLanConnection->GetProperties (&pProps);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
fPrivateConfigured = !!pProps->fIcsPrivate;
|
|
CoTaskMemFree(pProps);
|
|
}
|
|
|
|
if (pInfo->fOtherShared)
|
|
{
|
|
if (fPrivateConfigured)
|
|
{
|
|
// Using the same private connection, so
|
|
// only modify the old public
|
|
//
|
|
|
|
ASSERT(NULL != pInfo->pOldSharedConnection);
|
|
hr = pInfo->pOldSharedConnection->Unshare();
|
|
}
|
|
else
|
|
{
|
|
hr = pInfo->pIcsSettings->DisableIcs (&ulcPublic, &ulcPrivate);
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IHNetIcsPublicConnection *pIcsPublic;
|
|
IHNetIcsPrivateConnection *pIcsPrivate;
|
|
|
|
hr = pInfo->pHNetConn->SharePublic (&pIcsPublic);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (!fPrivateConfigured)
|
|
{
|
|
hr = pInfo->pPrivateLanConnection->SharePrivate (&pIcsPrivate);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pIcsPrivate->Release();
|
|
}
|
|
else
|
|
{
|
|
pIcsPublic->Unshare();
|
|
}
|
|
}
|
|
pIcsPublic->Release();
|
|
}
|
|
}
|
|
|
|
if (hr == HRESULT_FROM_WIN32(ERROR_SHARING_RRAS_CONFLICT))
|
|
{
|
|
fConflictMessageDisplayed = TRUE;
|
|
MsgDlg(pInfo->hwndOwner, SID_SharingConflict, NULL);
|
|
}
|
|
else if (FAILED(hr))
|
|
{
|
|
if (FACILITY_WIN32 == HRESULT_FACILITY(hr))
|
|
{
|
|
dwErr = HRESULT_CODE(hr);
|
|
}
|
|
else
|
|
{
|
|
dwErr = (DWORD) hr;
|
|
}
|
|
|
|
ErrorDlg(
|
|
pInfo->hwndOwner,
|
|
pInfo->fShared
|
|
? SID_OP_UnshareConnection : SID_OP_ShareConnection,
|
|
dwErr, NULL );
|
|
}
|
|
}
|
|
}
|
|
else if (pInfo->fResetPrivateAdapter && pInfo->dwLanCount)
|
|
{
|
|
|
|
IHNetIcsPrivateConnection *pIcsPrivateConnection;
|
|
hr = pInfo->pPrivateLanConnection->SharePrivate(&pIcsPrivateConnection);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pIcsPrivateConnection->Release();
|
|
}
|
|
else
|
|
{
|
|
ULONG ulPublicCount, ulPrivateCount;
|
|
HRESULT hr2 = pInfo->pIcsSettings->DisableIcs(&ulPublicCount, &ulPrivateCount);
|
|
if (SUCCEEDED(hr2))
|
|
{
|
|
pInfo->fShared = FALSE;
|
|
}
|
|
|
|
ErrorDlg(pInfo->hwndOwner, SID_OP_ShareConnection, hr, NULL );
|
|
}
|
|
}
|
|
|
|
if (!!pInfo->fDemandDial != !!pInfo->fNewDemandDial)
|
|
{
|
|
dwErr = RasSetSharedAutoDial(pInfo->fNewDemandDial);
|
|
if (dwErr)
|
|
{
|
|
ErrorDlg(
|
|
pInfo->hwndOwner,
|
|
pInfo->fDemandDial
|
|
? SID_OP_DisableDemandDial : SID_OP_EnableDemandDial,
|
|
dwErr, NULL );
|
|
}
|
|
}
|
|
|
|
HKEY hKey;
|
|
if(ERROR_SUCCESS == RegCreateKeyEx(HKEY_LOCAL_MACHINE, REGKEY_SHAREDACCESSCLIENTKEYPATH, 0, NULL, 0, KEY_SET_VALUE, NULL, &hKey, NULL))
|
|
{
|
|
DWORD dwData = pInfo->fNewBeaconControl;
|
|
RegSetValueEx(hKey, REGVAL_SHAREDACCESSCLIENTENABLECONTROL, 0, REG_DWORD, reinterpret_cast<LPBYTE>(&dwData), sizeof(dwData));
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
// Commit changes to firewall settings
|
|
//
|
|
if (!!pInfo->fFirewalled != !!pInfo->fNewFirewalled)
|
|
{
|
|
IHNetFirewalledConnection *pFwConn;
|
|
|
|
if (pInfo->fNewFirewalled)
|
|
{
|
|
hr = pInfo->pHNetConn->Firewall (&pFwConn);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pFwConn->Release();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = pInfo->pHNetConn->GetControlInterface (
|
|
IID_IHNetFirewalledConnection,
|
|
(void**)&pFwConn);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pFwConn->Unfirewall();
|
|
pFwConn->Release();
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
if (FACILITY_WIN32 == HRESULT_FACILITY(hr))
|
|
{
|
|
dwErr = HRESULT_CODE(hr);
|
|
}
|
|
else
|
|
{
|
|
dwErr = (DWORD) hr;
|
|
}
|
|
|
|
if (dwErr != ERROR_SHARING_RRAS_CONFLICT)
|
|
{
|
|
ErrorDlg(
|
|
pInfo->hwndOwner,
|
|
pInfo->fFirewalled
|
|
? SID_OP_UnshareConnection : SID_OP_ShareConnection,
|
|
dwErr, NULL );
|
|
}
|
|
else if (FALSE == fConflictMessageDisplayed)
|
|
{
|
|
MsgDlg(pInfo->hwndOwner, SID_SharingConflict, NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
HRESULT APIENTRY
|
|
HrCreateNetConnectionUtilities(INetConnectionUiUtilities ** ppncuu)
|
|
{
|
|
HRESULT hr;
|
|
|
|
hr = CoCreateInstance (CLSID_NetConnectionUiUtilities, NULL,
|
|
CLSCTX_INPROC_SERVER,
|
|
IID_INetConnectionUiUtilities, (void**)ppncuu);
|
|
return hr;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// exported function here
|
|
// --------------------------------------------------------------------------
|
|
|
|
static LPDLGTEMPLATE CopyDialogTemplate (HINSTANCE hinst, LPCWSTR wszResource)
|
|
{
|
|
LPDLGTEMPLATE lpdtCopy = NULL;
|
|
|
|
HRSRC hrsrc = FindResourceW (hinst, wszResource, (LPCWSTR)RT_DIALOG);
|
|
if (hrsrc) {
|
|
HGLOBAL hg = LoadResource (hinst, hrsrc);
|
|
if (hg) {
|
|
LPDLGTEMPLATE lpdt = (LPDLGTEMPLATE) LockResource (hg);
|
|
if (lpdt) {
|
|
DWORD dwSize = SizeofResource (hinst, hrsrc);
|
|
if (dwSize) {
|
|
lpdtCopy = (LPDLGTEMPLATE)Malloc (dwSize);
|
|
if (lpdtCopy) {
|
|
CopyMemory (lpdtCopy, lpdt, dwSize);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return lpdtCopy;
|
|
}
|
|
|
|
void SetSAUIhInstance (HINSTANCE hInstance)
|
|
{
|
|
_ASSERT (g_hinstDll == NULL);
|
|
_ASSERT (hInstance != NULL);
|
|
g_hinstDll = hInstance;
|
|
}
|
|
|
|
extern "C" HRESULT HNetGetFirewallSettingsPage (PROPSHEETPAGEW * pPSP, GUID * pGuid)
|
|
{
|
|
// zeroth thing: the PROPSHEETPAGEW struct is different sizes depending
|
|
// on what version of _WIN32_IE and _WIN32_WINNT are set to. So, check
|
|
// the dwSize field
|
|
if (IsBadWritePtr (pPSP, sizeof(DWORD)))
|
|
return E_POINTER;
|
|
if (IsBadWritePtr (pPSP, pPSP->dwSize))
|
|
return HRESULT_FROM_WIN32 (ERROR_INVALID_SIZE);
|
|
if (pPSP->dwSize < RTL_SIZEOF_THROUGH_FIELD (PROPSHEETPAGEW, lParam))
|
|
return HRESULT_FROM_WIN32 (ERROR_INVALID_SIZE);
|
|
|
|
// first thing: check rights
|
|
if (FALSE == FIsUserAdminOrPowerUser ())
|
|
return HRESULT_FROM_WIN32 (ERROR_ACCESS_DENIED);
|
|
{
|
|
// Check if ZAW is denying access to the Shared Access UI
|
|
BOOL fShowAdvancedUi = TRUE;
|
|
INetConnectionUiUtilities* pncuu = NULL;
|
|
HrCreateNetConnectionUtilities(&pncuu);
|
|
if (pncuu)
|
|
{
|
|
if ((FALSE == pncuu->UserHasPermission (NCPERM_ShowSharedAccessUi)) &&
|
|
(FALSE == pncuu->UserHasPermission (NCPERM_PersonalFirewallConfig)))
|
|
fShowAdvancedUi = FALSE;
|
|
pncuu->Release();
|
|
}
|
|
if (FALSE == fShowAdvancedUi)
|
|
return HRESULT_FROM_WIN32 (ERROR_ACCESS_DENIED);
|
|
}
|
|
|
|
// setup global(s)
|
|
g_contextId = (LPCTSTR)GlobalAddAtom (TEXT("SAUI"));
|
|
if (!g_contextId)
|
|
return GetLastError();
|
|
|
|
PEINFO * pPEINFO = NULL;
|
|
DWORD dwError = PeInit (pGuid, &pPEINFO);
|
|
if (dwError == S_OK) {
|
|
// we need this to init the link
|
|
LinkWindow_RegisterClass(); // no need to ever unregister: see ...\shell\shell32\linkwnd.cpp
|
|
|
|
// fill out PSP:
|
|
DWORD dwSize;
|
|
ZeroMemory (pPSP, dwSize = pPSP->dwSize);
|
|
pPSP->dwSize = dwSize;
|
|
pPSP->dwFlags = 0;
|
|
LPDLGTEMPLATE lpdt = CopyDialogTemplate (g_hinstDll, MAKEINTRESOURCE (PID_SA_Advanced));
|
|
if (lpdt) {
|
|
// avoid idd collisions
|
|
pPSP->dwFlags |= PSP_DLGINDIRECT;
|
|
pPSP->pResource = lpdt;
|
|
pPEINFO->lpdt = lpdt; // hang it here so I can free it
|
|
} else // if all else fails... (this should never happen).
|
|
pPSP->pszTemplate = MAKEINTRESOURCE (PID_SA_Advanced);
|
|
pPSP->hInstance = g_hinstDll;
|
|
pPSP->pfnDlgProc = SaDlgProc;
|
|
pPSP->lParam = (LPARAM)pPEINFO;
|
|
}
|
|
return dwError;
|
|
}
|
|
|
|
//
|
|
// Figure out if this is a single user connection. If it is, then we need
|
|
// to give them an error that explains that they should be using an all user
|
|
// connection instead.
|
|
// If this is an All-User connection, warn them if they don't have global credentials
|
|
//
|
|
VOID VerifyConnTypeAndCreds(IN PEINFO* pInfo)
|
|
{
|
|
if (NULL == pInfo)
|
|
{
|
|
return;
|
|
}
|
|
|
|
BOOL fAllUser = FALSE;
|
|
TCHAR szAppData[MAX_PATH+1]={0};
|
|
|
|
HINSTANCE hinstDll = LoadLibrary (TEXT("shfolder.dll"));;
|
|
|
|
if (hinstDll)
|
|
{
|
|
typedef HRESULT (*pfnGetFolderPathFunction) (HWND, int, HANDLE, DWORD, LPTSTR);
|
|
#ifdef UNICODE
|
|
pfnGetFolderPathFunction pfnGetFolderPath = (pfnGetFolderPathFunction)GetProcAddress (hinstDll, "SHGetFolderPathW");
|
|
#else
|
|
pfnGetFolderPathFunction pfnGetFolderPath = (pfnGetFolderPathFunction)GetProcAddress (hinstDll, "SHGetFolderPathA");
|
|
#endif
|
|
|
|
if (pfnGetFolderPath && pInfo->pArgs->pEntry->pszEntryName)
|
|
{
|
|
HRESULT hr = pfnGetFolderPath(pInfo->hwndDlg , CSIDL_COMMON_APPDATA, NULL, 0, szAppData);
|
|
|
|
if (SUCCEEDED(hr) && (S_FALSE != hr))
|
|
{
|
|
//
|
|
// Okay, now we have the path to the common application data directory.
|
|
// Let's compare that against the phonebook path that we have and see
|
|
// if this is an all user connection or not.
|
|
//
|
|
const TCHAR* const c_pszRelativePbkPath = TEXT("\\Microsoft\\Network\\Connections\\Pbk");
|
|
DWORD dwSize = (lstrlen(szAppData) + lstrlen(c_pszRelativePbkPath) + 1) * sizeof(TCHAR);
|
|
LPTSTR pszAllUserPhoneBookDir = (LPTSTR)Malloc(dwSize);
|
|
|
|
if (pszAllUserPhoneBookDir)
|
|
{
|
|
wsprintf(pszAllUserPhoneBookDir, TEXT("%s%s"), szAppData, c_pszRelativePbkPath);
|
|
|
|
//
|
|
// Compare
|
|
//
|
|
if (pInfo->pArgs->pEntry->pszPhonebookPath)
|
|
{
|
|
LPTSTR pszAllUser = _tcsstr(pInfo->pArgs->pEntry->pszPhonebookPath, pszAllUserPhoneBookDir);
|
|
|
|
if (pszAllUser)
|
|
{
|
|
fAllUser = TRUE;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// If the phonebook path wasn't based on the common app data dir, check to see
|
|
// if it was based on the old ras phonebook location %windir%\system32\ras.
|
|
//
|
|
HRESULT hr2 = pfnGetFolderPath(pInfo->hwndDlg , CSIDL_SYSTEM, NULL, 0, szAppData);
|
|
if (SUCCEEDED(hr2) && (S_FALSE != hr2))
|
|
{
|
|
const TCHAR* const c_pszRas = TEXT("\\Ras");
|
|
DWORD dwSize2 = (lstrlen(szAppData) + lstrlen(c_pszRas) + 1) * sizeof(TCHAR);
|
|
LPTSTR pszOldRasPhoneBook = (LPTSTR)Malloc(dwSize2);
|
|
|
|
if (pszOldRasPhoneBook)
|
|
{
|
|
wsprintf(pszOldRasPhoneBook, TEXT("%s%s"), szAppData, c_pszRas);
|
|
|
|
pszAllUser = _tcsstr(pInfo->pArgs->pEntry->pszPhonebookPath, pszOldRasPhoneBook);
|
|
|
|
if (pszAllUser)
|
|
{
|
|
fAllUser = TRUE;
|
|
}
|
|
}
|
|
Free0(pszOldRasPhoneBook);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Phone book string is null - using default RAS phonebook which is for all users
|
|
//
|
|
fAllUser = TRUE;
|
|
}
|
|
|
|
//
|
|
// Finally check if we have the proper credentials for an all user profile. If not then
|
|
// prompt user to create and save global credentials (option A).
|
|
// or display a message that an all-user profile is needed (option B)
|
|
//
|
|
if (fAllUser)
|
|
{
|
|
//
|
|
// Check if we have global passwords
|
|
//
|
|
BOOL fUserCreds = FALSE;
|
|
BOOL fGlobalCreds = FALSE;
|
|
|
|
FindEntryCredentials(pInfo->pArgs->pEntry->pszPhonebookPath,
|
|
pInfo->pArgs->pEntry->pszEntryName,
|
|
&fUserCreds,
|
|
&fGlobalCreds);
|
|
|
|
if (FALSE == fGlobalCreds)
|
|
{
|
|
//
|
|
// need to display warning message (A) - should have global creds
|
|
//
|
|
MSGARGS msgargs;
|
|
ZeroMemory( &msgargs, sizeof(msgargs) );
|
|
msgargs.dwFlags = MB_OK | MB_ICONINFORMATION;
|
|
MsgDlg( pInfo->hwndDlg, IDS_ALL_USER_CONN_MUST_HAVE_GLOBAL_CREDS, &msgargs );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// need to display warning message (B) - should create an all-user connection
|
|
//
|
|
MSGARGS msgargs;
|
|
ZeroMemory( &msgargs, sizeof(msgargs) );
|
|
msgargs.dwFlags = MB_OK | MB_ICONINFORMATION;
|
|
MsgDlg( pInfo->hwndDlg, IDS_PER_USER_CONN_NEED_TO_CREATE_ALL_USER_CONN, &msgargs );
|
|
}
|
|
}
|
|
Free0(pszAllUserPhoneBookDir);
|
|
}
|
|
}
|
|
|
|
FreeLibrary(hinstDll);
|
|
}
|
|
}
|
|
|
|
//
|
|
// All of this function is taken from RAS - rasdlg - dial.c
|
|
// with some parts removed since we didn't need them here.
|
|
//
|
|
DWORD
|
|
FindEntryCredentials(
|
|
IN TCHAR* pszPath,
|
|
IN TCHAR* pszEntryName,
|
|
OUT BOOL* pfUser, // set true if per user creds found
|
|
OUT BOOL* pfGlobal // set true if global creds found
|
|
)
|
|
|
|
// Loads the credentials for the given entry into memory. This routine
|
|
// determines whether per-user or per-connection credentials exist or
|
|
// both.
|
|
//
|
|
// The logic is a little complicated because RasGetCredentials had to
|
|
// support legacy usage of the API.
|
|
//
|
|
// Here's how it works. If only one set of credentials is stored for a
|
|
// connection, then RasGetCredentials will return that set regardless of
|
|
// whether the RASCM_DefalutCreds flag is set. If two sets of credentials
|
|
// are saved, then RasGetCredentials will return the per-user credentials
|
|
// if the RASCM_DefaultCreds bit is set, and the per-connection credentials
|
|
// otherwise.
|
|
//
|
|
// Here is the algorithm for loading the credentials
|
|
//
|
|
// 1. Call RasGetCredentials with the RASCM_DefaultCreds bit cleared
|
|
// 1a. If nothing is returned, no credentials are saved
|
|
// 1b. If the RASCM_DefaultCreds bit is set on return, then only
|
|
// global credentials are saved.
|
|
//
|
|
// 2. Call RasGetCredentials with the RASCM_DefaultCreds bit set
|
|
// 2a. If the RASCM_DefaultCreds bit is set on return, then
|
|
// both global and per-connection credentials are saved.
|
|
// 2b. Otherwise, only per-user credentials are saved.
|
|
//
|
|
{
|
|
DWORD dwErr;
|
|
RASCREDENTIALS rc1, rc2;
|
|
BOOL fUseLogonDomain;
|
|
|
|
TRACE( "saui.cpp - FindEntryCredentials" );
|
|
|
|
// Initialize
|
|
//
|
|
*pfUser = FALSE;
|
|
*pfGlobal = FALSE;
|
|
ZeroMemory( &rc1, sizeof(rc1) );
|
|
ZeroMemory( &rc2, sizeof(rc2) );
|
|
rc1.dwSize = sizeof(rc1);
|
|
rc2.dwSize = sizeof(rc2);
|
|
|
|
if (NULL == pszPath || NULL == pszEntryName)
|
|
{
|
|
return (DWORD)-1;
|
|
}
|
|
|
|
do
|
|
{
|
|
// Look up per-user cached username, password, and domain.
|
|
// See comment '1.' in the function header
|
|
//
|
|
rc1.dwMask = RASCM_UserName | RASCM_Password | RASCM_Domain;
|
|
TRACE( "RasGetCredentials per-user" );
|
|
dwErr = RasGetCredentials(pszPath, pszEntryName, &rc1 );
|
|
TRACE2( "RasGetCredentials=%d,m=%d", dwErr, rc1.dwMask );
|
|
if (dwErr != NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
|
|
// See 1a. in the function header comments
|
|
//
|
|
if (rc1.dwMask == 0)
|
|
{
|
|
dwErr = NO_ERROR;
|
|
break;
|
|
}
|
|
|
|
// See 1b. in the function header comments
|
|
//
|
|
else if (rc1.dwMask & RASCM_DefaultCreds)
|
|
{
|
|
*pfGlobal = TRUE;
|
|
dwErr = NO_ERROR;
|
|
break;
|
|
}
|
|
|
|
// Look up global per-user cached username, password, domain.
|
|
// See comment 2. in the function header
|
|
//
|
|
rc2.dwMask =
|
|
RASCM_UserName | RASCM_Password | RASCM_Domain | RASCM_DefaultCreds;
|
|
|
|
TRACE( "RasGetCredentials global" );
|
|
|
|
dwErr = RasGetCredentials(pszPath, pszEntryName, &rc2 );
|
|
|
|
TRACE2( "RasGetCredentials=%d,m=%d", dwErr, rc2.dwMask );
|
|
if (dwErr != NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
|
|
// See 2a. in the function header comments
|
|
//
|
|
if (rc2.dwMask & RASCM_DefaultCreds)
|
|
{
|
|
*pfGlobal = TRUE;
|
|
|
|
if (rc1.dwMask & RASCM_Password)
|
|
{
|
|
*pfUser = TRUE;
|
|
}
|
|
}
|
|
|
|
// See 2b. in the function header comments
|
|
//
|
|
else
|
|
{
|
|
if (rc1.dwMask & RASCM_Password)
|
|
{
|
|
*pfUser = TRUE;
|
|
}
|
|
}
|
|
|
|
}while (FALSE);
|
|
|
|
// Cleanup
|
|
//
|
|
SecureZeroMemory( rc1.szPassword, sizeof(rc1.szPassword) );
|
|
SecureZeroMemory( rc2.szPassword, sizeof(rc2.szPassword) );
|
|
|
|
return dwErr;
|
|
}
|