//+---------------------------------------------------------------------------- // // File: icm.h // // Module: CMDIAL32.DLL // // Synopsis: Main header file for cmdial32.dll // // Copyright (c) 1998-1999 Microsoft Corporation // // Author: nickball Created 02/10/98 // //+---------------------------------------------------------------------------- #ifndef _ICM_INC #define _ICM_INC #include #include #include #include #include #include #include #include #include #include #include #include // #undef WINVER // #define WINVER 0x0401 #include #include #include #include #include #include #include #include #include // for LSA stuff #include "cmglobal.h" #include "cm_def.h" #include "reg_str.h" #include "cmmgr32.h" // help IDs #include "cm_phbk.h" #include "cmdial.h" #include "cmutil.h" #include "cm_misc.h" #include "cmlog.h" #include "state.h" #include "cmsecure.h" #include "cmdebug.h" #include "contable.h" #include "ary.hxx" #include "ctr.h" #include "resource.h" #include "cmfmtstr.h" #include "base_str.h" #include "mgr_str.h" #include "ShellDll.h" #include "mutex.h" #include "cmras.h" #include "userinfo.h" #include "lanawait.h" #include "linkdll.h" // LinkToDll and BindLinkage #include "uapi.h" #include "bmpimage.h" // Common bitmap processing code #include "pwutil.h" #include "stp_str.h" #include "dial_str.h" #include "mon_str.h" #include "tooltip.h" #include "gppswithalloc.h" #include "hnetcfg.h" #include "netconp.h" #if DEBUG && defined(CMASSERTMSG) #define CELEMS(x) ( \ CMASSERTMSG(sizeof(x) != sizeof(void*), TEXT("possible incorrect usage of CELEMS")), \ (sizeof(x))/(sizeof(x[0])) \ ) #else #define CELEMS(x) ((sizeof(x))/(sizeof(x[0]))) #endif // DEBUG // we haven't done the strsafe pass for the entire XPSP codebase - make sure we can still build #define STRSAFE_NO_DEPRECATE #include //************************************************************************ // define's //************************************************************************ #define TIMER_RATE 1000 // 1 second #define PAUSE_DELAY 3 #define PWHANDLE_NONE 0 #define PWHANDLE_LOWER 1 #define PWHANDLE_UPPER 2 #define CE_PASSWORD_NOT_PRESENT 1223 #define CUSTOM_BUTTON_WIDTH 88 //#define DEFAULT_MAX_DOMAIN_LENGTH 256 // // User defined msg for telling CM itself to start loading startup info // #define WM_LOADSTARTUPINFO (WM_USER + 6) // // Delayed hangup of CM for W9x // wParam indicates if entry should be removed from table. // lParam is the RAS error code for hangup or ERROR_CANCELLED (currently unused) #define WM_HANGUP_CM (WM_USER + 7) // // Connected CM - CM is connected, do connect processing // #define WM_CONNECTED_CM (WM_USER + 8) // // Pause RasDial - Resume dialing after pause state. // #define WM_PAUSE_RASDIAL (WM_USER + 9) // Duration message flags #define DMF_NUL 0x0000 #define DMF_H 0x0001 // Hours #define DMF_M 0x0002 // Minutes #define DMF_S 0x0004 // Seconds #define DMF_HM 0x0003 // Hours, Minutes #define DMF_HS 0x0005 // Hours, Seconds #define DMF_MS 0x0006 // Minutes, Seconds #define DMF_HMS 0x0007 // Hours, Minutes, Seconds // for NT RasSetEntryProperties() #define SCRIPT_PATCH_BUFFER_SIZE 2048 #define SIZEOF_NULL 1 #define MIN_TAPI_VERSION 0x10003 #define MAX_TAPI_VERSION 0x10004 #define NElems(a) (sizeof a / sizeof a[0]) #define INETCFG_INSTALLMODEM 0x00000002 #define INETCFG_INSTALLRNA 0x00000004 #define INETCFG_INSTALLTCP 0x00000008 #define INETCFG_SUPPRESSINSTALLUI 0x00000080 // // Check to see if TCP is installed regardless of binding // #define INETCFG_INSTALLTCPONLY 0x00004000 // // Components Checked flags // #define CC_RNA 0x00000001 // RNA installed #define CC_TCPIP 0x00000002 // TCPIP installed #define CC_MODEM 0x00000004 // Modem installed #define CC_PPTP 0x00000008 // PPTP installed #define CC_SCRIPTING 0x00000010 // Scripting installed #define CC_RASRUNNING 0X00000020 // RAS services is running // on NT #define CC_CHECK_BINDINGS 0x00000040 // Check if PPP is bound to TCP #define DT_CMMON 0x00000001 #define DT_EXPLORER 0x00000002 #define DT_CMMGR 0x00000004 #define DT_CMSTP 0x00000008 #define DT_RUNDLL32 0x00000010 #define DT_RASAUTOU 0x00000020 #define DT_USER (DT_CMMGR | DT_CMMON | DT_EXPLORER | DT_CMSTP | DT_RUNDLL32 | DT_RASAUTOU) #define MAX_PHONE_NUMBERS 2 #define MAX_PHONE_LEN95 36 //Win 95 has 36 char phone limit #define MAX_PHONE_LENNT 80 //NT has 80 char phone limit // // Country list limits and defines // #define DEF_COUNTRY_INFO_SIZE 1024 #define MAX_COUNTRY_NAME 36 #define DEFAULT_COUNTRY_CODE 1 #define DEFAULT_COUNTRY_ID 1 // US // // Default settings values // #define DEFAULT_IDLETIMEOUT 10 // # of minutes to wait before idle disconnect #define DEFAULT_DIALEXTRAPERCENT 80 // see ArgsStruct dwDialExtraPercent #define DEFAULT_DIALEXTRASAMPLESECONDS 30 // see ArgsStruct dwDialExtraSampleSeconds #define DEFAULT_HANGUPEXTRAPERCENT 40 // see ArgsStruct dwHangupExtraPercent #define DEFAULT_HANGUPEXTRASAMPLESECONDS 300 // see ArgsStruct dwHangupExtraSampleSeconds #define DEFAULT_REDIAL_DELAY 5 #define DEFAULT_MAX_REDIALS 3 #define NT4_BUILD_NUMBER 1381 // // isdn dial mode // #define CM_ISDN_MODE_SINGLECHANNEL 0 #define CM_ISDN_MODE_DUALCHANNEL_ONLY 1 #define CM_ISDN_MODE_DUALCHANNEL_FALLBACK 2 // // len for the var lasterror string // #define MAX_LASTERR_LEN 128 // // Flags for manipulating dialog template mask // #define CMTM_UID 0x00000001 // Username to be displayed #define CMTM_PWD 0x00000002 // Password to be displayed #define CMTM_DMN 0x00000004 // Domain to be displayed #define CMTM_FAVS 0x00000008 // Favorite enbabled dialogs #define CMTM_GCOPT 0x00000010 // Global Credential Options #define CMTM_UID_AND_PWD CMTM_UID | CMTM_PWD // 0x00000003 // No domain displayed #define CMTM_UID_AND_DMN CMTM_UID | CMTM_DMN // 0x00000005 // No Password displayed #define CMTM_PWD_AND_DMN CMTM_PWD | CMTM_DMN // 0x00000006 // No Username displayed #define CMTM_U_P_D CMTM_UID | CMTM_PWD | CMTM_DMN // 0x00000007 // All userinfo displayed // // Access point names should be no longer than 32 chars (not counting the NULL terminator) // #define MAX_ACCESSPOINT_LENGTH 32 #define ID_OK_RELAUNCH_MAIN_DLG 123174 // // Balloon Tip Flags // #define BT_ACCESS_POINTS 0x00000001 // Access Point balloon tip has already been displayed // // Connection Types // #define DIAL_UP_CONNECTION 0 #define DIRECT_CONNECTION 1 #define DOUBLE_DIAL_CONNECTION 2 class CConnStatistics; // // Special-case some smart-card PIN errors // #define BAD_SCARD_PIN(x) ((SCARD_W_WRONG_CHV == (x)) || (SCARD_E_INVALID_CHV == (x))) //************************************************************************ // structures, typdef's //************************************************************************ // // Function prototypes for entrypoints into RAS. We will link to RAS using LoadLibary()/GetProcAddress(), // so that we can be flexible concerning how we load (for example, if RAS is not installed on the machine, // we can print a polite message, instead of just having Windows put up an ugly dialog about RASAPI32.DLL // not being found. // #include "raslink.h" // // Function prototypes for entrypoints into TAPI. We will link to TAPI using LoadLibary()/GetProcAddress(), // so that we can be flexible concerning how we load (for example, if TAPI is not installed on the machine, // we can print a polite message, instead of just having Windows put up an ugly dialog about TAPI32.DLL // not being found. // typedef LONG (WINAPI *pfnTapilineInitialize)(LPHLINEAPP, HINSTANCE, LINECALLBACK, LPCTSTR, LPDWORD); typedef LONG (WINAPI *pfnTapilineNegotiateAPIVersion)(HLINEAPP, DWORD, DWORD, DWORD, LPDWORD, LPLINEEXTENSIONID); typedef LONG (WINAPI *pfnTapilineGetDevCaps)(HLINEAPP, DWORD, DWORD, DWORD, LPLINEDEVCAPS); typedef LONG (WINAPI *pfnTapilineShutdown)(HLINEAPP); typedef LONG (WINAPI *pfnTapilineTranslateAddress)(HLINEAPP, DWORD, DWORD, LPCTSTR, DWORD, DWORD, LPLINETRANSLATEOUTPUT); typedef LONG (WINAPI *pfnTapilineTranslateDialog)(HLINEAPP, DWORD, DWORD, HWND, LPCTSTR); typedef LONG (WINAPI *pfnTapilineGetDevConfig)(DWORD, LPVARSTRING, LPCSTR); //typedef LONG (WINAPI *pfnTapilineGetID)(HLINE, DWORD, HCALL, DWORD, LPVARSTRING, LPCTSTR); //typedef LONG (WINAPI *pfnTapitapiGetLocationInfo)(LPCTSTR, LPCTSTR); typedef LONG (WINAPI *pfnTapilineGetTranslateCaps)(HLINEAPP, DWORD, LPLINETRANSLATECAPS); typedef LONG (WINAPI *pfnTapilineSetCurrentLocation)(HLINEAPP, DWORD); // // function prototypes for LSA stuff. // typedef NTSTATUS (NTAPI *pfnLsaOpenPolicy)(PLSA_UNICODE_STRING, PLSA_OBJECT_ATTRIBUTES, ACCESS_MASK, PLSA_HANDLE); typedef NTSTATUS (NTAPI *pfnLsaRetrievePrivateData)(LSA_HANDLE, PLSA_UNICODE_STRING, PLSA_UNICODE_STRING *); typedef NTSTATUS (NTAPI *pfnLsaStorePrivateData)(LSA_HANDLE, PLSA_UNICODE_STRING, PLSA_UNICODE_STRING); typedef ULONG (NTAPI *pfnLsaNtStatusToWinError)(NTSTATUS); typedef NTSTATUS (NTAPI *pfnLsaClose)(LSA_HANDLE); typedef NTSTATUS (NTAPI *pfnLsaFreeMemory)(PVOID); // // Connect Action Function Prototype // typedef DWORD (WINAPI *pfnCmConnectActionFunc)(HWND, HINSTANCE, LPCSTR, int); // // Structure used to describe the linkage to TAPI. NOTE: Changes to this structure // will probably require changes to LinkToTapi() and UnlinkFromTapi(). // typedef struct _TapiLinkageStruct { HINSTANCE hInstTapi; union { struct { pfnTapilineInitialize pfnlineInitialize; pfnTapilineNegotiateAPIVersion pfnlineNegotiateAPIVersion; pfnTapilineGetDevCaps pfnlineGetDevCaps; pfnTapilineGetDevConfig pfnlineGetDevConfig; pfnTapilineShutdown pfnlineShutdown; pfnTapilineTranslateAddress pfnlineTranslateAddress; // pfnTapitapiGetLocationInfo pfntapiGetLocationInfo; pfnTapilineTranslateDialog pfnlineTranslateDialog; // pfnTapilineGetID pfnlineGetID; pfnTapilineGetTranslateCaps pfnlineGetTranslateCaps; pfnTapilineSetCurrentLocation pfnlineSetCurrentLocation; }; void *apvPfnTapi[10]; // see comment for RasLinkageStruct for 10. }; HLINEAPP hlaLine; DWORD dwDevCnt; BOOL bOpen; BOOL bDevicePicked; TCHAR szDeviceName[RAS_MaxDeviceName + 1]; DWORD dwDeviceId; DWORD dwApiVersion; BOOL bModemSpeakerOff; DWORD dwTapiLocationForAccessPoint; // Tapi location for current access point DWORD dwOldTapiLocation; // Tapi location when CM is started, restored when CM exits } TapiLinkageStruct; typedef struct _LsaLinkageStruct { HINSTANCE hInstLsa; union { struct { pfnLsaOpenPolicy pfnOpenPolicy; pfnLsaRetrievePrivateData pfnRetrievePrivateData; pfnLsaStorePrivateData pfnStorePrivateData; pfnLsaNtStatusToWinError pfnNtStatusToWinError; pfnLsaClose pfnClose; pfnLsaFreeMemory pfnFreeMemory; }; void *apvPfnLsa[7]; }; } LsaLinkageStruct; #define PHONE_DESC_LEN 80 #define PB_MAX_SERVICE 256 #define PB_MAX_REGION 256 // // Phone Info Flags // #define PIF_USE_DIALING_RULES 0x00000001 typedef struct _PHONEINFO { DWORD dwCountryID; TCHAR szPhoneNumber[RAS_MaxPhoneNumber+1]; TCHAR szCanonical[RAS_MaxPhoneNumber+1]; TCHAR szDUN[MAX_PATH+1]; TCHAR szPhoneBookFile[MAX_PATH+1]; // the service file associate with the phone # TCHAR szDialablePhoneNumber[RAS_MaxPhoneNumber+1]; TCHAR szDisplayablePhoneNumber[RAS_MaxPhoneNumber+1]; TCHAR szDesc[PHONE_DESC_LEN]; DWORD dwPhoneInfoFlags; // // The following 2 vars are set by the phone book dlg(OnGeneralPhoneChange). // We need to save them and then write them out when the user clicks OK. // TCHAR szServiceType[PB_MAX_SERVICE]; TCHAR szRegionName[PB_MAX_REGION]; } PHONEINFO, *PPHONEINFO; // // Structure for all of the program's data. Basically, the program doesn't have any // global variables - everything is stored in this structure. // typedef struct _ArgsStruct { public: LPICMOCCtr pCtr; // OC ctr for FS OC UINT uMsgId; // message ID used for driving the dialing state machine DWORD dwFlags; // any flags from the command line -- see IniArgs RasLinkageStruct rlsRasLink; // linkade to RAS HRASCONN hrcRasConn; // the handle of the RAS connection TapiLinkageStruct tlsTapiLink; // linkage to TAPI LsaLinkageStruct llsLsaLink; // linkage to LSA BOOL fIgnoreChangeNotification; // TRUE if EN_CHANGE messages should be ignored TCHAR szLastErrorSrc[MAX_LASTERR_LEN]; // the source of last err(either RAS or a connect action name) TCHAR szDeviceName[RAS_MaxDeviceName+1]; // device being used TCHAR szDeviceType[RAS_MaxDeviceName+1]; // device type of the device being used TCHAR szUserName[UNLEN+1]; // username for corp account TCHAR szPassword[PWLEN+1]; // password for corp account TCHAR szDomain[DNLEN+1]; // domain for corp account TCHAR szConnectoid[RAS_MaxEntryName]; // connectoid name TCHAR szServiceName[RAS_MaxEntryName]; // top-level long service name // added for tunneling HRASCONN hrcTunnelConn; // the handle of the tunnel connection TCHAR szTunnelDeviceType[RAS_MaxDeviceType+1]; // device type TCHAR szTunnelDeviceName[RAS_MaxDeviceName+1]; // device being used for tunneling TCHAR szInetUserName[UNLEN+1]; // username for internet(isp) TCHAR szInetPassword[PWLEN+1]; // password for internet(isp) BOOL fUseSameUserName; // TRUE if will use the same password for dialup BOOL fHideDialAutomatically; // don't show 'dial automatically..." checkbox BOOL fHideRememberPassword; // don't show 'remember password" checkbox BOOL fHideRememberInetPassword; // don't show 'remember Internet password" checkbox BOOL fDialAutomatically; // dial automatically upon start? BOOL fRememberInetPassword; // remember the internet password BOOL fRememberMainPassword; // remember the password in the main dialog box BOOL fHideUserName; // Hide the username on the main logon tab BOOL fHidePassword; // Hide the password on the main logon tab BOOL fHideDomain; // Hide the domain on the main logon tab BOOL fHideInetUsername; // Hide the username on the Inet logon tab BOOL fHideInetPassword; // Hide the password on the Inet logon tab BOOL fTunnelPrimary; // if TRUE, we'll tunnel only if the user selects a phone # // from the pbk associated with the primary service profile BOOL fTunnelReferences; // if TRUE, we'll tunnel only if the user selects a phone # // from the pbk associated with the referenced service profile BOOL fUseTunneling; // TRUE if use tunneling for dial-up networking(it is NOT the same // as (fTunnel|fTunnelReferences)!!! It's determined by // looking at the above 3 flags plus more. BOOL bUseRasCredStore; // TRUE if this profile uses RasSetCredentials and RasGetCredentials // to store creds on win2k+. Will be FALSE on legacy platforms BOOL bShowHNetCfgAdvancedTab; // displays the ICF & ICS (Advanced) tab // Internet Connection Sharing & Internet Connection Firewall tab // TRUE by default DWORD dwSCardErr; // special case handling for SmartCard errors LPTSTR GetProperty(const TCHAR* pszName, BOOL *pbValidPropertyName); // get the cm property by name DWORD GetTypeOfConnection(); // is the connection dialup, direct, or double dial? protected: // // Encapsulate the tunnel address // // IP(or DNS name) in the profile for tunnel server TCHAR szPrimaryTunnelIP[RAS_MaxPhoneNumber+1]; public: const TCHAR* GetTunnelAddress() {return szPrimaryTunnelIP;} void SetPrimaryTunnel(LPCTSTR pszTunnelIP) {lstrcpynU(szPrimaryTunnelIP, pszTunnelIP, sizeof(szPrimaryTunnelIP)/sizeof(TCHAR));} public: UINT_PTR nTimerId; // ID of the timer ProgState psState; // the program's state DWORD dwStateStartTime; // the time that the state started UINT nRedialDelay; // the number of seconds to wait between redial attempts UINT nMaxRedials; // the maximum number of times to redial UINT nRedialCnt; // number of re-dial attempts remaining UINT nLastSecondsDisplay; // the last seconds count which was displayed UINT nDialIdx; // zero-based index of current phone number PHONEINFO aDialInfo[MAX_PHONE_NUMBERS]; // actual phone number that's to be dialed CIni *piniProfile; CIni *piniService; CIni *piniBoth; CIni *piniBothNonFav; LPTSTR pszHelpFile; // file name of help file BMPDATA BmpData; // bitmap handles for main sign-in dialog HPALETTE hMasterPalette; // the current palette for the app HICON hBigIcon; // icon for Alt-Tab task bar HICON hSmallIcon; // icon for main title bar and task bar DWORD dwExitCode; DWORD dwIdleTimeout; // Idle time out in minutes, 0 means never time out HWND hwndResetPasswdButton; HWND hwndTT; // tooltip HANDLE *phWatchProcesses; LPTSTR pszResetPasswdExe; LPTSTR pszCurrentAccessPoint; // String to store the current access point BOOL fAccessPointsEnabled; // Are Access Points enabled? DWORD dwOldTapiLocation; // tapi location when CM is started BOOL fHideBalloonTips; // Are Balloon Tips enabled? CBalloonTip *pBalloonTip; // pointer to the Balloon tip class // for references BOOL fHasRefs; BOOL fHasValidTopLevelPBK; BOOL fHasValidReferencedPBKs; // // for IdleThreshold -- byao 5/30/97 // CConnStatistics *pConnStatistics; CConnectionTable *pConnTable; // idle threshold value BOOL fCheckOSComponents; // should we check OS components? BOOL bDoNotCheckBindings; // Check if TCP is bound to PPP? Ole32LinkageStruct olsOle32Link; // links to Ole32 DLL for future splashing BOOL fFastEncryption; // Whether we want a faster encryption or a more secure one DWORD bDialInfoLoaded; // Whether the dial info is loaded BOOL fStartupInfoLoaded; // have we loaded Startup info? (OnMainLoadStartupInfo()) BOOL fNeedConfigureTapi; // need to configure TAPI location info BOOL fIgnoreTimerRasMsg; // Whether to ignore WM_TIMER and RAS messages BOOL fInFastUserSwitch; // Are we in the process of doing a fast user switch (FUS) CShellDll m_ShellDll; // The link to Shell dll public: BOOL IsDirectConnect() const; void SetDirectConnect(BOOL fDirect) ; // set the connection type direct or dial-up BOOL IsBothConnTypeSupported() const; void SetBothConnTypeSupported(BOOL fBoth); protected: BOOL m_fBothConnTypeSupported; // Whether the profile support both direct connect an dial-up BOOL m_fDirectConnect; // Whether the current configuration is using direct connection public: LPTSTR pszRasPbk; // Ras phonebook path LPTSTR pszRasHiddenPbk; // Hidden Ras phonebook path for dial-up portion of wholesale dial LPTSTR pszVpnFile; // // ISDN dual channel support(dial all initially, dial on demand) // // Dial-on-demand: // CM dials an additional channel when the total bandwidth used exceeds // dwDialExtraPercent percent of the available bandwidth for at least // dwDialExtraSampleSeconds seconds. // BOOL dwIsdnDialMode; // see CM_ISDN_MODE* DWORD dwDialExtraPercent; // used when dialmode = dialasneeded DWORD dwDialExtraSampleSeconds; // used when dialmode = dialasneeded DWORD dwHangUpExtraPercent; // used when dialmode = dialasneeded DWORD dwHangUpExtraSampleSeconds; // used when dialmode = dialasneeded BOOL fInitSecureCalled; // whether InitSecure() is called for password Encryption // // pucDnsTunnelIpAddr_list: // the h_addr_list of a HOSTENT - a list of ip addrs obtained by resolving the // tunnel server DNS name. // uiCurrentTunnelAddr // the index for h_TunnelIpAddr_list. Points to the currently used ip addr address. // rgwRandomDnsIndex // an array of random index to index into the tunnel addr list // unsigned char *pucDnsTunnelIpAddr_list; UINT uiCurrentDnsTunnelAddr; DWORD dwDnsTunnelAddrCount; PWORD rgwRandomDnsIndex; BOOL fAllUser; UINT uLanaMsgId; // Window handle of Lana window if any LPRASDIALPARAMS pRasDialParams; LPRASDIALEXTENSIONS pRasDialExtensions; DWORD dwRasSubEntry; HWND hwndMainDlg; BOOL fNoDialingRules; LPRASNOUSER lpRasNoUser; PEAPLOGONINFO lpEapLogonInfo; // // Note: RAS will pass either a LPRASNOUSER or LPEAPLOGONINFO ptr through the // RasCustomDialDlg interface when calling CM from WinLogon. RAS will // differentiate them by the RCD_Eap flag, which will be set if the // LPEAPLOGONINFO is passed. When not running in WinLogon, neither // will be sent. // BOOL fChangedPassword; // User changed password during logon HWND hWndChangePassword; // Hwnd of change passwor dialog BOOL fWaitingForCallback; // We're waiting for RAS to call us back HWND hWndCallbackNumber; // Hwnd of callback number dialog HWND hWndRetryAuthentication; // Hwnd of Retry Authentication dialog // // Support for global credentials // BOOL fGlobalCredentialsSupported; // enables/disables support for global creds DWORD dwCurrentCredentialType; // Which credentials are currently selected DWORD dwExistingCredentials; // uses bit flags to mark if credentials exist DWORD dwDeleteCredentials; // uses bit flag to mark creds for deletion DWORD dwWinLogonType; // 0 - User logged on // 1 - Winlogon: dial-up // 2 - Winlogon: ICS (no one is logged on) DWORD dwGlobalUserInfo; // uses bit flags to load/save global user info LONG lInConnectOrCancel; // to protect against Cancel during Connect processing, and vice-versa CmLogFile Log; } ArgsStruct; // // Global Credential Support // // Used to identify the current RAS credential store being used. // Used with ArgsStruct.dwCurrentCredentialType #define CM_CREDS_USER 1 #define CM_CREDS_GLOBAL 2 // Identifies which type of credentials want to be use used #define CM_CREDS_TYPE_MAIN 0 #define CM_CREDS_TYPE_INET 1 #define CM_CREDS_TYPE_BOTH 2 // Used to identify who is logged on. // Used with ArgsStruct.dwWinLogonType #define CM_LOGON_TYPE_USER 0 // User is logged on #define CM_LOGON_TYPE_WINLOGON 1 // Dial-up, winlogon, reconnect user initiated logon #define CM_LOGON_TYPE_ICS 2 // No user is logged on, but need to dial unattended (ICS) // Used with ArgsStruct.dwGlobalUserInfo #define CM_GLOBAL_USER_INFO_READ_ICS_DATA 0x0001 // used to load user settings for ICS #define CM_GLOBAL_USER_INFO_WRITE_ICS_DATA 0x0002 // used to save user settings for ICS // Used with ArgsStruct.dwExistingCredentials #define CM_EXIST_CREDS_MAIN_GLOBAL 0x0001 // set if RAS credential store has main global creds #define CM_EXIST_CREDS_MAIN_USER 0x0002 // set if RAS credential store has main user creds #define CM_EXIST_CREDS_INET_GLOBAL 0x0004 // set if RAS credential store has Internet global creds #define CM_EXIST_CREDS_INET_USER 0x0008 // set if RAS credential store has Internet user creds // Used with ArgsStruct.dwDeleteCredentials #define CM_DELETE_CREDS_MAIN_GLOBAL 0x0001 // set to delete main global creds #define CM_DELETE_CREDS_MAIN_USER 0x0002 // set to delete main user creds #define CM_DELETE_CREDS_INET_GLOBAL 0x0004 // set to delete Internet global creds #define CM_DELETE_CREDS_INET_USER 0x0008 // set to delete Internet user creds // // RasNumEntry - phone number subset of RASENTRY // typedef struct tagRasNumEntry { DWORD dwSize; DWORD dwfOptions; DWORD dwCountryID; DWORD dwCountryCode; TCHAR szAreaCode[ RAS_MaxAreaCode + 1 ]; TCHAR szLocalPhoneNumber[ RAS_MaxPhoneNumber + 1 ]; } RASNUMENTRY, *LPRASNUMENTRY; // // EditNumData struct used to pass data to/from EditNum dialog. // typedef struct tagEditNumData { ArgsStruct *pArgs; RASNUMENTRY RasNumEntry; } EDITNUMDATA, *LPEDITNUMDATA; //************************************************************************ // string constants //************************************************************************ // // CMMON exe name, expected to be local // const TCHAR* const c_pszCmMonExeName = TEXT("CMMON32.EXE"); //************************************************************************ // function prototypes //************************************************************************ // init.cpp void InitProfileFromName(ArgsStruct *pArgs, LPCTSTR pszArg); HRESULT InitProfile(ArgsStruct *pArgs, LPCTSTR pszEntry); HRESULT InitArgsForDisconnect(ArgsStruct *pArgs, BOOL fAllUser); HRESULT InitArgsForConnect(ArgsStruct *pArgs, LPCTSTR pszRasPhoneBook, LPCMDIALINFO lpCmInfo, BOOL fAllUser); HRESULT InitCredentials(ArgsStruct *pArgs, LPCMDIALINFO lpCmInfo, DWORD dwFlags, PVOID pvLogonBlob); HRESULT InitLogging(ArgsStruct *pArgs, LPCTSTR pszEntry, BOOL fBanner); LRESULT CreateIniObjects(ArgsStruct *pArgs); void ReleaseIniObjects(ArgsStruct *pArgs); DWORD RegisterBitmapClass(HINSTANCE hInst); HRESULT WriteCmpInfoToReg(LPCTSTR pszSubKey, LPCTSTR pszEntryName, PVOID pEntryValue, DWORD dwType, DWORD dwSize); LPTSTR GetEntryFromCmp(const TCHAR *pszSectionName, LPTSTR pszEntryName, LPCTSTR pszCmpPath); void ReplaceCmpFile(LPCTSTR pszCmpPath); LPTSTR FormRegPathFromAccessPoint(ArgsStruct *pArgs); // disconn.cpp DWORD Disconnect(CConnectionTable *pConnTable, LPCM_CONNECTION pConnection, BOOL fIgnoreRefCount, BOOL fPersist); DWORD HangupNotifyCmMon(CConnectionTable *pConnTable, LPCTSTR pszEntry); // connect.cpp HRESULT Connect(HWND hwndParent, LPCTSTR lpszEntry, LPTSTR lpszPhonebook, LPRASDIALDLG lpRasDialDlg, LPRASENTRYDLG lpRasEntryDlg, LPCMDIALINFO lpCmInfo, DWORD dwFlags, LPVOID lpvLogonBlob); #define NOT_IN_CONNECT_OR_CANCEL 0 #define IN_CONNECT_OR_CANCEL 1 void GetConnectType(ArgsStruct *pArgs); void AddWatchProcessId(ArgsStruct *pArgs, DWORD dwProcessId); void AddWatchProcess(ArgsStruct *pArgs, HANDLE hProcess); DWORD DoRasHangup(RasLinkageStruct *prlsRasLink, HRASCONN hRasConnection, HWND hwndDlg = NULL, BOOL fWaitForComplete = FALSE, LPBOOL pfWaiting = NULL); DWORD MyRasHangup(ArgsStruct *pArgs, HRASCONN hRasConnection, HWND hwndDlg = NULL, BOOL fWaitForComplete = FALSE); DWORD HangupCM( ArgsStruct *pArgs, HWND hwndDlg, BOOL fWaitForComplete = FALSE, BOOL fUpdateTable = TRUE); BOOL UseTunneling( ArgsStruct *pArgs, DWORD dwEntry ); void SetMainDlgUserInfo( ArgsStruct *pArgs, HWND hwndDlg ); BOOL OnResetPassword( HWND hwndDlg, ArgsStruct *pArgs ); void AppendStatusPane(HWND hwndDlg, DWORD dwMsgId); void AppendStatusPane(HWND hwndDlg, LPCTSTR pszMsg); LPTSTR GetPhoneByIdx(ArgsStruct *pArgs, UINT nIdx, LPTSTR *ppszDesc, LPTSTR *ppszDUN, LPDWORD pdwCountryID, LPTSTR *ppszRegionName, LPTSTR *ppszServiceType, LPTSTR *ppszPhoneBookFile, LPTSTR *ppszCanonical, DWORD *pdwPhoneInfoFlags); void PutPhoneByIdx(ArgsStruct *pArgs, UINT nIdx, LPCTSTR pszPhone, LPCTSTR pszDesc, LPCTSTR pszDUN, DWORD dwCountryID, LPCTSTR pszRegionName, LPCTSTR pszServiceType, LPCTSTR pszPhoneBookFile, LPCTSTR ppszCanonical, DWORD dwPhoneInfoFlags); DWORD LoadDialInfo(ArgsStruct *pArgs, HWND hwndDlg, BOOL fInstallModem = TRUE, BOOL fAlwaysMunge = FALSE); VOID MungeDialInfo(ArgsStruct *pArgs); void LoadHelpFileInfo(ArgsStruct *pArgs); void CopyPhone(ArgsStruct *pArgs, LPRASENTRY preEntry, DWORD dwEntry); VOID LoadLogoBitmap(ArgsStruct * pArgs, HWND hwndDlg); HRESULT LoadFutureSplash(ArgsStruct * pArgs, HWND hwndDlg); void LoadProperties( ArgsStruct *pArgs ); void LoadIconsAndBitmaps( ArgsStruct *pArgs, HWND hwndDlg ); DWORD DoRasDial(HWND hwndDlg, ArgsStruct *pArgs, DWORD dwEntry); DWORD DoTunnelDial(HWND hwndDlg, ArgsStruct *pArgs); BOOL CheckConnect(HWND hwndDlg, ArgsStruct *pArgs, UINT *pnCtrlFocus, BOOL fShowMsg = FALSE); void MainSetDefaultButton(HWND hwndDlg, UINT nCtrlId); VOID MapStateToFrame(ArgsStruct * pArgs); void SetInteractive(HWND hwndDlg, ArgsStruct *pArgs); void OnMainLoadStartupInfo( HWND hwndDlg, ArgsStruct *pArgs ); BOOL SetupInternalInfo( ArgsStruct *pArgs, HWND hwndDlg ); void OnMainInit(HWND hwndDlg, ArgsStruct *pArgs); void OnMainConnect(HWND hwndDlg, ArgsStruct *pArgs); int OnMainProperties(HWND hwndDlg, ArgsStruct *pArgs); void OnMainCancel(HWND hwndDlg, ArgsStruct *pArgs); void OnMainEnChange(HWND hwndDlg, ArgsStruct *pArgs); DWORD OnRasNotificationMessage(HWND hwndDlg, ArgsStruct *pArgs, WPARAM wParam, LPARAM lParam); void OnRasErrorMessage(HWND hwndDlg, ArgsStruct *pArgs, DWORD dwError); void OnMainTimer(HWND hwndDlg, ArgsStruct *pArgs); void OnConnectedCM(HWND hwndDlg, ArgsStruct *pArgs); INT_PTR CALLBACK MainDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam); BOOL ShowAccessPointInfoFromReg(ArgsStruct *pArgs, HWND hwndParent, UINT uiComboID); BOOL ChangedAccessPoint(ArgsStruct *pArgs, HWND hwndDlg, UINT uiComboID); // dialogs.cpp int DoPropertiesPropSheets( HWND hwndDlg, ArgsStruct *pArgs ); void CheckConnectionAndInformUser( HWND hwndDlg, ArgsStruct *pArgs ); BOOL HaveContextHelp( HWND hwndDlg, HWND hwndCtrl ); // refs.cpp BOOL ValidTopLevelPBK( ArgsStruct *pArgs ); BOOL ValidReferencedPBKs( ArgsStruct *pArgs ); CIni* GetAppropriateIniService( ArgsStruct *pArgs, DWORD dwEntry ); // ctr.cpp VOID CleanupCtr(LPICMOCCtr pCtr); BOOL LinkToOle32( Ole32LinkageStruct *polsOle32Link, LPCSTR pszOle32); void UnlinkFromOle32( Ole32LinkageStruct *polsOle32Link); // util.cpp BOOL InBetween(int iLowerBound, int iNumber, int iUpperBound); void GetPrefixSuffix ( ArgsStruct *pArgs, CIni* piniService, LPTSTR *ppszUsernamePrefix, LPTSTR *ppszUsernameSuffix ); LPTSTR ApplyPrefixSuffixToBufferAlloc ( ArgsStruct *pArgs, CIni *piniService, LPTSTR pszBuffer ); LPTSTR ApplyDomainPrependToBufferAlloc ( ArgsStruct *pArgs, CIni *piniService, LPTSTR pszBuffer, LPCTSTR pszDunName ); void ApplyPasswordHandlingToBuffer ( ArgsStruct *pArgs, LPTSTR pszBuffer ); BOOL IsActionEnabled(CONST WCHAR *pszProgram, CONST WCHAR *pszServiceName, CONST WCHAR *pszServiceFileName, LPDWORD lpdwLoadType); BOOL IsLogonAsSystem(); BOOL UnRegisterWindowClass(HINSTANCE hInst); DWORD RegisterWindowClass(HINSTANCE hInst); LPCM_CONNECTION GetConnection(ArgsStruct *pArgs); void NotifyUserOfExistingConnection( HWND hwndParent, LPCM_CONNECTION pConnection, BOOL fStatus); BOOL FileExists(LPCTSTR pszFullNameAndPath); LPTSTR CmGetWindowTextAlloc( HWND hwndDlg, UINT nCtrl); LPTSTR GetServiceName(CIni *piniService); LPTSTR GetTunnelSuffix(); LPTSTR GetDefaultDunSettingName(CIni* piniService, BOOL fTunnelEntry); LPTSTR GetDunSettingName(ArgsStruct * pArgs, DWORD dwEntry, BOOL fTunnelEntry); LPTSTR GetCMSforPhoneBook(ArgsStruct * pArgs, DWORD dwEntry); BOOL ReadMappingByRoot( HKEY hkRoot, LPCTSTR pszDUN, LPTSTR pszMapping, DWORD dwMapping, BOOL bExpandEnvStrings ); BOOL ReadMapping( LPCTSTR pszDUN, LPTSTR pszMapping, DWORD dwMapping, BOOL fAllUser, BOOL bExpandEnvStrings ); LPTSTR ReducePathToRelative( ArgsStruct *pArgs, LPCTSTR pszFullPath); BOOL IsBlankString(LPCTSTR pszString); BOOL IsValidPhoneNumChar(TCHAR tChar); LPTSTR StripPath(LPCTSTR pszFullNameAndPath); void SingleSpace(LPTSTR pszStr, UINT uNumCharsInStr); void Ip_GPPS(CIni *pIni, LPCTSTR pszSection, LPCTSTR pszEntry, RASIPADDR *pIP); void CopyGPPS(CIni *pIni, LPCTSTR pszSection, LPCTSTR pszEntry, LPTSTR pszBuffer, size_t nLen); BYTE HexValue(IN CHAR ch); CHAR HexChar(IN BYTE byte); void StripCanonical(LPTSTR pszSrc); void StripFirstElement(LPTSTR pszSrc); BOOL FrontExistingUI ( CConnectionTable *pConnTable, LPCTSTR pszServiceName, BOOL fConnect ); LPTSTR GetPropertiesDlgTitle( LPCTSTR pszServiceName ); int GetPPTPMsgId(void); BOOL IsServicePackInstalled(void); // pb.cpp #define CPBMAP_ERROR -1 class CPBMap { public: CPBMap(); ~CPBMap(); DWORD Open(LPCSTR pszISP, DWORD dwParam=0); DWORD ToCookie(DWORD_PTR dwPB, DWORD dwIdx, DWORD *pdwParam=NULL); DWORD_PTR PBFromCookie(DWORD dwCookie, DWORD *pdwParam=NULL); DWORD IdxFromCookie(DWORD dwCookie, DWORD *pdwParam=NULL); DWORD_PTR GetPBByIdx(DWORD_PTR dwIdx, DWORD *pdwParam=NULL); DWORD GetCnt(); private: UINT m_nCnt; void *m_pvData; }; #define PB_MAX_PHONE (RAS_MaxPhoneNumber+1) #define PB_MAX_DESC 256 typedef struct tagPBArgs { LPCTSTR pszCMSFile; TCHAR szServiceType[PB_MAX_SERVICE]; DWORD dwCountryId; TCHAR szRegionName[PB_MAX_REGION]; TCHAR szNonCanonical[PB_MAX_PHONE]; TCHAR szCanonical[PB_MAX_PHONE]; TCHAR szDesc[PB_MAX_DESC]; LPTSTR pszMessage; TCHAR szPhoneBookFile[MAX_PATH+1]; LPTSTR pszBitmap; LPCTSTR pszHelpFile; TCHAR szDUNFile[MAX_PATH+1]; HPALETTE *phMasterPalette; } PBArgs; BOOL DisplayPhoneBook(HWND hwndDlg, PBArgs *pArgs, BOOL fHasValidTopLevelPBK, BOOL fHasValidReferencedPBKs); // rnawnd.cpp HANDLE ZapRNAConnectedTo(LPCTSTR pszDUN, HANDLE hEvent); // userinfo.cpp BOOL GetUserInfo( ArgsStruct *pArgs, UINT uiEntry, PVOID *ppvData ); BOOL SaveUserInfo( ArgsStruct *pArgs, UINT uiEntry, PVOID pvData ); BOOL DeleteUserInfo( ArgsStruct *pArgs, UINT uiEntry ); int NeedToUpgradeUserInfo( ArgsStruct *pArgs ); BOOL UpgradeUserInfoFromCmp( ArgsStruct *pArgs ); BOOL UpgradeUserInfoFromRegToRasAndReg( ArgsStruct *pArgs ); BOOL ReadUserInfoFromReg( ArgsStruct *pArgs, UINT uiDataID, PVOID *ppvData); LPTSTR BuildUserInfoSubKey( LPCTSTR pszServiceKey, BOOL fAllUser); LPTSTR BuildICSDataInfoSubKey( LPCTSTR pszServiceKey); BOOL WriteUserInfoToReg( ArgsStruct *pArgs, UINT uiDataID, PVOID pvData); // ntlsa.cpp DWORD LSA_ReadString( ArgsStruct *pArgs, LPTSTR pszKey, LPTSTR pszStr, DWORD dwStrLen ); DWORD LSA_WriteString( ArgsStruct *pArgs, LPTSTR pszKey, LPCTSTR pszStr ); BOOL InitLsa( ArgsStruct *pArgs ); BOOL DeInitLsa( ArgsStruct *pArgs ); // ras.cpp BOOL IsRasLoaded(const RasLinkageStruct * const prlsRasLink); BOOL LinkToRas(RasLinkageStruct *prlsRasLink); void UnlinkFromRas(RasLinkageStruct *prlsRasLink); BOOL GetRasModems(const RasLinkageStruct *prlsRasLink, LPRASDEVINFO *pprdiRasDevInfo, LPDWORD pdwCnt); BOOL PickModem(IN const ArgsStruct *pArgs, OUT LPTSTR pszDeviceType, OUT LPTSTR pszDeviceName, OUT BOOL* pfSameModem = NULL); BOOL GetDeviceType(ArgsStruct *pArgs, LPTSTR pszDeviceType, UINT uNumCharsInDeviceType, LPTSTR pszDeviceName); BOOL PickTunnelDevice(LPTSTR pszDeviceType, LPTSTR pszDeviceName, LPRASDEVINFO prdiModems, DWORD dwCnt); BOOL PickTunnelDevice(ArgsStruct *pArgs, LPTSTR pszDeviceType, LPTSTR pszDeviceName); void CopyAutoDial(LPRASENTRY preEntry); LPRASENTRY MyRGEP(LPCTSTR pszRasPbk, LPCTSTR pszEntryName, RasLinkageStruct *prlsRasLink); BOOL CheckConnectionError(HWND hwndDlg, DWORD dwErr, ArgsStruct *pArgs, BOOL fTunneling, LPTSTR *ppszRasErrMsg = NULL); LPTSTR GetRasConnectoidName( ArgsStruct *pArgs, CIni* piniService, BOOL fTunnelEntry ); LPRASENTRY CreateRASEntryStruct( ArgsStruct *pArgs, LPCTSTR pszDUN, CIni* piniService, BOOL fTunnelEntry, LPTSTR pszRasPbk, LPBYTE *ppbEapData, LPDWORD pdwEapSize ); LRESULT ReadDUNSettings( ArgsStruct *pArgs, LPCTSTR pszFile, LPCTSTR pszDunName, LPVOID pvBuffer, LPBYTE *ppbEapData, LPDWORD pdwEapSiz, BOOL fTunnel ); BOOL ValidateDialupDunSettings(LPCTSTR pszCmsFile, LPCTSTR pszDunName, LPCTSTR pszTopLevelCms); LPTSTR CreateRasPrivatePbk( ArgsStruct *pArgs); DWORD AllocateSecurityDescriptorAllowAccessToWorld(PSECURITY_DESCRIPTOR *ppSd); LPTSTR GetPathToPbk( LPCTSTR pszCmp, ArgsStruct *pArgs); void DisableWin95RasWizard( void ); BOOL SetIsdnDualChannelEntries( ArgsStruct *pArgs, LPRASENTRY pre, LPRASSUBENTRY *pprse, PDWORD pdwSubEntryCount ); BOOL SetNtIdleDisconnectInRasEntry( ArgsStruct *pArgs, LPRASENTRY pre ); BOOL DisableSystemIdleDisconnect(LPRASENTRY pre); DWORD WINAPI RasDialFunc2( ULONG_PTR dwCallbackId, // user-defined value specified in RasDial // call DWORD dwSubEntry, // subentry index in multilink connection HRASCONN hrasconn, // handle to RAS connection UINT unMsg, // type of event that has occurred RASCONNSTATE rascs, // connection state about to be entered DWORD dwError, // error that may have occurred DWORD dwExtendedError // extended error information for some // errors ); LPRASENTRY AllocateRasEntry(); LPRASDIALEXTENSIONS AllocateAndInitRasDialExtensions(); DWORD InitRasDialExtensions(LPRASDIALEXTENSIONS lpRasDialExtensions); DWORD SetRasDialExtensions(ArgsStruct* pArgs, BOOL fEnablePausedStates, BOOL fEnableCustomScripting); LPVOID GetRasCallBack(ArgsStruct* pArgs); DWORD GetRasCallBackType(); #if 0 /* void InitDefaultRasPhoneBook(); LPTSTR GetRasSystemPhoneBookPath(); */ #endif LPRASDIALPARAMS AllocateAndInitRasDialParams(); DWORD InitRasDialParams(LPRASDIALPARAMS lpRasDialParams); LPTSTR GetRasPbkFromNT5ProfilePath(LPCTSTR pszProfile); DWORD OnPauseRasDial(HWND hwndDlg, ArgsStruct *pArgs, WPARAM wParam, LPARAM lParam); // tapi.cpp BOOL OpenTapi(HINSTANCE hInst, TapiLinkageStruct *ptlsTapiLink); void CloseTapi(TapiLinkageStruct *ptlsTapiLink); BOOL LinkToTapi(TapiLinkageStruct *ptlsTapiLink, LPCSTR pszTapi); void UnlinkFromTapi(TapiLinkageStruct *ptlsTapiLink); BOOL SetTapiDevice(HINSTANCE hInst, TapiLinkageStruct *ptlsTapiLink, LPCTSTR pszModem); LRESULT MungePhone(LPCTSTR pszModem, LPTSTR *ppszPhone, TapiLinkageStruct *ptlsTapiLink, HINSTANCE hInst, BOOL fDialingRulesEnabled, LPTSTR *ppszDial, BOOL fAccessPointsEnabled); DWORD GetCurrentTapiLocation(TapiLinkageStruct *ptlsTapiLink); DWORD SetCurrentTapiLocation(TapiLinkageStruct *ptlsTapiLink, DWORD dwLocation); void RestoreOldTapiLocation(TapiLinkageStruct *ptlsTapiLink); HANDLE HookLights(ArgsStruct *pArgs); inline BOOL IsTunnelEnabled(const ArgsStruct* pArgs) { return (pArgs->fTunnelPrimary || pArgs->fTunnelReferences); } inline BOOL IsDialingTunnel(const ArgsStruct* pArgs) { return pArgs->psState == PS_TunnelDialing || pArgs->psState == PS_TunnelAuthenticating; } inline BOOL _ArgsStruct::IsDirectConnect() const { return m_fDirectConnect; } inline void _ArgsStruct::SetDirectConnect(BOOL fDirect) { m_fDirectConnect = fDirect; } inline BOOL _ArgsStruct::IsBothConnTypeSupported() const { return m_fBothConnTypeSupported; } inline void _ArgsStruct::SetBothConnTypeSupported(BOOL fBoth) { m_fBothConnTypeSupported = fBoth; } // wsock.cpp BOOL TryAnotherTunnelDnsAddress( ArgsStruct *pArgs ); // main.cpp BOOL WhoIsCaller( DWORD dwCaller = DT_USER ); // lanawait.cpp BOOL LanaWait( ArgsStruct *pArgs, HWND hwndMainDlg ); // // Credential helper functions // #define CM_DELETE_SAVED_CREDS_KEEP_GLOBALS FALSE #define CM_DELETE_SAVED_CREDS_DELETE_GLOBALS TRUE #define CM_DELETE_SAVED_CREDS_KEEP_IDENTITY FALSE #define CM_DELETE_SAVED_CREDS_DELETE_IDENTITY TRUE BOOL InitializeCredentialSupport(ArgsStruct *pArgs); BOOL RefreshCredentialTypes(ArgsStruct *pArgs, BOOL fSetCredsDefault); VOID RefreshCredentialInfo(ArgsStruct *pArgs, DWORD dwCredsType); DWORD FindEntryCredentialsForCM(ArgsStruct *pArgs, LPTSTR pszPhoneBook, BOOL *pfUser, BOOL *pfGlobal); DWORD GetCurrentCredentialType(ArgsStruct *pArgs); BOOL DeleteSavedCredentials(ArgsStruct *pArgs, DWORD dwCredsType, BOOL fDeleteGlobal, BOOL fDeleteIdentity); VOID SetCredentialUIOptionBasedOnDefaultCreds(ArgsStruct *pArgs, HWND hwndDlg); VOID GetAndStoreUserInfo(ArgsStruct *pArgs, HWND hwndDlg, BOOL fSaveUPD, BOOL fSaveOtherUserInfo); VOID TryToDeleteAndSaveCredentials(ArgsStruct *pArgs, HWND hwndDlg); VOID GetUserInfoFromDialog(ArgsStruct *pArgs, HWND hwndDlg, RASCREDENTIALS *prc); VOID SwitchToLocalCreds(ArgsStruct *pArgs, HWND hwndDlg, BOOL fSwitchToLocal); VOID SwitchToGlobalCreds(ArgsStruct *pArgs, HWND hwndDlg, BOOL fSwitchToGlobal); VOID ReloadCredentials(ArgsStruct *pArgs, HWND hwndDlg, DWORD dwWhichCredType); // // Global User Info help functions // VOID SetIniObjectReadWriteFlags(ArgsStruct *pArgs); VOID VerifyAdvancedTabSettings(ArgsStruct *pArgs); HRESULT InternalGetSharingEnabled(IHNetConnection *pHNetConnection, BOOLEAN *pbEnabled, SHARINGCONNECTIONTYPE* pType); HRESULT InternalGetFirewallEnabled(IHNetConnection *pHNetConnection, BOOLEAN *pbEnabled); STDMETHODIMP DisableSharing(IHNetConnection *pHNetConn); VOID EnableInternetFirewall(IHNetConnection *pHNetConn); HRESULT FindINetConnectionByGuid(GUID *pGuid, INetConnection **ppNetCon); VOID SetProxyBlanket(IUnknown *pUnk); BOOL IsAdmin(VOID); BOOL IsMemberOfGroup(DWORD dwGroupRID, BOOL bUseBuiltinDomainRid); HRESULT APIENTRY HrCreateNetConnectionUtilities(INetConnectionUiUtilities ** ppncuu); #endif // _ICM_INC