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.
6782 lines
220 KiB
6782 lines
220 KiB
//+----------------------------------------------------------------------------
|
|
//
|
|
// File: dialogs.cpp
|
|
//
|
|
// Module: CMDIAL32.DLL
|
|
//
|
|
// Synopsis: This module contains the code for the implementing the Dialog UI
|
|
// functionality of Connection Manager.
|
|
//
|
|
// Copyright (c) 1996-1999 Microsoft Corporation
|
|
//
|
|
// Author: quintinb Created Header 8/17/99
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
#include "cmmaster.h"
|
|
#include "dialogs.h"
|
|
#include "pnpuverp.h"
|
|
#include "dial_str.h"
|
|
#include "mon_str.h"
|
|
#include "stp_str.h"
|
|
#include "ras_str.h"
|
|
#include "profile_str.h"
|
|
#include "log_str.h"
|
|
#include "tunl_str.h"
|
|
#include "userinfo_str.h"
|
|
|
|
#include "cmsafenet.h"
|
|
|
|
//
|
|
// Get the common function HasSpecifiedAccessToFileOrDir
|
|
//
|
|
#include "hasfileaccess.cpp"
|
|
|
|
#include <pshpack1.h>
|
|
typedef struct DLGTEMPLATEEX
|
|
{
|
|
WORD dlgVer;
|
|
WORD signature;
|
|
DWORD helpID;
|
|
DWORD exStyle;
|
|
DWORD style;
|
|
WORD cDlgItems;
|
|
short x;
|
|
short y;
|
|
short cx;
|
|
short cy;
|
|
} DLGTEMPLATEEX, *LPDLGTEMPLATEEX;
|
|
#include <poppack.h>
|
|
|
|
//
|
|
// Timeout for the write properties mutex, in milliseconds
|
|
//
|
|
const DWORD WRITE_PROPERTIES_MUTEX_TIMEOUT = 1000*10;
|
|
|
|
//************************************************************************
|
|
// Globals
|
|
//************************************************************************
|
|
|
|
//
|
|
// Original edit control and property sheet window procedures
|
|
//
|
|
|
|
WNDPROC CGeneralPage::m_pfnOrgEditWndProc = NULL;
|
|
WNDPROC CNewAccessPointDlg::m_pfnOrgEditWndProc = NULL;
|
|
WNDPROC CPropertiesSheet::m_pfnOrgPropSheetProc = NULL; // prop sheet
|
|
CPropertiesSheet* CPropertiesSheet::m_pThis = NULL;
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CGeneralPage::UpdateNumberDescription
|
|
//
|
|
// Synopsis: Helper function to deal with updating the description edit,
|
|
// by appending to the Phone Number: and Backup Number: labels
|
|
//
|
|
// Arguments: int nPhoneIdx - index of phone number to which this applies
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: nickball - Created - 7/17/97
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CGeneralPage::UpdateNumberDescription(int nPhoneIdx, LPCTSTR pszDesc)
|
|
{
|
|
MYDBGASSERT(pszDesc);
|
|
|
|
if (NULL == pszDesc)
|
|
{
|
|
return;
|
|
}
|
|
|
|
UINT nDescID = !nPhoneIdx ? IDC_GENERAL_P1_STATIC: IDC_GENERAL_P2_STATIC;
|
|
|
|
LPTSTR pszTmp;
|
|
|
|
//
|
|
// Load the appropriate label as a base string
|
|
//
|
|
|
|
if (nPhoneIdx)
|
|
{
|
|
pszTmp = CmLoadString(g_hInst, IDS_BACKUP_NUM_LABEL);
|
|
}
|
|
else
|
|
{
|
|
pszTmp = CmLoadString(g_hInst, IDS_PHONE_NUM_LABEL);
|
|
}
|
|
|
|
MYDBGASSERT(pszTmp);
|
|
|
|
if (pszTmp)
|
|
{
|
|
//
|
|
// Append the description and display
|
|
//
|
|
|
|
if (*pszDesc)
|
|
{
|
|
pszTmp = CmStrCatAlloc(&pszTmp, TEXT(" "));
|
|
pszTmp = CmStrCatAlloc(&pszTmp, pszDesc);
|
|
}
|
|
|
|
SetDlgItemTextU(m_hWnd, nDescID, pszTmp);
|
|
}
|
|
|
|
CmFree(pszTmp);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CGeneralPage::ClearUseDialingRules
|
|
//
|
|
// Synopsis: Helper function to deal with disabling the check box and
|
|
// reseting the state for UseDialingRules.
|
|
//
|
|
// Arguments: iPhoneNdx - index of phone number to which this applies
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: nickball - Created - 7/17/97
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
void CGeneralPage::ClearUseDialingRules(int iPhoneNdx)
|
|
{
|
|
MYDBGASSERT(iPhoneNdx ==0 || iPhoneNdx ==1);
|
|
//
|
|
// Uncheck and disable the appropriate "Use Dialing Rules" checkbox
|
|
//
|
|
|
|
if (0 == iPhoneNdx)
|
|
{
|
|
CheckDlgButton(m_hWnd, IDC_GENERAL_UDR1_CHECKBOX, FALSE);
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_GENERAL_UDR1_CHECKBOX), FALSE);
|
|
}
|
|
else
|
|
{
|
|
CheckDlgButton(m_hWnd, IDC_GENERAL_UDR2_CHECKBOX, FALSE);
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_GENERAL_UDR2_CHECKBOX), FALSE);
|
|
}
|
|
|
|
m_DialInfo[iPhoneNdx].dwPhoneInfoFlags &= ~PIF_USE_DIALING_RULES;
|
|
|
|
UpdateDialingRulesButton();
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CGeneralPage::UpdateDialingRulesButton
|
|
//
|
|
// Synopsis: Helper function to deal with enabling/disabling the
|
|
// DialingRules button according to whether dialing rules
|
|
// is being applied to either primary or backup number.
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: nickball - Created - 12/14/98
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
void CGeneralPage::UpdateDialingRulesButton(void)
|
|
{
|
|
BOOL fDialingRules = (IsDlgButtonChecked(m_hWnd, IDC_GENERAL_UDR1_CHECKBOX) &&
|
|
IsWindowEnabled(GetDlgItem(m_hWnd, IDC_GENERAL_UDR1_CHECKBOX))
|
|
) ||
|
|
(IsDlgButtonChecked(m_hWnd, IDC_GENERAL_UDR2_CHECKBOX) &&
|
|
IsWindowEnabled(GetDlgItem(m_hWnd, IDC_GENERAL_UDR2_CHECKBOX))
|
|
);
|
|
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_GENERAL_TAPI_BUTTON), fDialingRules);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: DoPropertiesPropSheets
|
|
//
|
|
// Synopsis: Pop up the Properties property sheets.
|
|
//
|
|
// Arguments: hwndDlg [dlg window handle]
|
|
// pArgs [the ptr to ArgsStruct]
|
|
//
|
|
// Returns: PropertySheet return value
|
|
//
|
|
// History: henryt Created 3/5/97
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
int DoPropertiesPropSheets(
|
|
HWND hwndDlg,
|
|
ArgsStruct *pArgs
|
|
)
|
|
{
|
|
CPropertiesSheet PropertiesSheet(pArgs);
|
|
CInetPage* pInetPage = NULL;
|
|
CAboutPage* pAboutPage = NULL;
|
|
COptionPage* pOptionPage = NULL;
|
|
CGeneralPage* pGeneralPage = NULL;
|
|
CVpnPage* pVpnPage = NULL;
|
|
HRESULT hr;
|
|
BOOL bCOMInitialized = FALSE;
|
|
HINSTANCE hinstDll = NULL;
|
|
|
|
typedef HRESULT (*pfnGetPageFunction) (PROPSHEETPAGEW *, GUID *);
|
|
|
|
CMTRACE(TEXT("Begin DoPropertiesPropSheets()"));
|
|
|
|
//
|
|
// Always start by adding the General page
|
|
//
|
|
|
|
if (pArgs->IsBothConnTypeSupported() || !pArgs->IsDirectConnect())
|
|
{
|
|
//
|
|
// If both dial-up and direct is supported, use the appropriate
|
|
// template for the general property page.
|
|
//
|
|
|
|
UINT uiMainDlgID;
|
|
|
|
//
|
|
// The general page is always access point aware
|
|
//
|
|
uiMainDlgID = pArgs->IsBothConnTypeSupported() ? IDD_GENERAL_DIRECT : IDD_GENERAL;
|
|
|
|
pGeneralPage = new CGeneralPage(pArgs, uiMainDlgID);
|
|
|
|
if (pGeneralPage)
|
|
{
|
|
PropertiesSheet.AddPage(pGeneralPage);
|
|
|
|
//
|
|
// Create the balloon tip object
|
|
//
|
|
pArgs->pBalloonTip = new CBalloonTip();
|
|
}
|
|
|
|
//
|
|
// Show the Internet Sign-In tab if we're tunneling and
|
|
// Inet username/password is different than main sign-on username/password
|
|
// Also, if either the username or password are NOT to be hidden, we
|
|
// display the tab.
|
|
//
|
|
|
|
if (IsTunnelEnabled(pArgs) && !pArgs->fUseSameUserName)
|
|
{
|
|
if (!pArgs->fHideInetUsername || !pArgs->fHideInetPassword)
|
|
{
|
|
//
|
|
// Determine which template to use based hide flags
|
|
//
|
|
|
|
UINT uiTemplateID = IDD_INET_SIGNIN;
|
|
|
|
if (pArgs->fHideInetUsername)
|
|
{
|
|
uiTemplateID = IDD_INET_SIGNIN_NO_UID;
|
|
}
|
|
else if (pArgs->fHideInetPassword)
|
|
{
|
|
uiTemplateID = IDD_INET_SIGNIN_NO_PWD;
|
|
}
|
|
|
|
//
|
|
// Create the page
|
|
//
|
|
|
|
pInetPage = new CInetPage(pArgs, uiTemplateID);
|
|
|
|
if (pInetPage)
|
|
{
|
|
PropertiesSheet.AddPage(pInetPage);
|
|
|
|
if (pGeneralPage)
|
|
{
|
|
//
|
|
// To receive event from General Page
|
|
//
|
|
pGeneralPage->SetEventListener(pInetPage);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Add the VPN selector tab if we are tunneling and have a VPN phonebook
|
|
// specified.
|
|
//
|
|
if (IsTunnelEnabled(pArgs) && pArgs->pszVpnFile)
|
|
{
|
|
pVpnPage = new CVpnPage(pArgs, IDD_VPN);
|
|
|
|
if (pVpnPage)
|
|
{
|
|
PropertiesSheet.AddPage(pVpnPage);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Always include Options page
|
|
//
|
|
pOptionPage = new COptionPage(pArgs, IDD_OPTIONS);
|
|
|
|
if (pOptionPage)
|
|
{
|
|
PropertiesSheet.AddPage(pOptionPage);
|
|
}
|
|
|
|
#ifndef _WIN64
|
|
//
|
|
// Add the Advanced (Internet Connection Firewall & Internet Connection
|
|
// Sharing) property page. Display only on WindowsXP and x86. If an error occurs
|
|
// fail gracefully & continue.
|
|
//
|
|
|
|
//
|
|
// Check if this is WindowsXP and/or above and if we are allowed to display the tab
|
|
//
|
|
if (OS_NT51 && pArgs->bShowHNetCfgAdvancedTab && (FALSE == IsLogonAsSystem()))
|
|
{
|
|
PROPSHEETPAGEW psp;
|
|
|
|
ZeroMemory (&psp, sizeof(psp));
|
|
psp.dwSize = sizeof(psp);
|
|
//
|
|
// Make sure COM is initialized on this thread.
|
|
// Win95 can't find an entry in ole32.dll for CoInitializeEx since we statically link
|
|
// the lib. Need to use CoInitilize because it needs to run on plain vanilla
|
|
// Win95. Possibly we should dynamically load the dll in this case.
|
|
//
|
|
hr = CoInitialize(NULL);
|
|
if (S_OK == hr)
|
|
{
|
|
CMTRACE(TEXT("DoPropertiesPropSheets - Correctly Initialized COM."));
|
|
bCOMInitialized = TRUE;
|
|
}
|
|
else if (S_FALSE == hr)
|
|
{
|
|
CMTRACE(TEXT("DoPropertiesPropSheets - This concurrency model is already initialized. CoInitialize returned S_FALSE."));
|
|
bCOMInitialized = TRUE;
|
|
hr = S_OK;
|
|
}
|
|
else if (RPC_E_CHANGED_MODE == hr)
|
|
{
|
|
CMTRACE1(TEXT("DoPropertiesPropSheets - Using different concurrency model. Did not initialize COM - RPC_E_CHANGED_MODE. hr=0x%x"), hr);
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
CMTRACE1(TEXT("DoPropertiesPropSheets - Failed to Initialized COM. hr=0x%x"), hr);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CMTRACE(TEXT("DoPropertiesPropSheets - Get connection GUID."));
|
|
GUID *pGuid = NULL;
|
|
LPRASENTRY pRasEntry = MyRGEP(pArgs->pszRasPbk, pArgs->szServiceName, &pArgs->rlsRasLink);
|
|
|
|
if (pRasEntry && sizeof(RASENTRY_V501) >= pRasEntry->dwSize)
|
|
{
|
|
//
|
|
// Get the pGuid value
|
|
//
|
|
pGuid = &(((LPRASENTRY_V501)pRasEntry)->guidId);
|
|
|
|
hinstDll = LoadLibrary (TEXT("hnetcfg.dll"));
|
|
if (NULL == hinstDll)
|
|
{
|
|
CMTRACE1(TEXT("DoPropertiesPropSheets - could not LoadLibray hnetcfg.dll GetLastError() = 0x%x"),
|
|
GetLastError());
|
|
}
|
|
else
|
|
{
|
|
CMTRACE(TEXT("DoPropertiesPropSheets - Loaded Library hnetcfg.dll"));
|
|
pfnGetPageFunction pfnGetPage = (pfnGetPageFunction)GetProcAddress (hinstDll, "HNetGetFirewallSettingsPage");
|
|
|
|
if (!pfnGetPage)
|
|
{
|
|
CMTRACE1(TEXT("DoPropertiesPropSheets - GetProcAddress for HNetGetFirewallSettingsPage failed! 0x%x"),
|
|
GetLastError());
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Get the actual Property Sheet Page
|
|
// This function can fail if the user doesn't have the correct
|
|
// security settings (eg. is not an Administrator) This is checked
|
|
// internally in the hnetcfg.dll
|
|
//
|
|
CMTRACE(TEXT("DoPropertiesPropSheets - calling HNetGetFirewallSettingsPage"));
|
|
|
|
hr = pfnGetPage(&psp, pGuid);
|
|
if (S_OK == hr)
|
|
{
|
|
//
|
|
// Add the Property Sheet Page into our PropertiesSheet object
|
|
//
|
|
PropertiesSheet.AddExternalPage(&psp);
|
|
CMTRACE(TEXT("DoPropertiesPropSheets - Called AddExternalPage() "));
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// This error could be ERROR_ACCESS_DENIED which is ok
|
|
// so just log this. The tab will not be displayed in this case
|
|
//
|
|
if ((HRESULT)ERROR_ACCESS_DENIED == hr)
|
|
{
|
|
CMTRACE(TEXT("DoPropertiesPropSheets() - ERROR_ACCESS_DENIED. User does not have the security rights to view this tab."));
|
|
}
|
|
else
|
|
{
|
|
CMTRACE1(TEXT("DoPropertiesPropSheets() - Failed to get Propery Page. hr=0x%x"), hr);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CMTRACE(TEXT("DoPropertiesPropSheets - Failed to LoadRAS Entry."));
|
|
}
|
|
|
|
CmFree(pRasEntry);
|
|
pRasEntry = NULL;
|
|
}
|
|
}
|
|
#endif // _WIN64
|
|
|
|
//
|
|
// If NOT NT5, set the about page as the last property sheet
|
|
//
|
|
|
|
if (!(OS_NT5))
|
|
{
|
|
pAboutPage = new CAboutPage(pArgs, IDD_ABOUT);
|
|
|
|
if (pAboutPage)
|
|
{
|
|
PropertiesSheet.AddPage(pAboutPage);
|
|
}
|
|
}
|
|
|
|
//
|
|
// The service name used as mutex name
|
|
//
|
|
PropertiesSheet.m_lpszServiceName = CmStrCpyAlloc(pArgs->szServiceName);
|
|
|
|
//
|
|
// Set the title for the sheet
|
|
//
|
|
LPTSTR pszTitle = GetPropertiesDlgTitle(pArgs->szServiceName);
|
|
|
|
if (OS_W9X)
|
|
{
|
|
//
|
|
// If this is Win9x then we will call the ANSI version of the
|
|
// property sheet function. Thus we must pass it an ANSI title.
|
|
// Since the ANSI and Unicode version of the Prop Sheet Header are
|
|
// the same size (contains only string pointers not strings) whether
|
|
// ANSI or Unicode and we only have one Unicode string, lets take
|
|
// a shortcut and cast the title to an ANSI string and then call the
|
|
// A version of the API. This saves us having to have a UtoA function
|
|
// for the prop sheets when we would only be doing one string conversion.
|
|
//
|
|
LPSTR pszAnsiTitle = WzToSzWithAlloc(pszTitle);
|
|
CmFree(pszTitle);
|
|
pszTitle = (LPTSTR)pszAnsiTitle;
|
|
}
|
|
|
|
//
|
|
// Show it!
|
|
//
|
|
|
|
int iRet = PropertiesSheet.DoPropertySheet(hwndDlg, pszTitle, g_hInst);
|
|
|
|
CmFree(pszTitle);
|
|
|
|
switch(iRet)
|
|
{
|
|
case -1:
|
|
CMTRACE(TEXT("DoPropertiesPropSheets(): PropertySheet() failed"));
|
|
break;
|
|
|
|
case IDOK:
|
|
CheckConnectionAndInformUser(hwndDlg, pArgs);
|
|
break;
|
|
|
|
case 0 : // Cancel
|
|
break;
|
|
|
|
default:
|
|
MYDBGASSERT(FALSE);
|
|
break;
|
|
}
|
|
|
|
delete pInetPage;
|
|
delete pAboutPage;
|
|
delete pOptionPage;
|
|
delete pGeneralPage;
|
|
delete pVpnPage;
|
|
|
|
//
|
|
// Clean up the BalloonTip object if we have one
|
|
//
|
|
delete pArgs->pBalloonTip;
|
|
pArgs->pBalloonTip = NULL;
|
|
|
|
CmFree (PropertiesSheet.m_lpszServiceName);
|
|
PropertiesSheet.m_lpszServiceName = NULL;
|
|
|
|
|
|
//
|
|
// Clean up and Uninitilize COM
|
|
//
|
|
if (hinstDll)
|
|
{
|
|
FreeLibrary (hinstDll);
|
|
}
|
|
|
|
if (bCOMInitialized)
|
|
{
|
|
CoUninitialize();
|
|
}
|
|
|
|
CMTRACE(TEXT("End DoPropertiesPropSheets()"));
|
|
|
|
return iRet;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CheckConnectionAndInformUser
|
|
//
|
|
// Synopsis: This function is called after the user clicked OK on the
|
|
// Properties dialog. The Prop dialog can be up while the same
|
|
// profile is connected and so we need to tell the user that
|
|
// the changes won't be effective until the next time they connect.
|
|
//
|
|
// Arguments: hwnDlg - hwnd of the main dlg
|
|
// pArgs
|
|
//
|
|
// Returns: None
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void CheckConnectionAndInformUser(
|
|
HWND hwndDlg,
|
|
ArgsStruct *pArgs
|
|
)
|
|
{
|
|
CM_CONNECTION Connection;
|
|
|
|
ZeroMemory(&Connection, sizeof(CM_CONNECTION));
|
|
|
|
if (SUCCEEDED(pArgs->pConnTable->GetEntry(pArgs->szServiceName, &Connection)) &&
|
|
Connection.CmState == CM_CONNECTED)
|
|
{
|
|
LPTSTR pszTmp = CmLoadString(g_hInst, IDMSG_EFFECTIVE_NEXT_TIME);
|
|
MessageBox(hwndDlg, pszTmp, pArgs->szServiceName, MB_OK | MB_ICONINFORMATION);
|
|
CmFree(pszTmp);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
const DWORD CInetSignInDlg::m_dwHelp[] = {
|
|
IDC_INET_USERNAME_STATIC, IDH_INTERNET_USER_NAME,
|
|
IDC_INET_USERNAME, IDH_INTERNET_USER_NAME,
|
|
IDC_INET_PASSWORD_STATIC, IDH_INTERNET_PASSWORD,
|
|
IDC_INET_PASSWORD, IDH_INTERNET_PASSWORD,
|
|
IDC_INET_REMEMBER, IDH_INTERNET_SAVEPASS,
|
|
0,0};
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CInetSignInDlg::OnInitDialog
|
|
//
|
|
// Synopsis: Virtual function. Call upon WM_INITDIALOG message
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: BOOL - Return value of WM_INITDIALOG
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL CInetSignInDlg::OnInitDialog()
|
|
{
|
|
//
|
|
// Brand the dialog
|
|
//
|
|
|
|
if (m_pArgs->hSmallIcon)
|
|
{
|
|
SendMessageU(m_hWnd, WM_SETICON, ICON_SMALL, (LPARAM) m_pArgs->hSmallIcon);
|
|
}
|
|
|
|
if (m_pArgs->hBigIcon)
|
|
{
|
|
SendMessageU(m_hWnd, WM_SETICON, ICON_BIG, (LPARAM) m_pArgs->hBigIcon);
|
|
SendMessageU(GetDlgItem(m_hWnd, IDC_INET_ICON), STM_SETIMAGE, IMAGE_ICON, (LPARAM) m_pArgs->hBigIcon);
|
|
}
|
|
|
|
//
|
|
// Use should not see this dialog, if the password is optional
|
|
//
|
|
|
|
MYDBGASSERT(!m_pArgs->piniService->GPPB(c_pszCmSection,c_pszCmEntryPwdOptional));
|
|
|
|
UpdateFont(m_hWnd);
|
|
|
|
CInetPage::OnInetInit(m_hWnd, m_pArgs);
|
|
|
|
//
|
|
// if the username is empty, then we disable the OK button.
|
|
//
|
|
|
|
if (GetDlgItem(m_hWnd, IDC_INET_USERNAME) &&
|
|
!SendDlgItemMessageU(m_hWnd, IDC_INET_USERNAME, WM_GETTEXTLENGTH, 0, (LPARAM)0))
|
|
{
|
|
EnableWindow(GetDlgItem(m_hWnd, IDOK), FALSE);
|
|
}
|
|
|
|
if (GetDlgItem(m_hWnd, IDC_INET_PASSWORD) &&
|
|
!SendDlgItemMessageU(m_hWnd, IDC_INET_PASSWORD, WM_GETTEXTLENGTH, 0, (LPARAM)0))
|
|
{
|
|
EnableWindow(GetDlgItem(m_hWnd, IDOK), FALSE);
|
|
}
|
|
|
|
//
|
|
// We wouldn't be here unless data was missing, so set focus accordingly
|
|
//
|
|
|
|
if (!m_pArgs->fHideInetUsername && !*m_pArgs->szInetUserName)
|
|
{
|
|
SetFocus(GetDlgItem(m_hWnd, IDC_INET_USERNAME));
|
|
}
|
|
else
|
|
{
|
|
SetFocus(GetDlgItem(m_hWnd, IDC_INET_PASSWORD));
|
|
}
|
|
|
|
//
|
|
// Must return FALSE when setting focus
|
|
//
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CInetSignInDlg::OnOK
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_COMMAND with IDOK
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
void CInetSignInDlg::OnOK()
|
|
{
|
|
CInetPage::OnInetOk(m_hWnd, m_pArgs);
|
|
EndDialog(m_hWnd, TRUE);
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CInetSignInDlg::OnOtherCommand
|
|
//
|
|
// Synopsis: Virtual function. Call upon WM_COMMAND with command other than IDOK
|
|
// and IDCANCEL
|
|
//
|
|
// Arguments: WPARAM wParam - wParam of WM_COMMAND
|
|
// LPARAM -
|
|
//
|
|
// Returns: DWORD -
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CInetSignInDlg::OnOtherCommand(WPARAM wParam, LPARAM)
|
|
{
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDC_INET_USERNAME:
|
|
case IDC_INET_PASSWORD:
|
|
//
|
|
// User typed something in username or password
|
|
//
|
|
if (HIWORD(wParam) == EN_CHANGE)
|
|
{
|
|
BOOL fHasUserName = TRUE;
|
|
|
|
if (GetDlgItem(m_hWnd, IDC_INET_USERNAME))
|
|
{
|
|
fHasUserName = !!SendDlgItemMessageU(m_hWnd,
|
|
IDC_INET_USERNAME,
|
|
WM_GETTEXTLENGTH, 0, 0);
|
|
}
|
|
|
|
BOOL fHasPassword = TRUE;
|
|
|
|
if (GetDlgItem(m_hWnd, IDC_INET_PASSWORD))
|
|
{
|
|
fHasPassword = !!SendDlgItemMessageU(m_hWnd,
|
|
IDC_INET_PASSWORD,
|
|
WM_GETTEXTLENGTH, 0, 0);
|
|
}
|
|
|
|
//
|
|
// Enable OK button only if both user name and password is available
|
|
//
|
|
|
|
EnableWindow(GetDlgItem(m_hWnd, IDOK), fHasUserName && fHasPassword);
|
|
|
|
if (!m_pArgs->fHideRememberInetPassword && !m_pArgs->fHideInetPassword)
|
|
{
|
|
//
|
|
// Enable/Disable check/uncheck the "Save Password" accordingly
|
|
// fPasswordOptional is always FALSE for the dialog
|
|
//
|
|
CInetPage::AdjustSavePasswordCheckBox(GetDlgItem(m_hWnd, IDC_INET_REMEMBER),
|
|
!fHasPassword, m_pArgs->fDialAutomatically, FALSE);
|
|
}
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CGeneralPage::SubClassEditProc
|
|
//
|
|
// Synopsis: Proc to subclass the edit controls in the Dial propsheet.
|
|
//
|
|
// Arguments: hwnd [wnd handle]
|
|
// uMsg [wnd msg]
|
|
// lParam [LPARAM]
|
|
// wParam [WPARAM]
|
|
//
|
|
// Returns: NONE
|
|
//
|
|
// History: henryt Created 3/24/97
|
|
// byao Modified 4/3/97 Added new code to handle description field,
|
|
// phone number field, etc.
|
|
// henryt Modified 5/1/97 New UI.
|
|
// nickball Modified 6/18/97 Moved GetParent call and added
|
|
// NC_DESTROY handling for CM16
|
|
// nickball Modified 7/10/97 Commented out removal of description
|
|
// nickball Modified 7/10/97 Implemented ClearDialAsLongDistance
|
|
// fengsun Modified 11/3/97 Changed into static member function
|
|
// nickball Modified 09/16/98 Renamed ClearDialAsLongDistance to ClearUseDialingRules
|
|
//----------------------------------------------------------------------------
|
|
LRESULT CALLBACK CGeneralPage::SubClassEditProc(HWND hwnd, UINT uMsg,
|
|
WPARAM wParam, LPARAM lParam)
|
|
{
|
|
//
|
|
// If user types a non-tapi character Beep and do not accept that character
|
|
//
|
|
|
|
if ((uMsg == WM_CHAR) && (VK_BACK != wParam))
|
|
{
|
|
if (!IsValidPhoneNumChar((TCHAR)wParam))
|
|
{
|
|
|
|
Beep(2000, 100);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Call the original window procedure for default processing.
|
|
//
|
|
LRESULT lres = CallWindowProcU(m_pfnOrgEditWndProc, hwnd, uMsg, wParam, lParam);
|
|
|
|
//
|
|
// if the user is typing a phone # in the edit control, then there is
|
|
// no phone book file associated with the #.
|
|
// make sure we ignore CTRL-C(VK_CANCEL) because the user is just doing a copy.
|
|
//
|
|
if ( ( uMsg == WM_CHAR && wParam != VK_CANCEL ) ||
|
|
( uMsg == WM_KEYDOWN && wParam == VK_DELETE) ||
|
|
( uMsg == WM_PASTE))
|
|
{
|
|
//
|
|
// Either primary or backup edit control
|
|
//
|
|
DWORD dwControlId = (DWORD) GetWindowLongU(hwnd, GWL_ID);
|
|
MYDBGASSERT(dwControlId == IDC_GENERAL_PRIMARY_EDIT ||
|
|
dwControlId == IDC_GENERAL_BACKUP_EDIT);
|
|
|
|
//
|
|
// Get the object pointer saved by SetWindowLong
|
|
//
|
|
CGeneralPage* pGeneralPage = (CGeneralPage*)GetWindowLongU(hwnd, GWLP_USERDATA);
|
|
MYDBGASSERT(pGeneralPage);
|
|
|
|
pGeneralPage->ClearUseDialingRules(dwControlId == IDC_GENERAL_PRIMARY_EDIT ? 0 : 1);
|
|
}
|
|
|
|
return lres;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: SubClassPropSheetProc
|
|
//
|
|
// Synopsis: Proc to subclass the parent property sheet dlg.
|
|
//
|
|
// Arguments: hwnd [wnd handle]
|
|
// uMsg [wnd msg]
|
|
// lParam [LPARAM]
|
|
// wParam [WPARAM]
|
|
//
|
|
// Returns: NONE
|
|
//
|
|
// History: henryt Created 6/11/97
|
|
//----------------------------------------------------------------------------
|
|
LRESULT CALLBACK CPropertiesSheet::SubClassPropSheetProc(HWND hwnd, UINT uMsg, WPARAM wParam,LPARAM lParam)
|
|
{
|
|
switch (uMsg)
|
|
{
|
|
case WM_COMMAND:
|
|
//
|
|
// If ok is pressed, save the index of the tab
|
|
// So, the next time user comes to properties, the same tab will be displayed
|
|
//
|
|
|
|
if (LOWORD(wParam) == IDOK && HIWORD(wParam) == BN_CLICKED)
|
|
{
|
|
CPropertiesSheet* pPropSheet = (CPropertiesSheet*)GetWindowLongU(hwnd, GWLP_USERDATA);
|
|
MYDBGASSERT(pPropSheet);
|
|
|
|
//
|
|
// Declare a mutex to prevent multi-instance write to the same profile
|
|
//
|
|
CNamedMutex propertiesMutex;
|
|
|
|
//
|
|
// Use the profile name as the mutex name
|
|
// If we lock timed out, go ahead and save the properties
|
|
// The destructor of the mutex will release the lock
|
|
//
|
|
MYVERIFY(propertiesMutex.Lock(pPropSheet->m_lpszServiceName, TRUE, WRITE_PROPERTIES_MUTEX_TIMEOUT));
|
|
|
|
LRESULT dwRes = CallWindowProcU(m_pfnOrgPropSheetProc, hwnd, uMsg, wParam, lParam);
|
|
|
|
return dwRes;
|
|
}
|
|
case WM_MOVING:
|
|
{
|
|
CPropertiesSheet* pPropSheet = (CPropertiesSheet*)GetWindowLongU(hwnd, GWLP_USERDATA);
|
|
|
|
if (pPropSheet && pPropSheet->m_pArgs && pPropSheet->m_pArgs->pBalloonTip)
|
|
{
|
|
pPropSheet->m_pArgs->pBalloonTip->HideBalloonTip();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Call the original window procedure for default processing.
|
|
//
|
|
return CallWindowProcU(m_pfnOrgPropSheetProc, hwnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CPropertiesSheet::PropSheetProc
|
|
//
|
|
// Synopsis: Callback function for the propertysheet. PSCB_INITIALIZED is
|
|
// called before any page is initialized. Initialize the property
|
|
// page here
|
|
//
|
|
// Arguments: HWND hwndDlg - PropertySheet window handle
|
|
// UINT uMsg - Message id
|
|
// LPARAM -
|
|
//
|
|
// Returns: int CALLBACK -
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
int CALLBACK CPropertiesSheet::PropSheetProc(HWND hwndDlg, UINT uMsg, LPARAM lParam)
|
|
{
|
|
if (uMsg == PSCB_INITIALIZED)
|
|
{
|
|
MYDBGASSERT(hwndDlg);
|
|
|
|
//
|
|
// Save the m_pThis pointer, so it can be accessed by SubClassPropSheetProc
|
|
//
|
|
MYDBGASSERT(m_pThis);
|
|
SetWindowLongU(hwndDlg, GWLP_USERDATA, (LONG_PTR)m_pThis);
|
|
m_pThis = NULL;
|
|
|
|
//
|
|
// subclass the property sheet
|
|
//
|
|
m_pfnOrgPropSheetProc = (WNDPROC)SetWindowLongU(hwndDlg, GWLP_WNDPROC, (LONG_PTR)SubClassPropSheetProc);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function CGeneralPage::DisplayMungedPhone
|
|
//
|
|
// Synopsis Apply TAPI rules to the phone number, and then display it
|
|
// in the edit control
|
|
//
|
|
// Arguments uiPhoneIdx The index of the phone #
|
|
//
|
|
// Returns FALSE if the number can't be munged
|
|
//
|
|
// History 4/2/97 byao Modified to current implementation
|
|
// 4/30/97 henryt added/deleted params
|
|
// 5/17/97 VetriV Added functionality to return
|
|
// displayable number
|
|
// 11/3/97 fengsun Changed into member function
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
BOOL CGeneralPage::DisplayMungedPhone(UINT uiPhoneIdx)
|
|
{
|
|
LPTSTR pszPhone;
|
|
LPTSTR pszTmpDialableString = NULL;
|
|
BOOL bRet = TRUE;
|
|
|
|
//
|
|
// If DialingRules is turned off, just use what we already have, no munge.
|
|
//
|
|
|
|
if (m_pArgs->fNoDialingRules)
|
|
{
|
|
lstrcpynU(m_DialInfo[uiPhoneIdx].szDisplayablePhoneNumber, m_DialInfo[uiPhoneIdx].szPhoneNumber,
|
|
CELEMS(m_DialInfo[uiPhoneIdx].szDisplayablePhoneNumber));
|
|
|
|
lstrcpynU(m_DialInfo[uiPhoneIdx].szDialablePhoneNumber, m_DialInfo[uiPhoneIdx].szPhoneNumber,
|
|
CELEMS(m_DialInfo[uiPhoneIdx].szDialablePhoneNumber));
|
|
|
|
m_DialInfo[uiPhoneIdx].szCanonical[0] = TEXT('\0');
|
|
|
|
SetDlgItemTextU(m_hWnd, (uiPhoneIdx? IDC_GENERAL_BACKUP_EDIT : IDC_GENERAL_PRIMARY_EDIT), m_DialInfo[uiPhoneIdx].szPhoneNumber);
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Retrieve the canonical form of the number for munging
|
|
//
|
|
pszPhone = CmStrCpyAlloc(m_DialInfo[uiPhoneIdx].szCanonical);
|
|
|
|
if (pszPhone)
|
|
{
|
|
if (*pszPhone && m_szDeviceName[0])
|
|
{
|
|
//
|
|
// Apply tapi rules only when there's a modem selected. We now munge the phone
|
|
// even if there is no description because we want to pick up tone and pulse.
|
|
//
|
|
if (ERROR_SUCCESS != MungePhone(m_szDeviceName,
|
|
&pszPhone,
|
|
&m_pArgs->tlsTapiLink,
|
|
g_hInst,
|
|
m_DialInfo[uiPhoneIdx].dwPhoneInfoFlags & PIF_USE_DIALING_RULES,
|
|
&pszTmpDialableString,
|
|
m_pArgs->fAccessPointsEnabled))
|
|
{
|
|
//
|
|
// Munge failed, make sure that ptrs are valid, albeit empty
|
|
//
|
|
|
|
CmFree(pszPhone);
|
|
pszPhone = CmStrCpyAlloc(TEXT("")); // CmFmtMsg(g_hInst, IDMSG_CANTFORMAT);
|
|
pszTmpDialableString = CmStrCpyAlloc(TEXT("")); // CmFmtMsg(g_hInst, IDMSG_CANTFORMAT);
|
|
bRet = FALSE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Standard procedure. If Dialing rule are applied, then use the
|
|
// canonical form (eg. pszPhone). Otherwise use the raw number form.
|
|
//
|
|
|
|
if (m_DialInfo[uiPhoneIdx].dwPhoneInfoFlags & PIF_USE_DIALING_RULES)
|
|
{
|
|
//
|
|
// Unique situation in which we have read in a legacy hand-edited
|
|
// phone number and the default dialing-rules state is TRUE/ON.
|
|
// We fake out the standard procedure by slipping the raw number
|
|
// into the otherwise blank pszPhone. Note: This occurs only the
|
|
// first time the app. is run until a save is made at which time
|
|
// the current storage format is used.
|
|
//
|
|
|
|
if (!*pszPhone)
|
|
{
|
|
pszPhone = CmStrCatAlloc(&pszPhone, m_DialInfo[uiPhoneIdx].szPhoneNumber);
|
|
}
|
|
|
|
//
|
|
// In this case the pszPhone is dynamically allocated and can be very long. In order to
|
|
// fix this, we need to trim the string if it's longer than what should fit in the UI.
|
|
//
|
|
LRESULT lEditLen = SendDlgItemMessageU(m_hWnd, (uiPhoneIdx? IDC_GENERAL_BACKUP_EDIT : IDC_GENERAL_PRIMARY_EDIT), EM_GETLIMITTEXT, 0, 0);
|
|
|
|
if (lstrlenU(pszPhone) >= ((INT)lEditLen))
|
|
{
|
|
pszPhone[lEditLen] = TEXT('\0');
|
|
}
|
|
|
|
SetDlgItemTextU(m_hWnd, (uiPhoneIdx? IDC_GENERAL_BACKUP_EDIT : IDC_GENERAL_PRIMARY_EDIT), pszPhone);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// No need to trim anything, since the structure is providing the phone number. Eventully the
|
|
// number from the UI will go back into the phone number structure and we know it will fit
|
|
// since it came from there.
|
|
//
|
|
SetDlgItemTextU(m_hWnd, (uiPhoneIdx? IDC_GENERAL_BACKUP_EDIT : IDC_GENERAL_PRIMARY_EDIT), m_DialInfo[uiPhoneIdx].szPhoneNumber);
|
|
}
|
|
}
|
|
|
|
//
|
|
// copy the munged phone to the caller's buffer.
|
|
//
|
|
|
|
if (pszTmpDialableString)
|
|
{
|
|
lstrcpynU(m_DialInfo[uiPhoneIdx].szDialablePhoneNumber, pszTmpDialableString,
|
|
CELEMS(m_DialInfo[uiPhoneIdx].szDialablePhoneNumber));
|
|
}
|
|
|
|
if (pszPhone)
|
|
{
|
|
lstrcpynU(m_DialInfo[uiPhoneIdx].szDisplayablePhoneNumber, pszPhone,
|
|
CELEMS(m_DialInfo[uiPhoneIdx].szDisplayablePhoneNumber));
|
|
}
|
|
|
|
CmFree(pszPhone);
|
|
CmFree(pszTmpDialableString);
|
|
|
|
return bRet;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function CGeneralPage::OnDialingProperties
|
|
//
|
|
// Synopsis Handler for handling the "Dialing Properties..." button-click
|
|
// in the 'Dialing' tab.
|
|
//
|
|
// Arguments
|
|
//
|
|
// History 4/30/97 henryt modified for new UI
|
|
// 11/3/97 fengsun Change the function name and make it
|
|
// a member ffunction
|
|
// 01/29/98 cleaned up memory leak, added comments.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CGeneralPage::OnDialingProperties()
|
|
{
|
|
LONG lRes;
|
|
LPTSTR pszPhone = NULL;
|
|
|
|
//
|
|
// Use primary or backup to seed tapi dialog depending on whether dialing
|
|
// rules are being applied to the number. We use the check state rather
|
|
// than the phone-info flag because of the anomolous first time case in
|
|
// which the flag is set, but the controls aren't checked.
|
|
//
|
|
|
|
if (IsDlgButtonChecked(m_hWnd, IDC_GENERAL_UDR1_CHECKBOX))
|
|
{
|
|
pszPhone = CmStrCpyAlloc(m_DialInfo[0].szCanonical);//szPhoneNumber);
|
|
}
|
|
else if (IsDlgButtonChecked(m_hWnd, IDC_GENERAL_UDR2_CHECKBOX))
|
|
{
|
|
pszPhone = CmStrCpyAlloc(m_DialInfo[1].szCanonical);//szPhoneNumber);
|
|
}
|
|
else
|
|
{
|
|
pszPhone = CmStrCpyAlloc(TEXT(" "));
|
|
}
|
|
|
|
//
|
|
// Launch TAPI dialog for DialingRules configuration
|
|
//
|
|
|
|
if (!m_pArgs->tlsTapiLink.pfnlineTranslateDialog)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!SetTapiDevice(g_hInst,&m_pArgs->tlsTapiLink,m_szDeviceName))
|
|
{
|
|
MYDBGASSERT(FALSE);
|
|
return;
|
|
}
|
|
|
|
if (OS_W9X)
|
|
{
|
|
//
|
|
// On win9x, we are linked to the ANSI version of lineTranslateDialog, thus
|
|
// we need to convert the string. In order to keep things simpler, we just
|
|
// cast the converted LPSTR as an LPWSTR and pass it on.
|
|
//
|
|
|
|
LPSTR pszAnsiPhone = WzToSzWithAlloc(pszPhone);
|
|
CmFree(pszPhone);
|
|
pszPhone = (LPTSTR)pszAnsiPhone;
|
|
}
|
|
|
|
lRes = m_pArgs->tlsTapiLink.pfnlineTranslateDialog(m_pArgs->tlsTapiLink.hlaLine,
|
|
m_pArgs->tlsTapiLink.dwDeviceId,
|
|
m_pArgs->tlsTapiLink.dwApiVersion,
|
|
m_hWnd,
|
|
pszPhone);
|
|
CmFree(pszPhone);
|
|
|
|
CMTRACE1(TEXT("OnDialingProperties() lineTranslateDialog() returns %u"), lRes);
|
|
|
|
|
|
//
|
|
// We do not know whether user changed anything (WIN32), so re-munge anyway
|
|
//
|
|
|
|
if (lRes == ERROR_SUCCESS)
|
|
{
|
|
DWORD dwCurrentTapiLoc = GetCurrentTapiLocation(&m_pArgs->tlsTapiLink);
|
|
|
|
if (-1 != dwCurrentTapiLoc)
|
|
{
|
|
if (dwCurrentTapiLoc != m_pArgs->tlsTapiLink.dwTapiLocationForAccessPoint)
|
|
{
|
|
m_bAPInfoChanged = TRUE;
|
|
}
|
|
|
|
m_pArgs->tlsTapiLink.dwTapiLocationForAccessPoint = dwCurrentTapiLoc;
|
|
|
|
for (UINT i = 0; i < m_NumPhones; i++)
|
|
{
|
|
//
|
|
// Only munge if Use Dialing Rules is available
|
|
//
|
|
|
|
if (m_DialInfo[i].dwPhoneInfoFlags & PIF_USE_DIALING_RULES)
|
|
{
|
|
DisplayMungedPhone(i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function CGeneralPage::OnPhoneBookButton
|
|
//
|
|
// Synopsis Handler for handling the "Phone Book..." button-click
|
|
// in the 'Dialing' tab.
|
|
//
|
|
// Arguments nPhoneIdx phone index
|
|
//
|
|
// History 4/30/97 henryt modified for new UI
|
|
// 11/3/97 fengsun Change to a member function
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CGeneralPage::OnPhoneBookButton(UINT nPhoneIdx)
|
|
{
|
|
PBArgs sArgs;
|
|
LPTSTR pszTmp;
|
|
UINT nEditID = !nPhoneIdx ? IDC_GENERAL_PRIMARY_EDIT: IDC_GENERAL_BACKUP_EDIT;
|
|
//UINT nDescID = !nPhoneIdx ? IDC_GENERAL_PRIMARYDESC_DISPLAY: IDC_GENERAL_BACKUPDESC_DISPLAY;
|
|
|
|
UINT nUdrID = !nPhoneIdx? IDC_GENERAL_UDR1_CHECKBOX : IDC_GENERAL_UDR2_CHECKBOX;
|
|
BOOL bRes;
|
|
UINT uiSrc;
|
|
BOOL bBlankPhone = FALSE;
|
|
|
|
memset(&sArgs,0,sizeof(sArgs));
|
|
|
|
sArgs.pszCMSFile = m_pArgs->piniService->GetFile();
|
|
|
|
//
|
|
// Update the attributes of the users phone number selection to reflect
|
|
// any interim changes. This ensures that we will default to the correct
|
|
// service, country and region of the current phone number selection. (4397)
|
|
//
|
|
|
|
if (nPhoneIdx && !GetWindowTextLengthU(GetDlgItem(m_hWnd, nEditID)))
|
|
{
|
|
//
|
|
// if we're changing the backup # and currently the backup # is empty,
|
|
// we use the state and country info of the primary #.
|
|
//
|
|
uiSrc = 0;
|
|
}
|
|
else
|
|
{
|
|
uiSrc = nPhoneIdx;
|
|
}
|
|
|
|
lstrcpynU(sArgs.szServiceType, m_DialInfo[uiSrc].szServiceType, CELEMS(sArgs.szServiceType));
|
|
|
|
sArgs.dwCountryId = m_DialInfo[uiSrc].dwCountryID;
|
|
|
|
lstrcpynU(sArgs.szRegionName, m_DialInfo[uiSrc].szRegionName, CELEMS(sArgs.szRegionName));
|
|
|
|
sArgs.pszMessage = m_pArgs->piniService->GPPS(c_pszCmSection, c_pszCmEntryPbMessage);
|
|
|
|
//
|
|
// Check to see if the phone number is blank. We need to save this off for
|
|
// balloon tips to use later.
|
|
//
|
|
|
|
if(0 == GetWindowTextLengthU(GetDlgItem(m_hWnd,nEditID)))
|
|
{
|
|
bBlankPhone = TRUE;
|
|
}
|
|
|
|
//
|
|
// Make sure that bitmap path is complete
|
|
//
|
|
|
|
pszTmp = m_pArgs->piniService->GPPS(c_pszCmSection, c_pszCmEntryPbLogo);
|
|
if (pszTmp && *pszTmp)
|
|
{
|
|
sArgs.pszBitmap = CmConvertRelativePath(m_pArgs->piniService->GetFile(), pszTmp);
|
|
}
|
|
CmFree(pszTmp);
|
|
|
|
//
|
|
// Include the help file name
|
|
//
|
|
|
|
sArgs.pszHelpFile = m_pArgs->pszHelpFile;
|
|
|
|
//
|
|
// Need the master palette handle also.
|
|
//
|
|
|
|
sArgs.phMasterPalette = &m_pArgs->hMasterPalette;
|
|
|
|
//
|
|
// Launch the phonebook dlg
|
|
//
|
|
|
|
bRes = DisplayPhoneBook(m_hWnd,&sArgs, m_pArgs->fHasValidTopLevelPBK, m_pArgs->fHasValidReferencedPBKs);
|
|
|
|
CmFree(sArgs.pszMessage);
|
|
CmFree(sArgs.pszBitmap);
|
|
|
|
if (!bRes)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// We have a new phone number selected, update phone number buffers.
|
|
// and configure UI accordingly. If no dialing rules, the its a non
|
|
// issue, leave it as is.
|
|
//
|
|
|
|
m_bAPInfoChanged = TRUE;
|
|
if (!m_pArgs->fNoDialingRules)
|
|
{
|
|
EnableWindow(GetDlgItem(m_hWnd, nUdrID), TRUE);
|
|
CheckDlgButton(m_hWnd, nUdrID, (m_DialInfo[nPhoneIdx].dwPhoneInfoFlags & PIF_USE_DIALING_RULES));
|
|
|
|
//
|
|
// Set TAPI button display according to dialing rules use.
|
|
//
|
|
|
|
UpdateDialingRulesButton();
|
|
}
|
|
|
|
//
|
|
// Copy the new info in the tmp phone info array. First we
|
|
// Get the new phonebook name, which should be a full path
|
|
//
|
|
|
|
MYDBGASSERT(FileExists(sArgs.szPhoneBookFile));
|
|
|
|
lstrcpynU(m_DialInfo[nPhoneIdx].szPhoneBookFile, sArgs.szPhoneBookFile,
|
|
CELEMS(m_DialInfo[nPhoneIdx].szPhoneBookFile));
|
|
|
|
lstrcpynU(m_DialInfo[nPhoneIdx].szDUN, sArgs.szDUNFile,
|
|
CELEMS(m_DialInfo[nPhoneIdx].szDUN));
|
|
|
|
//
|
|
// Remove the first element (country code) from the non-canonical number
|
|
//
|
|
|
|
StripFirstElement(sArgs.szNonCanonical);
|
|
|
|
//
|
|
// If there was no area code, then we'll have a leading space, trim it
|
|
//
|
|
|
|
CmStrTrim(sArgs.szNonCanonical);
|
|
|
|
//
|
|
// Update our buffers
|
|
//
|
|
|
|
lstrcpynU(m_DialInfo[nPhoneIdx].szPhoneNumber, sArgs.szNonCanonical, CELEMS(m_DialInfo[nPhoneIdx].szPhoneNumber));
|
|
lstrcpynU(m_DialInfo[nPhoneIdx].szCanonical, sArgs.szCanonical, CELEMS(m_DialInfo[nPhoneIdx].szCanonical));
|
|
lstrcpynU(m_DialInfo[nPhoneIdx].szDesc, sArgs.szDesc, CELEMS(m_DialInfo[nPhoneIdx].szDesc));
|
|
|
|
m_DialInfo[nPhoneIdx].dwCountryID = sArgs.dwCountryId;
|
|
|
|
//
|
|
// Store attributes of user selection (ie.service, country, region)
|
|
// We will store this data permanently if the user exits with an OK.
|
|
// It is also used if the user returns to the PB dialog (4397)
|
|
//
|
|
|
|
lstrcpynU(m_DialInfo[nPhoneIdx].szServiceType,
|
|
sArgs.szServiceType, CELEMS(m_DialInfo[nPhoneIdx].szServiceType));
|
|
lstrcpynU(m_DialInfo[nPhoneIdx].szRegionName,
|
|
sArgs.szRegionName, CELEMS(m_DialInfo[nPhoneIdx].szRegionName));
|
|
//
|
|
// Display the current phone number and update the description.
|
|
//
|
|
|
|
DisplayMungedPhone(nPhoneIdx);
|
|
|
|
//
|
|
// Update the description display
|
|
//
|
|
|
|
UpdateNumberDescription(nPhoneIdx, sArgs.szDesc);
|
|
|
|
//SetDlgItemText(m_hWnd, nDescID, sArgs.szDesc);
|
|
|
|
|
|
|
|
|
|
//
|
|
// Check for and display balloon tips if enabled
|
|
//
|
|
if (m_pArgs->fHideBalloonTips)
|
|
{
|
|
CMTRACE(TEXT("Balloon tips are disabled."));
|
|
}
|
|
else
|
|
{
|
|
RECT rect;
|
|
POINT point = {0,0};
|
|
LPTSTR pszBalloonTitle = NULL;
|
|
LPTSTR pszBalloonMsg = NULL;
|
|
|
|
HWND hwndParent = GetParent(m_hWnd);
|
|
HWND hwndTAPIButton = GetDlgItem(m_hWnd, IDC_GENERAL_TAPI_BUTTON);
|
|
HWND hwndPrimaryDRCheckbox = GetDlgItem(m_hWnd, IDC_GENERAL_UDR1_CHECKBOX);
|
|
HWND hwndNewAPButton = GetDlgItem(m_hWnd, IDC_GENERAL_NEWAP_BUTTON);
|
|
|
|
MYDBGASSERT(hwndParent);
|
|
MYDBGASSERT(hwndTAPIButton);
|
|
MYDBGASSERT(hwndPrimaryDRCheckbox);
|
|
MYDBGASSERT(hwndNewAPButton);
|
|
|
|
if (hwndParent && hwndTAPIButton && hwndPrimaryDRCheckbox && hwndNewAPButton)
|
|
{
|
|
//
|
|
// Get the BalloonTipsDisplayed flags from the registry
|
|
//
|
|
DWORD dwBalloonTipsDisplayed = m_pArgs->piniBothNonFav->GPPI(c_pszCmSection, c_pszCmEntryBalloonTipsDisplayed, NULL);
|
|
|
|
//
|
|
// If the primary button was clicked and the edit control is blank, we will try to display the Dialing Rules balloon tip,
|
|
// else we will try to display the access point balloon tip.
|
|
//
|
|
if (bBlankPhone)
|
|
{
|
|
//
|
|
// We only display if the primary Dialing Rules checkbox is enabled. Then if the Dialing Rules button is enabled,
|
|
// we point the balloon tip to the button, otherwise we will point it to the checkbox.
|
|
//
|
|
if (IsWindowEnabled(hwndPrimaryDRCheckbox) && !nPhoneIdx)
|
|
{
|
|
pszBalloonTitle = CmLoadString(g_hInst, IDMSG_BALLOON_TITLE_DIALINGRULES);
|
|
pszBalloonMsg = CmLoadString(g_hInst, IDMSG_BALLOON_MSG_DIALINGRULES);
|
|
|
|
if (IsWindowEnabled(hwndTAPIButton))
|
|
{
|
|
if (GetWindowRect(hwndTAPIButton, &rect))
|
|
{
|
|
//
|
|
// Get the coordinates of the Dialing Rules button. We want the balloon tip to point
|
|
// to half way up the button and 10px left of the right edge.
|
|
//
|
|
point.x = rect.right - 10;
|
|
point.y = ((rect.bottom - rect.top) / 2) + rect.top;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (GetWindowRect(hwndPrimaryDRCheckbox, &rect))
|
|
{
|
|
//
|
|
// Get the coordinates of the Primary Dialing Rules checkbox. We want the balloon tip to point
|
|
// to the center of the checkbox.
|
|
//
|
|
point.x = rect.left + 10;
|
|
point.y = ((rect.bottom - rect.top) / 2) + rect.top;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Update the registry flag to reset the Access Point balloon tip if the dialing rules balloon tip is displayed
|
|
//
|
|
if (dwBalloonTipsDisplayed & BT_ACCESS_POINTS)
|
|
{
|
|
dwBalloonTipsDisplayed = dwBalloonTipsDisplayed & ~BT_ACCESS_POINTS;
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
// We display only if Access Points are not enabled and the phone number
|
|
// edit control is not blank.
|
|
//
|
|
if(!m_pArgs->fAccessPointsEnabled && !nPhoneIdx)
|
|
{
|
|
|
|
//
|
|
// Check to see if we have displayed this balloon tip before.
|
|
//
|
|
if (!(dwBalloonTipsDisplayed & BT_ACCESS_POINTS))
|
|
{
|
|
|
|
pszBalloonTitle = CmLoadString(g_hInst, IDMSG_BALLOON_TITLE_ACCESSPOINT);
|
|
pszBalloonMsg = CmLoadString(g_hInst, IDMSG_BALLOON_MSG_ACCESSPOINT);
|
|
|
|
if (GetWindowRect(hwndNewAPButton, &rect))
|
|
{
|
|
//
|
|
// Get the coordinates for the New Access Point button. We want the balloon tip to point
|
|
// to half way up the button and 10px left of the right edge.
|
|
//
|
|
point.x = rect.right - 10;
|
|
point.y = ((rect.bottom - rect.top) / 2) + rect.top;
|
|
|
|
//
|
|
// Update registry value
|
|
//
|
|
dwBalloonTipsDisplayed = dwBalloonTipsDisplayed | BT_ACCESS_POINTS;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Verify we have the info we need and display the balloon tip
|
|
//
|
|
if (pszBalloonTitle && pszBalloonMsg && point.x && point.y)
|
|
{
|
|
if (m_pArgs && m_pArgs->pBalloonTip)
|
|
{
|
|
if (m_pArgs->pBalloonTip->DisplayBalloonTip(&point, TTI_INFO, pszBalloonTitle, pszBalloonMsg, hwndParent))
|
|
{
|
|
//
|
|
// Write the updated BalloonTipsDisplay flag to the registry
|
|
//
|
|
m_pArgs->piniBothNonFav->WPPI(c_pszCmSection, c_pszCmEntryBalloonTipsDisplayed, dwBalloonTipsDisplayed);
|
|
}
|
|
else
|
|
{
|
|
CMTRACE3(TEXT("BalloonTip failed to display - %s; at coordinates{%li,%li}"),pszBalloonTitle,point.x,point.y);
|
|
}
|
|
}
|
|
}
|
|
|
|
CmFree(pszBalloonTitle);
|
|
CmFree(pszBalloonMsg);
|
|
}
|
|
}
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HaveContextHelp
|
|
//
|
|
// Synopsis: Whether a specific control id has context help
|
|
// This function very easily introducce inconsistance
|
|
// Every dialog should manage its own control, instead having this
|
|
// function keep track of all the controls.
|
|
//
|
|
// Arguments: hwndDlg the hwnd of parent dlg
|
|
// hwndCtrl the hwnd of control
|
|
//
|
|
// Returns: NONE
|
|
//
|
|
// History: henryt Created 6/26/97
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
BOOL HaveContextHelp(
|
|
HWND hwndDlg,
|
|
HWND hwndCtrl
|
|
)
|
|
{
|
|
//
|
|
// list of controls that we don't provide context help for
|
|
//
|
|
static const int rgiNoContextHelpCtrlId[] =
|
|
{
|
|
IDC_MAIN_BITMAP,
|
|
IDC_PHONEBOOK_BITMAP,
|
|
IDC_GENERAL_PHONENUMBERS_GROUPBOX,
|
|
// IDC_GENERAL_PRIMARYDESC_DISPLAY,
|
|
// IDC_GENERAL_BACKUPDESC_DISPLAY,
|
|
// IDC_ABOUT_BITMAP,
|
|
IDC_ABOUT_FRAME,
|
|
IDC_ABOUT_VERSION,
|
|
IDC_ABOUT_WARNING,
|
|
IDC_ABOUT_CM_STATIC,
|
|
IDC_ABOUT_VERSION_STATIC,
|
|
IDC_ABOUT_COPYRIGHT_STATIC,
|
|
IDC_ABOUT_SHOCKWAVE_STATIC,
|
|
IDC_INET_ICON,
|
|
IDC_CONNSTAT_ICON,
|
|
IDC_CONNSTAT_DURATION_DISPLAY,
|
|
IDC_CONNSTAT_SPEED_DISPLAY,
|
|
IDC_CONNSTAT_RECEIVED_DISPLAY,
|
|
IDC_CONNSTAT_SENT_DISPLAY,
|
|
IDC_CONNSTAT_DISCONNECT_DISPLAY,
|
|
IDC_DETAILINFO,
|
|
IDC_CONNSTAT_STATIC_CALL_DURATION,
|
|
IDC_CONNSTAT_STATIC_CONNECT_SPEED,
|
|
IDC_CONNSTAT_STATIC_BYTES_RECEIVED,
|
|
IDC_CONNSTAT_STATIC_BYTES_SENT
|
|
};
|
|
|
|
UINT uIdx, uLast;
|
|
|
|
MYDBGASSERT(hwndDlg);
|
|
MYDBGASSERT(hwndCtrl);
|
|
|
|
for (uIdx=0, uLast=sizeof(rgiNoContextHelpCtrlId)/sizeof(rgiNoContextHelpCtrlId[0]);
|
|
uIdx < uLast; uIdx++)
|
|
{
|
|
if (GetDlgItem(hwndDlg, rgiNoContextHelpCtrlId[uIdx]) == hwndCtrl)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
return (uIdx == uLast);
|
|
}
|
|
|
|
// check if TAPI has its information, put up dialog if not
|
|
BOOL CGeneralPage::CheckTapi(TapiLinkageStruct *ptlsTapiLink, HINSTANCE hInst)
|
|
{
|
|
LONG lRes;
|
|
LPLINETRANSLATEOUTPUT pltoOutput = NULL;
|
|
DWORD dwLen;
|
|
BOOL bRet = FALSE;
|
|
|
|
if (!SetTapiDevice(hInst,ptlsTapiLink,m_szDeviceName))
|
|
{
|
|
return bRet;
|
|
}
|
|
|
|
dwLen = sizeof(*pltoOutput) + (1024 * sizeof(TCHAR));
|
|
pltoOutput = (LPLINETRANSLATEOUTPUT) CmMalloc(dwLen);
|
|
if (NULL == pltoOutput)
|
|
{
|
|
return bRet;
|
|
}
|
|
|
|
pltoOutput->dwTotalSize = dwLen;
|
|
|
|
lRes = ptlsTapiLink->pfnlineTranslateAddress(ptlsTapiLink->hlaLine,
|
|
ptlsTapiLink->dwDeviceId,
|
|
ptlsTapiLink->dwApiVersion,
|
|
TEXT("1234"),
|
|
0,
|
|
LINETRANSLATEOPTION_CANCELCALLWAITING,
|
|
pltoOutput);
|
|
//
|
|
// If the line translate failed, then execute the Dialing Rules UI by calling
|
|
// lineTranslateDialog (inside OnDialingProperties). Providing that the user
|
|
// completes the UI, TAPI will be initialized and ready for use.
|
|
//
|
|
|
|
if (ERROR_SUCCESS != lRes)
|
|
{
|
|
OnDialingProperties();
|
|
|
|
//
|
|
// The user may have canceled, so test again before declaring success
|
|
//
|
|
|
|
lRes = ptlsTapiLink->pfnlineTranslateAddress(ptlsTapiLink->hlaLine,
|
|
ptlsTapiLink->dwDeviceId,
|
|
ptlsTapiLink->dwApiVersion,
|
|
TEXT("1234"),
|
|
0,
|
|
LINETRANSLATEOPTION_CANCELCALLWAITING,
|
|
pltoOutput);
|
|
}
|
|
|
|
if (ERROR_SUCCESS == lRes)
|
|
{
|
|
bRet = TRUE;
|
|
}
|
|
|
|
CmFree(pltoOutput);
|
|
|
|
m_pArgs->fNeedConfigureTapi = !(bRet);
|
|
|
|
return bRet;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CPropertiesSheet::AddExternalPage
|
|
//
|
|
// Synopsis: Add a page to the property sheet.
|
|
//
|
|
// Arguments: PROPSHEETPAGE * pPsp - The page to add
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: tomkel Created 01/09/2001
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
void CPropertiesSheet::AddExternalPage(PROPSHEETPAGE *pPsp)
|
|
{
|
|
//
|
|
// This version of AddExternalPage only work before calling DoPropertySheet
|
|
//
|
|
MYDBGASSERT(pPsp);
|
|
|
|
if (!pPsp)
|
|
{
|
|
return;
|
|
}
|
|
CMTRACE1(TEXT("CPropertiesSheet::AddExternalPage - sizeof(PROPSHEETPAGE) = %d"),sizeof(PROPSHEETPAGE));
|
|
MYDBGASSERT(m_numPages < MAX_PAGES);
|
|
CopyMemory((LPVOID)&m_pages[m_numPages], (LPVOID)pPsp, sizeof(PROPSHEETPAGE));
|
|
m_adwPageType[m_numPages] = CPROP_SHEET_TYPE_EXTERNAL;
|
|
m_numPages++;
|
|
|
|
}
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CPropertiesSheet::AddPage
|
|
//
|
|
// Synopsis: Add a page to the property sheet.
|
|
//
|
|
// Arguments: const CPropertiesPage* pPage - The page to add
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
void CPropertiesSheet::AddPage(const CPropertiesPage* pPage)
|
|
{
|
|
//
|
|
// This version of AddPage only work before calling DoPropertySheet
|
|
//
|
|
MYDBGASSERT(pPage);
|
|
MYDBGASSERT(pPage->m_pszTemplate);
|
|
|
|
if (!pPage)
|
|
{
|
|
return;
|
|
}
|
|
|
|
MYDBGASSERT(m_numPages < MAX_PAGES);
|
|
m_pages[m_numPages].pszTemplate = pPage->m_pszTemplate;
|
|
m_pages[m_numPages].lParam = (LPARAM)pPage; // save the property page object
|
|
m_adwPageType[m_numPages] = CPROP_SHEET_TYPE_INTERNAL;
|
|
m_numPages++;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CPropertiesSheet::DoPropertySheet
|
|
//
|
|
// Synopsis: Call PropertySheet to create a modal property sheet
|
|
//
|
|
// Arguments: HWND hWndParent - Parent window
|
|
// LPTSTR pszCaption - Title string
|
|
// HINSTANCE hInst - The resource instance
|
|
// UINT nStartPage - The start page
|
|
//
|
|
// Returns: int - return value of PropertySheet()
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
int CPropertiesSheet::DoPropertySheet(HWND hWndParent, LPTSTR pszCaption, HINSTANCE hInst)
|
|
{
|
|
for (UINT i=0; i<m_numPages; i++)
|
|
{
|
|
//
|
|
// Only do this for our CM property pages that are classes
|
|
//
|
|
if (m_adwPageType[i] == CPROP_SHEET_TYPE_INTERNAL)
|
|
{
|
|
m_pages[i].dwSize = sizeof(PROPSHEETPAGE);
|
|
m_pages[i].hInstance = hInst;
|
|
m_pages[i].dwFlags = 0; // No help button or F1
|
|
m_pages[i].pfnDlgProc = CPropertiesPage::PropPageProc;
|
|
}
|
|
}
|
|
|
|
m_psh.dwSize = sizeof(PROPSHEETHEADER);
|
|
m_psh.hwndParent = hWndParent;
|
|
m_psh.hInstance = hInst;
|
|
m_psh.pszIcon = 0;
|
|
m_psh.pszCaption = pszCaption; // MAKEINTRESOURCE(nCaption);
|
|
m_psh.nPages = m_numPages;
|
|
m_psh.nStartPage = 0;
|
|
m_psh.ppsp = m_pages;
|
|
m_psh.dwFlags = PSH_PROPSHEETPAGE|PSH_NOAPPLYNOW|PSH_USECALLBACK;
|
|
m_psh.pfnCallback = PropSheetProc;
|
|
|
|
//
|
|
// Dynamiclly load comctl32.dll
|
|
//
|
|
int iRet = -1;
|
|
|
|
HINSTANCE hComCtl = LoadLibraryExA("comctl32.dll", NULL, 0);
|
|
|
|
CMASSERTMSG(hComCtl, TEXT("LoadLibrary - comctl32 failed"));
|
|
|
|
if (hComCtl != NULL)
|
|
{
|
|
typedef int (*PROPERTYSHEETPROC)(LPCPROPSHEETHEADER lppsph);
|
|
typedef void (*INITCOMMONCONTROLSPROC)(VOID);
|
|
|
|
|
|
PROPERTYSHEETPROC fnPropertySheet;
|
|
INITCOMMONCONTROLSPROC fnInitCommonControls;
|
|
|
|
LPSTR pszPropSheetFuncName = OS_NT ? "PropertySheetW" : "PropertySheetA";
|
|
fnPropertySheet = (PROPERTYSHEETPROC)GetProcAddress(hComCtl, pszPropSheetFuncName);
|
|
fnInitCommonControls = (INITCOMMONCONTROLSPROC)GetProcAddress(hComCtl, "InitCommonControls");
|
|
|
|
|
|
if (fnPropertySheet == NULL || fnInitCommonControls == NULL)
|
|
{
|
|
CMTRACE(TEXT("GetProcAddress of comctl32 failed"));
|
|
}
|
|
else
|
|
{
|
|
fnInitCommonControls();
|
|
|
|
//
|
|
// Set m_pThis right before we call PropertySheet
|
|
// It will be used by PropSheetProc.
|
|
// Note: this is not multi-thread safe. However, there is very little chance
|
|
// that another thread is trying to bring up settings at the same time, and
|
|
// a context switch happens before PropSheetProc got called
|
|
//
|
|
|
|
MYDBGASSERT(m_pThis == NULL);
|
|
m_pThis = this;
|
|
|
|
if ((iRet = fnPropertySheet(&m_psh)) == -1)
|
|
{
|
|
CMTRACE(TEXT("DoPropertySheet: PropertySheet() failed"));
|
|
}
|
|
}
|
|
|
|
FreeLibrary(hComCtl);
|
|
}
|
|
|
|
return iRet;
|
|
}
|
|
|
|
//
|
|
// Implementation of class CPropertiesPage
|
|
//
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CPropertiesPage::CPropertiesPage
|
|
//
|
|
// Synopsis: Constructor
|
|
//
|
|
// Arguments: UINT nIDTemplate - Resource ID of the page
|
|
// const DWORD* pHelpPairs - The pairs of ControlID/HelpID
|
|
// const TCHAR* lpszHelpFile - The help file name
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
CPropertiesPage::CPropertiesPage(UINT nIDTemplate, const DWORD* pHelpPairs, const TCHAR* lpszHelpFile )
|
|
:CWindowWithHelp(pHelpPairs, lpszHelpFile)
|
|
{
|
|
m_pszTemplate = MAKEINTRESOURCE(nIDTemplate);
|
|
}
|
|
|
|
CPropertiesPage::CPropertiesPage(LPCTSTR lpszTemplateName, const DWORD* pHelpPairs,
|
|
const TCHAR* lpszHelpFile)
|
|
:CWindowWithHelp(pHelpPairs, lpszHelpFile)
|
|
{
|
|
m_pszTemplate = lpszTemplateName;
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CPropertiesPage::OnInitDialog
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_INITDIALOG message
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: BOOL - return value of the message
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL CPropertiesPage::OnInitDialog()
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CPropertiesPage::OnCommand
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_COMMAND
|
|
//
|
|
// Arguments: WPARAM - wParam of the message
|
|
// LPARAM - lParam of the message
|
|
//
|
|
// Returns: DWORD - return value of the message
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CPropertiesPage::OnCommand(WPARAM , LPARAM )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CPropertiesPage::OnSetActive
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_NOTIFY with PSN_SETACTIVE
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: BOOL - return value of the message
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL CPropertiesPage::OnSetActive()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CPropertiesPage::OnKillActive
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_NOTIFY with PSN_KILLACTIVE
|
|
// Notifies a page that it is about to lose activation either because
|
|
// another page is being activated or the user has clicked the OK button.
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: BOOL - return value of the message
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL CPropertiesPage::OnKillActive()
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CPropertiesPage::OnApply
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_NOTIFY with PSN_APPLY
|
|
// Indicates that the user clicked the OK or Apply Now button
|
|
// and wants all changes to take effect.
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: NONE
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
void CPropertiesPage::OnApply()
|
|
{
|
|
SetPropSheetResult(PSNRET_NOERROR);
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CPropertiesPage::OnReset
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_NOTIFY with PSN_RESET
|
|
// Notifies a page that the user has clicked the Cancel button and
|
|
// the property sheet is about to be destroyed.
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: NONE
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
void CPropertiesPage::OnReset()
|
|
{
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CPropertiesPage::OnPsnHelp
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_NOTIFY with PSN_HELP
|
|
//
|
|
// Arguments: HWND - Window handle to the control sending a message
|
|
// UINT - Identifier of the control sending a message
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
void CPropertiesPage::OnPsnHelp(HWND , UINT_PTR)
|
|
{
|
|
if (m_lpszHelpFile && m_lpszHelpFile[0])
|
|
{
|
|
CmWinHelp(m_hWnd, m_hWnd, m_lpszHelpFile, HELP_FORCEFILE, 0);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CPropertiesPage::OnOtherMessage
|
|
//
|
|
// Synopsis: Callup opun message other than WM_INITDIALOG and WM_COMMAND
|
|
//
|
|
// Arguments: UINT - Message Id
|
|
// WPARAM - wParam of the message
|
|
// LPARAM - lParam of the message
|
|
//
|
|
// Returns: DWORD - return value of the message
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CPropertiesPage::OnOtherMessage(UINT , WPARAM , LPARAM )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CPropertiesPage::PropPageProc
|
|
//
|
|
// Synopsis: The call back dialog procedure for all the property pages
|
|
//
|
|
// Arguments: HWND hwndDlg - Property page window handle
|
|
// UINT uMsg - Message ID
|
|
// WPARAM wParam - wParam of the message
|
|
// LPARAM lParam - lParam of the message
|
|
//
|
|
// Returns: BOOL - return value of the message
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
INT_PTR CALLBACK CPropertiesPage::PropPageProc(HWND hwndDlg,UINT uMsg,WPARAM wParam, LPARAM lParam)
|
|
{
|
|
CPropertiesPage* pPage;
|
|
NMHDR* pnmHeader = (NMHDR*)lParam;
|
|
|
|
//
|
|
// Save the object pointer on the first message,
|
|
// The first message is not necessarily WM_INITDIALOG
|
|
//
|
|
if (uMsg == WM_INITDIALOG)
|
|
{
|
|
pPage = (CPropertiesPage*) ((PROPSHEETPAGE *)lParam)->lParam;
|
|
|
|
//
|
|
// Save the object pointer, this is implementation detail
|
|
// The user of this class should not be aware of this
|
|
//
|
|
::SetWindowLongU(hwndDlg, DWLP_USER, (LONG_PTR)pPage);
|
|
|
|
MYDBGASSERT(pPage);
|
|
MYDBGASSERT(pPage->m_hWnd == NULL);
|
|
|
|
pPage->m_hWnd = hwndDlg;
|
|
}
|
|
else
|
|
{
|
|
pPage = (CPropertiesPage*) GetWindowLongU(hwndDlg,DWLP_USER);
|
|
|
|
if (pPage == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
MYDBGASSERT(pPage->m_hWnd == hwndDlg);
|
|
}
|
|
|
|
ASSERT_VALID(pPage);
|
|
|
|
switch(uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
return pPage->OnInitDialog();
|
|
|
|
case WM_COMMAND:
|
|
return (BOOL)pPage->OnCommand(wParam, lParam);
|
|
|
|
case WM_NOTIFY:
|
|
{
|
|
if (NULL == pnmHeader)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
switch (pnmHeader->code)
|
|
{
|
|
case PSN_SETACTIVE:
|
|
pPage->OnSetActive();
|
|
break;
|
|
|
|
case PSN_KILLACTIVE:
|
|
pPage->OnKillActive();
|
|
break;
|
|
|
|
case PSN_APPLY:
|
|
pPage->OnApply();
|
|
return TRUE;
|
|
|
|
case PSN_RESET:
|
|
pPage->OnReset();
|
|
break;
|
|
|
|
case PSN_HELP:
|
|
pPage->OnPsnHelp(pnmHeader->hwndFrom , pnmHeader->idFrom);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
break;
|
|
} // WM_NOTIFY
|
|
|
|
case WM_HELP:
|
|
pPage->OnHelp((LPHELPINFO)lParam);
|
|
return TRUE;
|
|
|
|
case WM_CONTEXTMENU:
|
|
{
|
|
POINT pos = {LOWORD(lParam), HIWORD(lParam)};
|
|
|
|
CMTRACE3(TEXT("\r\nPropPageProc() - WM_CONTEXTMENU wParam = %u pos.x = %u, pos.y = %u"),
|
|
wParam, pos.x, pos.y);
|
|
|
|
pPage->OnContextMenu((HWND) wParam, pos);
|
|
return TRUE;
|
|
}
|
|
|
|
default:
|
|
return (BOOL)pPage->OnOtherMessage(uMsg, wParam, lParam);
|
|
}
|
|
|
|
return (FALSE);
|
|
}
|
|
|
|
//
|
|
// Help id pairs for dialing page
|
|
//
|
|
const DWORD CGeneralPage::m_dwHelp[] = {
|
|
IDC_GENERAL_PHONENUMBERS_GROUPBOX, IDH_GENERAL_PHONENUM,
|
|
IDC_RADIO_DIRECT, IDH_GENERAL_ALREADY,
|
|
IDC_RADIO_DIALUP, IDH_GENERAL_DIALTHIS,
|
|
IDC_GENERAL_P1_STATIC, IDH_GENERAL_PHONENUM,
|
|
IDC_GENERAL_PRIMARY_EDIT, IDH_GENERAL_PHONENUM,
|
|
IDC_GENERAL_PRIMARYPB_BUTTON, IDH_GENERAL_PHONEBOOK,
|
|
IDC_GENERAL_UDR1_CHECKBOX, IDH_GENERAL_USE_DIAL_RULE,
|
|
IDC_GENERAL_P2_STATIC, IDH_GENERAL_BACKUPNUM,
|
|
IDC_GENERAL_BACKUP_EDIT, IDH_GENERAL_BACKUPNUM,
|
|
IDC_GENERAL_BACKUPPB_BUTTON, IDH_GENERAL_PHONEBOOKB,
|
|
IDC_GENERAL_UDR2_CHECKBOX, IDH_GENERAL_USE_DIAL_RULEB,
|
|
IDC_GENERAL_TAPI_BUTTON, IDH_GENERAL_DIALRULE,
|
|
IDC_GENERAL_MODEM_COMBO, IDH_GENERAL_CONNECT_MODEM,
|
|
IDC_CONNECT_USING, IDH_GENERAL_CONNECT_MODEM,
|
|
IDC_GENERAL_ACCESSPOINT_COMBO, IDH_GENERAL_ACCESSPOINTS,
|
|
IDC_GENERAL_ACCESSPOINT_STATIC, IDH_GENERAL_ACCESSPOINTS,
|
|
IDC_GENERAL_NEWAP_BUTTON, IDH_GENERAL_NEWAP,
|
|
IDC_GENERAL_DELETEAP_BUTTON, IDH_GENERAL_DELETEAP,
|
|
0,0};
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CGeneralPage::CGeneralPage
|
|
//
|
|
// Synopsis: Constructor
|
|
//
|
|
// Arguments: ArgsStruct* pArgs - Information needed for the page
|
|
// UINT nIDTemplate - Resource ID
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
CGeneralPage::CGeneralPage(ArgsStruct* pArgs, UINT nIDTemplate)
|
|
: CPropertiesPage(nIDTemplate, m_dwHelp, pArgs->pszHelpFile)
|
|
{
|
|
MYDBGASSERT(pArgs);
|
|
m_pArgs = pArgs;
|
|
m_pEventListener = NULL;
|
|
|
|
m_NumPhones = MAX_PHONE_NUMBERS;
|
|
|
|
m_szDeviceName[0] = TEXT('\0');
|
|
m_szDeviceType[0] = TEXT('\0');
|
|
|
|
m_bDialInfoInit = FALSE;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CGeneralPage::OnInitDialog
|
|
//
|
|
// Synopsis: Init the General properties property sheet.
|
|
//
|
|
// Arguments: hwndDlg [dlg window handle]
|
|
// pArgs [the ptr to ArgsStruct]
|
|
//
|
|
// Returns: NONE
|
|
//
|
|
// History: henryt Created 4/30/97
|
|
// byao Modified 5/12/97 - disable backup phone no. in
|
|
// 'Dialing with Connectoid' mode
|
|
//----------------------------------------------------------------------------
|
|
|
|
BOOL CGeneralPage::OnInitDialog()
|
|
{
|
|
UpdateFont(m_hWnd);
|
|
|
|
//
|
|
// Load the Access Points from the registry
|
|
//
|
|
if (FALSE == ShowAccessPointInfoFromReg(m_pArgs, m_hWnd, IDC_GENERAL_ACCESSPOINT_COMBO))
|
|
{
|
|
//
|
|
// If the above function fails then there is no Access Point in the registry.
|
|
// Need to figure out if this is the default access point.
|
|
//
|
|
LPTSTR pszTempDefaultAccessPointName = CmLoadString(g_hInst, IDS_DEFAULT_ACCESSPOINT);
|
|
if (pszTempDefaultAccessPointName)
|
|
{
|
|
if (0 == lstrcmpiU(m_pArgs->pszCurrentAccessPoint, pszTempDefaultAccessPointName))
|
|
{
|
|
//
|
|
// This must be an old (1.0 or 1.2) profile since it's the default Access Point and it isn't
|
|
// in the registry yet. Need to properly display the Access Point combobox and
|
|
// create the reg key. Calling AddNewAPToReg does that.
|
|
//
|
|
AddNewAPToReg(m_pArgs->pszCurrentAccessPoint, TRUE);
|
|
|
|
//
|
|
// Need to clear the AccessPointEnabled Flag. This is a side effect of calling AddNewAPToReg
|
|
// thus it needs to be cleared (set to FALSE) since we only have one Access Point and
|
|
// the this flag is only set if we have 1+ Access Points
|
|
//
|
|
m_pArgs->fAccessPointsEnabled = FALSE;
|
|
WriteUserInfoToReg(m_pArgs, UD_ID_ACCESSPOINTENABLED, (PVOID) &m_pArgs->fAccessPointsEnabled);
|
|
}
|
|
CmFree(pszTempDefaultAccessPointName);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Set phone number descriptions
|
|
//
|
|
UpdateForNewAccessPoint(TRUE);
|
|
|
|
//
|
|
// Subclass the Phone Number edit controls
|
|
//
|
|
HWND hwndPrimary = GetDlgItem(m_hWnd, IDC_GENERAL_PRIMARY_EDIT);
|
|
HWND hwndBackup = GetDlgItem(m_hWnd, IDC_GENERAL_BACKUP_EDIT);
|
|
|
|
MYDBGASSERT(hwndPrimary && hwndBackup);
|
|
|
|
if (hwndPrimary && hwndBackup)
|
|
{
|
|
m_pfnOrgEditWndProc = (WNDPROC)SetWindowLongU(hwndPrimary, GWLP_WNDPROC, (LONG_PTR)SubClassEditProc);
|
|
WNDPROC lpEditProc = (WNDPROC)SetWindowLongU(hwndBackup, GWLP_WNDPROC, (LONG_PTR)SubClassEditProc);
|
|
|
|
MYDBGASSERT(lpEditProc == m_pfnOrgEditWndProc);
|
|
|
|
//
|
|
// Save the object with the window handle
|
|
//
|
|
|
|
SetWindowLongU(hwndPrimary, GWLP_USERDATA, (LONG_PTR)this);
|
|
SetWindowLongU(hwndBackup, GWLP_USERDATA, (LONG_PTR)this);
|
|
}
|
|
|
|
return (TRUE);
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CGeneralPage::UpdateForNewAccessPoint
|
|
//
|
|
// Synopsis: Set the phone number description from pArgs.
|
|
//
|
|
// Notes: This function was originally part of OnInitDialog.
|
|
// It was made into a separate function for access points
|
|
//
|
|
// Arguments: fSetPhoneNumberDescriptions [update phone numbers as well]
|
|
//
|
|
// Returns: NONE
|
|
//
|
|
// History: t-urama Created 07/31/2000
|
|
//----------------------------------------------------------------------------
|
|
void CGeneralPage::UpdateForNewAccessPoint(BOOL fSetPhoneNumberDescriptions)
|
|
{
|
|
m_bAPInfoChanged = FALSE;
|
|
LPTSTR pszDefaultAccessPointName = CmLoadString(g_hInst, IDS_DEFAULT_ACCESSPOINT);
|
|
|
|
if (pszDefaultAccessPointName && m_pArgs->pszCurrentAccessPoint)
|
|
{
|
|
if (!lstrcmpiU(m_pArgs->pszCurrentAccessPoint, pszDefaultAccessPointName))
|
|
{
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_GENERAL_DELETEAP_BUTTON), FALSE);
|
|
}
|
|
else
|
|
{
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_GENERAL_DELETEAP_BUTTON), TRUE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("UpdateForNewAccessPoint -- either CmLoadString of IDS_DEFAULT_ACCESSPOINT failed or pszCurrentAccessPoint is NULL."));
|
|
}
|
|
|
|
CmFree(pszDefaultAccessPointName);
|
|
|
|
if (fSetPhoneNumberDescriptions)
|
|
{
|
|
UpdateNumberDescription(0, m_pArgs->aDialInfo[0].szDesc);
|
|
UpdateNumberDescription(1, m_pArgs->aDialInfo[1].szDesc);
|
|
|
|
if (m_pArgs->IsBothConnTypeSupported())
|
|
{
|
|
//
|
|
// Set radio button according to AlwaysOn state
|
|
//
|
|
if (m_pArgs->IsDirectConnect())
|
|
{
|
|
CheckDlgButton(m_hWnd, IDC_RADIO_DIRECT, BST_CHECKED);
|
|
CheckDlgButton(m_hWnd, IDC_RADIO_DIALUP, BST_UNCHECKED);
|
|
EnableDialupControls(FALSE);
|
|
}
|
|
else
|
|
{
|
|
CheckDlgButton(m_hWnd, IDC_RADIO_DIALUP, BST_CHECKED);
|
|
CheckDlgButton(m_hWnd, IDC_RADIO_DIRECT, BST_UNCHECKED);
|
|
PostMessageU(m_hWnd, WM_INITDIALINFO, 0,0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Note: It is assumed that this page will never be loaded in a pure direct
|
|
// case, thus the deduction that NOT IsBothConnTypeSupported means dial only.
|
|
//
|
|
MYDBGASSERT(!m_pArgs->IsDirectConnect());
|
|
PostMessageU(m_hWnd, WM_INITDIALINFO, 0,0);
|
|
}
|
|
}
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CGeneralPage::EnableDialupControls
|
|
//
|
|
// Synopsis: Sets the enabled state of ALL the dialup controls on the tab
|
|
//
|
|
// Arguments: BOOL fEnable - flag indicating enable state of dial-up controls
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: nickball Created 04/21/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
void CGeneralPage::EnableDialupControls(BOOL fEnable)
|
|
{
|
|
BOOL fState = fEnable;
|
|
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_GENERAL_P1_STATIC), fState);
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_GENERAL_PRIMARY_EDIT), fState);
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_GENERAL_P2_STATIC), fState);
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_GENERAL_BACKUP_EDIT), fState);
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_CONNECT_USING), fState);
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_GENERAL_MODEM_COMBO), fState);
|
|
|
|
//
|
|
// We are enabling controls check PB buttons
|
|
//
|
|
|
|
fState = FALSE;
|
|
|
|
if (fEnable)
|
|
{
|
|
//
|
|
// No phonebooks, no button access
|
|
//
|
|
|
|
if (m_pArgs->fHasValidTopLevelPBK || m_pArgs->fHasValidReferencedPBKs)
|
|
{
|
|
fState = TRUE;
|
|
}
|
|
}
|
|
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_GENERAL_PRIMARYPB_BUTTON), fState);
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_GENERAL_BACKUPPB_BUTTON), fState);
|
|
|
|
//
|
|
// Examine the canonical phone number, we must have a canonical form
|
|
// of the number available for Use Dailing Rules to be enabled.
|
|
//
|
|
|
|
if (fEnable && *m_DialInfo[0].szCanonical)
|
|
{
|
|
fState = TRUE;
|
|
}
|
|
else
|
|
{
|
|
fState = FALSE;
|
|
}
|
|
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_GENERAL_UDR1_CHECKBOX), fState);
|
|
|
|
//
|
|
// Examine the canonical phone number, we must have a canonical form
|
|
// of the number available for Use Dailing Rules to be enabled.
|
|
//
|
|
|
|
if (fEnable && *m_DialInfo[1].szCanonical)
|
|
{
|
|
fState = TRUE;
|
|
}
|
|
else
|
|
{
|
|
fState = FALSE;
|
|
}
|
|
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_GENERAL_UDR2_CHECKBOX), fState);
|
|
|
|
//
|
|
// Update dialing rules state
|
|
//
|
|
|
|
if (fEnable)
|
|
{
|
|
UpdateDialingRulesButton();
|
|
}
|
|
else
|
|
{
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_GENERAL_TAPI_BUTTON), fEnable);
|
|
}
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CGeneralPage::OnOtherMessage
|
|
//
|
|
// Synopsis: Callup opun message other than WM_INITDIALOG and WM_COMMAND
|
|
//
|
|
// Arguments: UINT - Message Id
|
|
// WPARAM - wParam of the message
|
|
// LPARAM - lParam of the message
|
|
//
|
|
// Returns: DWORD - return value of the message
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CGeneralPage::OnOtherMessage(UINT uMsg, WPARAM , LPARAM )
|
|
{
|
|
if (uMsg == WM_INITDIALINFO)
|
|
{
|
|
InitDialInfo();
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: IsUniqueIsdnDevice
|
|
//
|
|
// Synopsis: Checks to see if this is an ISDN device and if it was already added
|
|
// to the ComboBox control identified by hWnd and nId
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: BOOL - Returns TRUE if a Unique ISDN Device
|
|
//
|
|
// History: quintinb 7/14/99 created
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL IsUniqueIsdnDevice(HWND hWnd, UINT nId, LPRASDEVINFO pRasDevInfo)
|
|
{
|
|
BOOL bReturn = FALSE;
|
|
|
|
if (hWnd && nId && pRasDevInfo)
|
|
{
|
|
//
|
|
// First lets check to make sure that this is even an ISDN device
|
|
//
|
|
if (0 == lstrcmpiU(pRasDevInfo->szDeviceType, RASDT_Isdn))
|
|
{
|
|
//
|
|
// Okay, it is an ISDN device, do we have one with that name already?
|
|
//
|
|
if (CB_ERR == SendDlgItemMessageU(hWnd, nId, CB_FINDSTRINGEXACT,
|
|
-1, (LPARAM)pRasDevInfo->szDeviceName))
|
|
{
|
|
bReturn = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CGeneralPage::InitDialInfo
|
|
//
|
|
// Synopsis: The dialing page can not call LoadDialInfo directly on WM_INITDIALOG
|
|
// LoadDialInfo might popup some UI to install modem. The property
|
|
// sheet and the property page will not be disabled, if a dialog is
|
|
// poped up on WM_INITDIALOG message. Instead, we post a message
|
|
// on WM_INITDIALOG and call LoadDialInfo here.
|
|
// On a slow machine, there might be a period that all the control
|
|
// are gray.
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: DWORD - Return code from LoadDialInfo
|
|
//
|
|
// History: fengsun 2/26/98 Created Header
|
|
// nickball 4/24/98 Added return code
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CGeneralPage::InitDialInfo()
|
|
{
|
|
/*if (m_bDialInfoInit)
|
|
{
|
|
return ERROR_SUCCESS;
|
|
}*/
|
|
|
|
HCURSOR hPrev = SetCursor(LoadCursorU(NULL,IDC_WAIT));
|
|
|
|
//
|
|
// Make sure the dial info is loaded
|
|
//
|
|
|
|
DWORD dwRet = LoadDialInfo(m_pArgs, m_hWnd);
|
|
|
|
if (dwRet == ERROR_PORT_NOT_AVAILABLE)
|
|
{
|
|
//
|
|
// No modem avaliable, update direct/dial controls if any
|
|
//
|
|
|
|
if (m_pArgs->IsBothConnTypeSupported())
|
|
{
|
|
CheckDlgButton(m_hWnd, IDC_RADIO_DIALUP, BST_UNCHECKED);
|
|
CheckDlgButton(m_hWnd, IDC_RADIO_DIRECT, BST_CHECKED);
|
|
SetFocus(GetDlgItem(m_hWnd, IDC_RADIO_DIRECT));
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Make sure user can exit using keyboard by explicitly
|
|
// setting cancel button as default and giving it focus.
|
|
//
|
|
|
|
HWND hwndParent = GetParent(m_hWnd);
|
|
|
|
MYDBGASSERT(hwndParent);
|
|
|
|
if (hwndParent)
|
|
{
|
|
SendMessageU(hwndParent, DM_SETDEFID, (WPARAM)IDCANCEL, 0);
|
|
SetFocus(GetDlgItem(hwndParent, IDCANCEL));
|
|
}
|
|
}
|
|
|
|
//
|
|
// Disable everything dial-up
|
|
//
|
|
|
|
EnableDialupControls(FALSE);
|
|
|
|
SetCursor(hPrev);
|
|
|
|
return dwRet;
|
|
}
|
|
|
|
lstrcpynU(m_szDeviceName, m_pArgs->szDeviceName, CELEMS(m_szDeviceName));
|
|
|
|
//
|
|
// Init the tmp phone array, it'll possibly be modified
|
|
//
|
|
m_DialInfo[0] = m_pArgs->aDialInfo[0];
|
|
m_DialInfo[1] = m_pArgs->aDialInfo[1];
|
|
|
|
EnableDialupControls(TRUE);
|
|
|
|
//
|
|
// Check TAPI before translating address
|
|
//
|
|
|
|
CheckTapi(&m_pArgs->tlsTapiLink, g_hInst);
|
|
|
|
//
|
|
// Set limit for phone # length. Use OS to determine intial default, but
|
|
// allow admin override.
|
|
//
|
|
|
|
UINT i = (OS_NT ? MAX_PHONE_LENNT : MAX_PHONE_LEN95);
|
|
|
|
i = (int) m_pArgs->piniService->GPPI(c_pszCmSection, c_pszCmEntryMaxPhoneNumber, i);
|
|
|
|
//
|
|
// Even override is limited, in this case by our storage at RAS_MaxPhoneNumber
|
|
//
|
|
|
|
i = __min(i, RAS_MaxPhoneNumber);
|
|
|
|
SendDlgItemMessageU(m_hWnd, IDC_GENERAL_PRIMARY_EDIT, EM_SETLIMITTEXT, i, 0);
|
|
SendDlgItemMessageU(m_hWnd, IDC_GENERAL_BACKUP_EDIT, EM_SETLIMITTEXT, i, 0);
|
|
|
|
//
|
|
// display the munged phone #'s
|
|
//
|
|
|
|
for (i = 0; i < m_NumPhones; i++)
|
|
{
|
|
DisplayMungedPhone(i);
|
|
|
|
int iCtrl = (i? IDC_GENERAL_UDR2_CHECKBOX : IDC_GENERAL_UDR1_CHECKBOX);
|
|
|
|
//
|
|
// Set "Use Dialing Rules". If there is a canonical value then honor
|
|
// the USE_DIALING_RULES flag. Otherwise, its a hand edited number,
|
|
// so we disable the check for dialing rules. Note: this logic is also
|
|
// used in EnableDialupControls().
|
|
//
|
|
|
|
if (!m_DialInfo[i].szCanonical[0])
|
|
{
|
|
EnableWindow(GetDlgItem(m_hWnd, iCtrl), FALSE);
|
|
}
|
|
else
|
|
{
|
|
CheckDlgButton(m_hWnd,
|
|
iCtrl,
|
|
(m_DialInfo[i].dwPhoneInfoFlags & PIF_USE_DIALING_RULES));
|
|
}
|
|
}
|
|
|
|
//
|
|
// Set TAPI button display according to dialing rules use.
|
|
//
|
|
|
|
UpdateDialingRulesButton();
|
|
|
|
//
|
|
// Standard dial: If we have no phone books, disable the buttons
|
|
//
|
|
|
|
if (!m_pArgs->fHasValidTopLevelPBK && !m_pArgs->fHasValidReferencedPBKs)
|
|
{
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_GENERAL_PRIMARYPB_BUTTON), FALSE);
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_GENERAL_BACKUPPB_BUTTON), FALSE);
|
|
}
|
|
|
|
DWORD dwCnt;
|
|
DWORD dwIdx;
|
|
|
|
if (!m_bDialInfoInit)
|
|
{
|
|
// Initialize the modem combo box only once. This does not use any of the
|
|
// access point info.
|
|
//
|
|
//
|
|
// Init the modem combo box. ISDN devices are a special case because they
|
|
// have two channels and thus usually enumerate each channel as a device.
|
|
// The old style handling was to only show the first ISDN device on the machine.
|
|
// This worked but won't allow a user to use a second ISDN device with CM should
|
|
// they have one. We will keep the old behavior on legacy platforms but on NT5
|
|
// we will try to do the right thing and only not enumerate a second device if
|
|
// we already have one of those in the list. This will filter out second channels
|
|
// and will give the user access to another ISDN device as long as it isn't of the same
|
|
// name as the first. Definitely not a great solution but this close to ship it is the
|
|
// best we can do. Note that for ISDN devices we want to only show
|
|
// one device even though RAS may enumerate two (one for each channe
|
|
//
|
|
|
|
SendDlgItemMessageU(m_hWnd, IDC_GENERAL_MODEM_COMBO, CB_RESETCONTENT, 0, 0L);
|
|
|
|
LPRASDEVINFO prdiRasDevInfo;
|
|
|
|
|
|
if (GetRasModems(&m_pArgs->rlsRasLink, &prdiRasDevInfo, &dwCnt))
|
|
{
|
|
|
|
//
|
|
// add modem list to modem-combo
|
|
//
|
|
for (dwIdx=0; dwIdx < dwCnt; dwIdx++)
|
|
{
|
|
//
|
|
// filter out tunnel device, IRDA, and Parallel ports.
|
|
//
|
|
if (!lstrcmpiU(prdiRasDevInfo[dwIdx].szDeviceType, RASDT_Modem) || // a modem
|
|
!lstrcmpiU(prdiRasDevInfo[dwIdx].szDeviceType, RASDT_Atm) || // an ATM device
|
|
IsUniqueIsdnDevice(m_hWnd, IDC_GENERAL_MODEM_COMBO, &prdiRasDevInfo[dwIdx])) // an ISDN modem, note we
|
|
// filter out the channels
|
|
// and show only one device
|
|
{
|
|
//
|
|
// Add the device to the Device Combo Box
|
|
//
|
|
SendDlgItemMessageU(m_hWnd, IDC_GENERAL_MODEM_COMBO, CB_ADDSTRING,
|
|
0, (LPARAM)prdiRasDevInfo[dwIdx].szDeviceName);
|
|
}
|
|
}
|
|
}
|
|
|
|
CmFree(prdiRasDevInfo);
|
|
}
|
|
|
|
dwCnt = (DWORD)SendDlgItemMessageU(m_hWnd, IDC_GENERAL_MODEM_COMBO, CB_GETCOUNT, 0, 0);
|
|
if (dwCnt == 0)
|
|
{
|
|
dwIdx = (DWORD)CB_ERR;
|
|
}
|
|
else if (dwCnt == 1)
|
|
{
|
|
dwIdx = 0;
|
|
}
|
|
else
|
|
{
|
|
dwIdx = (DWORD)SendDlgItemMessageU(m_hWnd,
|
|
IDC_GENERAL_MODEM_COMBO,
|
|
CB_FINDSTRINGEXACT,
|
|
0,
|
|
(LPARAM)m_szDeviceName);
|
|
}
|
|
|
|
if (dwIdx != CB_ERR)
|
|
{
|
|
SendDlgItemMessageU(m_hWnd, IDC_GENERAL_MODEM_COMBO, CB_SETCURSEL, (WPARAM)dwIdx, 0L);
|
|
|
|
|
|
//
|
|
// Reset the tmp modem var
|
|
//
|
|
|
|
GetDlgItemTextU(m_hWnd, IDC_GENERAL_MODEM_COMBO, m_szDeviceName, RAS_MaxDeviceName+1);
|
|
|
|
//
|
|
// GetDeviceType will fill the szDeviceType according to szDeviceName
|
|
//
|
|
if (!GetDeviceType(m_pArgs, m_szDeviceType, m_szDeviceName))
|
|
{
|
|
//
|
|
// if GetDeviceType() failed, something's wrong. just use the devicetype
|
|
// that we've been using.
|
|
//
|
|
lstrcpynU(m_szDeviceType, m_pArgs->szDeviceType, CELEMS(m_szDeviceType));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Disable DialingProperties button if no modem selected
|
|
//
|
|
|
|
if (IsWindowEnabled(GetDlgItem(m_hWnd, IDC_GENERAL_TAPI_BUTTON)))
|
|
{
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_GENERAL_TAPI_BUTTON), m_szDeviceName[0] != 0);
|
|
}
|
|
|
|
m_bDialInfoInit = TRUE;
|
|
|
|
SetCursor(hPrev);
|
|
|
|
return dwRet;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CGeneralPage::OnCommand
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_COMMAND
|
|
//
|
|
// Arguments: WPARAM - wParam of the message
|
|
// LPARAM - lParam of the message
|
|
//
|
|
// Returns: DWORD - return value of the message
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CGeneralPage::OnCommand(WPARAM wParam, LPARAM)
|
|
{
|
|
//
|
|
// Hide any open balloon tips
|
|
//
|
|
if (m_pArgs->pBalloonTip)
|
|
{
|
|
m_pArgs->pBalloonTip->HideBalloonTip();
|
|
}
|
|
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDC_GENERAL_UDR1_CHECKBOX:
|
|
case IDC_GENERAL_UDR2_CHECKBOX:
|
|
{
|
|
int i = (LOWORD(wParam) == IDC_GENERAL_UDR1_CHECKBOX? 0 : 1);
|
|
|
|
if (IsDlgButtonChecked(m_hWnd, LOWORD(wParam)))
|
|
{
|
|
int iEditID = i ? IDC_GENERAL_BACKUP_EDIT : IDC_GENERAL_PRIMARY_EDIT;
|
|
|
|
m_DialInfo[i].dwPhoneInfoFlags |= PIF_USE_DIALING_RULES;
|
|
}
|
|
else
|
|
{
|
|
m_DialInfo[i].dwPhoneInfoFlags &= ~PIF_USE_DIALING_RULES;
|
|
}
|
|
|
|
//
|
|
// If neither dialing rule is on, disable button.
|
|
//
|
|
|
|
UpdateDialingRulesButton();
|
|
|
|
DisplayMungedPhone(i);
|
|
m_bAPInfoChanged = TRUE;
|
|
return TRUE;
|
|
}
|
|
|
|
case IDC_GENERAL_PRIMARYPB_BUTTON:
|
|
case IDC_GENERAL_BACKUPPB_BUTTON:
|
|
OnPhoneBookButton(LOWORD(wParam) == IDC_GENERAL_PRIMARYPB_BUTTON ? 0 : 1);
|
|
return (TRUE);
|
|
|
|
case IDC_GENERAL_TAPI_BUTTON:
|
|
OnDialingProperties();
|
|
return (TRUE);
|
|
|
|
case IDC_RADIO_DIRECT:
|
|
MYDBGASSERT(m_pArgs->IsBothConnTypeSupported());
|
|
m_bAPInfoChanged = TRUE;
|
|
if (BN_CLICKED == HIWORD(wParam)) // notification code
|
|
{
|
|
EnableDialupControls(FALSE);
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
case IDC_RADIO_DIALUP:
|
|
|
|
MYDBGASSERT(m_pArgs->IsBothConnTypeSupported());
|
|
m_bAPInfoChanged = TRUE;
|
|
if (BN_CLICKED == HIWORD(wParam)) // notification code
|
|
{
|
|
//
|
|
// NT #356821 - nickball
|
|
//
|
|
// Make sure we don't respond until the click is fully
|
|
// registered as we only want to respond once and in
|
|
// the case of keyboard navigation a BN_CLICKED
|
|
// notification is sent before the button takes the
|
|
// click and afterwards. Mouse navigation causes
|
|
// one notification once the button already has the
|
|
// click. Responding to both clicks get us into a nasty
|
|
// little re-entrancy in IntiDialInfo, so we filter out
|
|
// the first notification
|
|
//
|
|
|
|
if (IsDlgButtonChecked(m_hWnd, IDC_RADIO_DIALUP))
|
|
{
|
|
//
|
|
// Load dialing information, and enable dial-up controls
|
|
//
|
|
|
|
if (ERROR_PORT_NOT_AVAILABLE != InitDialInfo())
|
|
{
|
|
EnableDialupControls(TRUE);
|
|
SetFocus(GetDlgItem(m_hWnd, IDC_GENERAL_PRIMARY_EDIT));
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
case IDC_GENERAL_DELETEAP_BUTTON:
|
|
{
|
|
if (m_pArgs->pszCurrentAccessPoint)
|
|
{
|
|
LPTSTR pszMsg = CmFmtMsg(g_hInst, IDMSG_DELETE_ACCESSPOINT, m_pArgs->pszCurrentAccessPoint);
|
|
|
|
if (pszMsg)
|
|
{
|
|
if (IDYES == MessageBox(m_hWnd,
|
|
pszMsg,
|
|
m_pArgs->szServiceName,
|
|
MB_YESNO | MB_ICONEXCLAMATION | MB_DEFBUTTON2 | MB_APPLMODAL))
|
|
{
|
|
this->DeleteAccessPoint();
|
|
}
|
|
}
|
|
|
|
CmFree(pszMsg);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
case IDC_GENERAL_NEWAP_BUTTON:
|
|
{
|
|
//
|
|
// We need to allow for the case where the user has made a change
|
|
// to a phone number and has now decided to save this to a *new*
|
|
// Access Point (AP). The dialog below asks the user if he/she wants
|
|
// to save the current changes to the "old" AP (i.e. the AP we're
|
|
// just leaving). If the user says No, this means they want to
|
|
// use these settings for the new AP (the one we're about to ask
|
|
// them to name). For this case, we apply all the current phone
|
|
// number information to the new AP, i.e we _don't_ clear out the
|
|
// old phone number settings. See NT bug 301054 for more.
|
|
//
|
|
BOOL bClearOldPhoneNumberSettings = TRUE;
|
|
|
|
BOOL bRes = AccessPointInfoChanged();
|
|
if (bRes && m_pArgs->pszCurrentAccessPoint)
|
|
{
|
|
LPTSTR pszMsg = CmFmtMsg(g_hInst, IDMSG_SAVE_ACCESSPOINT, m_pArgs->pszCurrentAccessPoint);
|
|
if (pszMsg)
|
|
{
|
|
int iRet = MessageBox(m_hWnd,
|
|
pszMsg,
|
|
m_pArgs->szServiceName,
|
|
MB_YESNO | MB_ICONEXCLAMATION | MB_DEFBUTTON1 | MB_APPLMODAL);
|
|
if (IDYES == iRet)
|
|
{
|
|
OnApply();
|
|
}
|
|
else if (IDNO == iRet)
|
|
{
|
|
bClearOldPhoneNumberSettings = FALSE;
|
|
}
|
|
else
|
|
{
|
|
MYDBGASSERT(0);
|
|
}
|
|
}
|
|
|
|
CmFree(pszMsg);
|
|
}
|
|
|
|
LPTSTR pszAPName = NULL;
|
|
CNewAccessPointDlg NewAccessPointDlg(m_pArgs, &pszAPName);
|
|
|
|
if (IDOK == NewAccessPointDlg.DoDialogBox(g_hInst, IDD_NEW_ACCESSPOINT, m_hWnd))
|
|
{
|
|
MYDBGASSERT(pszAPName);
|
|
AddNewAPToReg(pszAPName, bClearOldPhoneNumberSettings);
|
|
|
|
if (FALSE == bClearOldPhoneNumberSettings)
|
|
{
|
|
//
|
|
// Since we didn't clear the phone number settings, we've
|
|
// left them in place as initial values for the new AP. We
|
|
// need to mark the new AP as 'dirty' so that when the current
|
|
// AP changes, the UI will ask the user to save changes.
|
|
// (there's no significance attached to choosing IDC_GENERAL_PRIMARY_EDIT, I
|
|
// could just as well have used the other edit control.)
|
|
//
|
|
SendDlgItemMessageU(m_hWnd, IDC_GENERAL_PRIMARY_EDIT, EM_SETMODIFY, TRUE, 0);
|
|
}
|
|
}
|
|
|
|
CmFree(pszAPName);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch (HIWORD(wParam))
|
|
{
|
|
case CBN_SELENDOK:
|
|
|
|
if (IDC_GENERAL_MODEM_COMBO == LOWORD(wParam))
|
|
{
|
|
TCHAR szModem[RAS_MaxDeviceName+1];
|
|
TCHAR szDeviceType[RAS_MaxDeviceType+1];
|
|
|
|
MYDBGASSERT(IDC_GENERAL_MODEM_COMBO == LOWORD(wParam));
|
|
|
|
GetWindowTextU(GetDlgItem(m_hWnd, IDC_GENERAL_MODEM_COMBO),
|
|
szModem, RAS_MaxDeviceName+1);
|
|
|
|
if (lstrcmpU(m_szDeviceName, szModem) == 0)
|
|
{
|
|
// there's no change in the modem
|
|
return FALSE;
|
|
}
|
|
|
|
m_bAPInfoChanged = TRUE;
|
|
//
|
|
// If GetDeviceType fails we won't in fact change the
|
|
// modem even though the user thinks that we did.
|
|
// Logic could possibly be added to notify the user
|
|
// and refresh the device list, but this is a fair
|
|
// amount of work for little gain.
|
|
//
|
|
|
|
if (GetDeviceType(m_pArgs, szDeviceType, szModem))
|
|
{
|
|
lstrcpyU(m_szDeviceName, szModem);
|
|
lstrcpyU(m_szDeviceType, szDeviceType);
|
|
|
|
//
|
|
// CheckTapi will check (m_szDeviceName)
|
|
//
|
|
CheckTapi(&m_pArgs->tlsTapiLink, g_hInst);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// The selection in the Access Point combo box
|
|
// has changed. Now we have to load the dialing information for
|
|
// the newly selected Access Point
|
|
//
|
|
MYDBGASSERT(IDC_GENERAL_ACCESSPOINT_COMBO == LOWORD(wParam));
|
|
BOOL bRes = AccessPointInfoChanged();
|
|
if (bRes && m_pArgs->pszCurrentAccessPoint)
|
|
{
|
|
//
|
|
// If the dialing info. for the previous Access Point has changed, ask the
|
|
// user if he wants to save the changes
|
|
//
|
|
LPTSTR pszMsg = CmFmtMsg(g_hInst, IDMSG_SAVE_ACCESSPOINT, m_pArgs->pszCurrentAccessPoint);
|
|
if (pszMsg)
|
|
{
|
|
if (IDYES == MessageBox(m_hWnd,
|
|
pszMsg,
|
|
m_pArgs->szServiceName,
|
|
MB_YESNO | MB_ICONEXCLAMATION | MB_DEFBUTTON1 | MB_APPLMODAL))
|
|
{
|
|
OnApply();
|
|
}
|
|
}
|
|
|
|
CmFree(pszMsg);
|
|
}
|
|
|
|
//
|
|
// Now call the function to change the Access Point in the combo box
|
|
// and load its parameters into pArgs
|
|
//
|
|
|
|
if (ChangedAccessPoint(m_pArgs, m_hWnd, IDC_GENERAL_ACCESSPOINT_COMBO))
|
|
{
|
|
//
|
|
// Load new dialing info. into controls on the general page
|
|
//
|
|
this->UpdateForNewAccessPoint(TRUE);
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CheckAccessToCmpAndRasPbk
|
|
//
|
|
// Synopsis: Check to see if the user has the necessary security permissions
|
|
// to make changes to properties. Notifies user if they do not.
|
|
//
|
|
// Arguments: HWND hwndDlg - The hwnd of the calling app.
|
|
// ArgsStruct *pArgs - Ptr to our global args struct.
|
|
//
|
|
// Returns: HRESULT - indicating the particular success or failure.
|
|
//
|
|
// History: nickball 03/14/00 Created header
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT CheckAccessToCmpAndRasPbk(HWND hwndDlg, ArgsStruct *pArgs)
|
|
{
|
|
|
|
MYDBGASSERT(pArgs); // hwndDlg can be NULL
|
|
|
|
if (NULL == pArgs)
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
//
|
|
// Check the cmp, note this could be locked with NTFS perms or just with
|
|
// attrib. HasSpecifiedAccessToFileOrDir should catch both as appropriate.
|
|
//
|
|
LPTSTR pszCmp = CmStrCpyAlloc(pArgs->piniProfile->GetFile());
|
|
LPTSTR pszHiddenRasPbk = NULL;
|
|
LPTSTR pszRasPbk = NULL;
|
|
DWORD dwDesiredAccess = FILE_GENERIC_READ | FILE_GENERIC_WRITE;
|
|
BOOL bHasMainRasPbkAccess = FALSE;
|
|
BOOL bHasHiddenRasPbkAccess = FALSE;
|
|
|
|
if (pszCmp && pszCmp[0])
|
|
{
|
|
//
|
|
// Now check the RAS phonebook
|
|
//
|
|
if (OS_W9X)
|
|
{
|
|
//
|
|
// No phonebook on 9x so skip this check
|
|
//
|
|
bHasMainRasPbkAccess = TRUE;
|
|
bHasHiddenRasPbkAccess = TRUE;
|
|
}
|
|
else
|
|
{
|
|
pszRasPbk = GetPathToPbk((LPCTSTR)pszCmp, pArgs);
|
|
MYDBGASSERT(pszRasPbk);
|
|
CmStrCatAlloc(&pszRasPbk, c_pszRasPhonePbk);
|
|
MYDBGASSERT(pszRasPbk);
|
|
|
|
|
|
if (pszRasPbk && pszRasPbk[0])
|
|
{
|
|
bHasMainRasPbkAccess = HasSpecifiedAccessToFileOrDir(pszRasPbk, dwDesiredAccess);
|
|
|
|
if ((FALSE == bHasMainRasPbkAccess) && (FALSE == FileExists(pszRasPbk)))
|
|
{
|
|
//
|
|
// if the file doesn't exist, give them the
|
|
// benefit of the doubt. We won't get very far if
|
|
// the file doesn't exist and they don't have permissions
|
|
// to create it.
|
|
//
|
|
bHasMainRasPbkAccess = TRUE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now check the hidden RAS phonebook
|
|
//
|
|
if (DOUBLE_DIAL_CONNECTION == pArgs->GetTypeOfConnection())
|
|
{
|
|
pszHiddenRasPbk = CreateRasPrivatePbk(pArgs);
|
|
|
|
if (pszHiddenRasPbk && HasSpecifiedAccessToFileOrDir(pszHiddenRasPbk, dwDesiredAccess))
|
|
{
|
|
bHasHiddenRasPbkAccess = TRUE;
|
|
}
|
|
}
|
|
|
|
else
|
|
{
|
|
bHasHiddenRasPbkAccess = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Only set hr to success if we have access to both
|
|
//
|
|
HRESULT hr;
|
|
|
|
if (bHasMainRasPbkAccess && bHasHiddenRasPbkAccess)
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = E_ACCESSDENIED;
|
|
LPTSTR pszProblemFile = NULL;
|
|
|
|
if (!bHasMainRasPbkAccess)
|
|
{
|
|
pszProblemFile = pszRasPbk;
|
|
}
|
|
else if (!bHasHiddenRasPbkAccess)
|
|
{
|
|
pszProblemFile = pszHiddenRasPbk;
|
|
}
|
|
|
|
if (NULL != pszProblemFile)
|
|
{
|
|
LPTSTR pszMsg = CmFmtMsg(g_hInst, IDMSG_NO_CMP_PBK_ACCESS, pszProblemFile);
|
|
if (pszMsg)
|
|
{
|
|
MessageBox(hwndDlg, pszMsg, pArgs->szServiceName, MB_OK | MB_ICONERROR);
|
|
CmFree(pszMsg);
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// Cleanup
|
|
//
|
|
CmFree(pszCmp);
|
|
CmFree(pszRasPbk);
|
|
CmFree(pszHiddenRasPbk);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CGeneralPage::OnApply()
|
|
//
|
|
// Synopsis: Save the data associated with the 'Dialing' property sheet.
|
|
// when the user clicks OK.
|
|
//
|
|
// Returns: NONE
|
|
//
|
|
// History: henryt Created 4/30/97
|
|
// byao Modified 5/23/97
|
|
// Always update modem when user selected OK from
|
|
// 'Properties' button
|
|
//----------------------------------------------------------------------------
|
|
void CGeneralPage::OnApply()
|
|
{
|
|
BOOL fDirect = IsDlgButtonChecked(m_hWnd, IDC_RADIO_DIRECT);
|
|
LPTSTR pszTmp = NULL;
|
|
|
|
//
|
|
// If access points are enabled save the current access point to the registry
|
|
//
|
|
if (m_pArgs->fAccessPointsEnabled)
|
|
{
|
|
WriteUserInfoToReg(m_pArgs, UD_ID_CURRENTACCESSPOINT, (PVOID)(m_pArgs->pszCurrentAccessPoint));
|
|
}
|
|
|
|
if (!fDirect)
|
|
{
|
|
//
|
|
// Before we go anywhere, make sure that the device is acceptable
|
|
// otherwise, we won't be able to munge the phone number
|
|
//
|
|
if (!SetTapiDevice(g_hInst, &m_pArgs->tlsTapiLink, m_szDeviceName))
|
|
{
|
|
pszTmp = CmFmtMsg(g_hInst, IDMSG_UNSUPPORTED_DEVICE);
|
|
|
|
MessageBoxEx(m_hWnd, pszTmp, m_pArgs->szServiceName,
|
|
MB_OK | MB_ICONINFORMATION, LANG_USER_DEFAULT);
|
|
CmFree(pszTmp);
|
|
SetPropSheetResult(PSNRET_INVALID_NOCHANGEPAGE);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Device is ok, see if TAPI is properly intialized.
|
|
// Don't proceed unless it is.
|
|
//
|
|
|
|
if (!CheckTapi(&m_pArgs->tlsTapiLink, g_hInst))
|
|
{
|
|
SetPropSheetResult(PSNRET_INVALID_NOCHANGEPAGE);
|
|
return;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Save connection type information
|
|
//
|
|
|
|
m_pArgs->SetDirectConnect(fDirect);
|
|
m_pArgs->piniProfile->WPPI(c_pszCmSection, c_pszCmEntryConnectionType, fDirect);
|
|
|
|
|
|
//
|
|
// If dial-up data was not initialized, there
|
|
// is no need to update phone number info.
|
|
//
|
|
|
|
if (m_bDialInfoInit)
|
|
{
|
|
|
|
//
|
|
// Store the current TAPI location
|
|
//
|
|
DWORD dwCurrentTapiLoc = GetCurrentTapiLocation(&m_pArgs->tlsTapiLink);
|
|
if (-1 != dwCurrentTapiLoc)
|
|
{
|
|
m_pArgs->tlsTapiLink.dwTapiLocationForAccessPoint = dwCurrentTapiLoc;
|
|
m_pArgs->piniProfile->WPPI(c_pszCmSection, c_pszCmEntryTapiLocation, dwCurrentTapiLoc);
|
|
}
|
|
|
|
//
|
|
// Update device name and type
|
|
//
|
|
|
|
lstrcpynU(m_pArgs->szDeviceName, m_szDeviceName, CELEMS(m_pArgs->szDeviceName));
|
|
lstrcpynU(m_pArgs->szDeviceType, m_szDeviceType, CELEMS(m_pArgs->szDeviceType));
|
|
|
|
//
|
|
// Update the CMP
|
|
//
|
|
|
|
m_pArgs->piniProfile->WPPS(c_pszCmSection,
|
|
c_pszCmEntryDialDevice,
|
|
m_pArgs->szDeviceName);
|
|
|
|
//
|
|
// Check each number to see if we need to update CMP or connectoids
|
|
//
|
|
|
|
for (UINT i = 0; i < m_NumPhones; i++)
|
|
{
|
|
int iEditID = i ? IDC_GENERAL_BACKUP_EDIT : IDC_GENERAL_PRIMARY_EDIT;
|
|
|
|
//
|
|
// If Dialing Rules aren't used, it is likely that the user has
|
|
// modified the phone number, get number and munge it. In the
|
|
// case of fNoDialingRules we skip this test to be certain that
|
|
// we pick up any user changes.
|
|
//
|
|
|
|
if (!(m_DialInfo[i].dwPhoneInfoFlags & PIF_USE_DIALING_RULES))
|
|
{
|
|
pszTmp = CmGetWindowTextAlloc(m_hWnd, iEditID);
|
|
|
|
if (*pszTmp)
|
|
{
|
|
//
|
|
// Ensure that phone number doesn't exceed storage size
|
|
// Note: On W2K the edit limits prevent pasting an excess
|
|
// amount of data, but we truncate to be positive across
|
|
// all versions of Windows.
|
|
//
|
|
|
|
if (lstrlenU(pszTmp) > RAS_MaxPhoneNumber)
|
|
{
|
|
pszTmp[RAS_MaxPhoneNumber] = TEXT('\0');
|
|
}
|
|
|
|
//
|
|
// If we're ignoring dialing rules, just get our data directly
|
|
//
|
|
|
|
if (m_pArgs->fNoDialingRules)
|
|
{
|
|
lstrcpynU(m_DialInfo[i].szPhoneNumber, pszTmp, CELEMS(m_DialInfo[i].szPhoneNumber));
|
|
lstrcpynU(m_DialInfo[i].szDisplayablePhoneNumber, pszTmp, CELEMS(m_DialInfo[i].szDisplayablePhoneNumber));
|
|
lstrcpynU(m_DialInfo[i].szDialablePhoneNumber, pszTmp, CELEMS(m_DialInfo[i].szDialablePhoneNumber));
|
|
m_DialInfo[i].szCanonical[0] = TEXT('\0');
|
|
}
|
|
else
|
|
{
|
|
LPTSTR pszPhone = CmStrCpyAlloc(pszTmp);
|
|
LPTSTR pszDialable = NULL;
|
|
|
|
MYDBGASSERT(m_szDeviceName[0]);
|
|
|
|
//
|
|
// Munge the number to ensure that we have the correct dialable
|
|
//
|
|
if (ERROR_SUCCESS != MungePhone(m_szDeviceName,
|
|
&pszPhone,
|
|
&m_pArgs->tlsTapiLink,
|
|
g_hInst,
|
|
m_DialInfo[i].dwPhoneInfoFlags & PIF_USE_DIALING_RULES,
|
|
&pszDialable,
|
|
m_pArgs->fAccessPointsEnabled))
|
|
{
|
|
CmFree(pszTmp);
|
|
|
|
//
|
|
// Can't format the number, notify user of the problem
|
|
//
|
|
|
|
pszTmp = CmFmtMsg(g_hInst, IDMSG_CANTFORMAT);
|
|
MessageBoxEx(m_hWnd, pszTmp, m_pArgs->szServiceName,
|
|
MB_OK | MB_ICONINFORMATION, LANG_USER_DEFAULT);
|
|
CmFree(pszTmp);
|
|
CmFree(pszPhone);
|
|
SetPropSheetResult(PSNRET_INVALID_NOCHANGEPAGE);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Update buffers
|
|
//
|
|
if (pszDialable)
|
|
{
|
|
lstrcpynU(m_DialInfo[i].szDialablePhoneNumber, pszDialable, CELEMS(m_DialInfo[i].szDialablePhoneNumber));
|
|
}
|
|
|
|
if (pszPhone)
|
|
{
|
|
lstrcpynU(m_DialInfo[i].szDisplayablePhoneNumber, pszPhone, CELEMS(m_DialInfo[i].szDisplayablePhoneNumber));
|
|
}
|
|
|
|
//
|
|
// If we find a plus in the first char, assume that the user is
|
|
// attempting canonical format by hand and treat as a dialing
|
|
// rules number. Either way, update the szPhoneNumber buffer.
|
|
//
|
|
|
|
if (pszTmp == CmStrchr(pszTmp, TEXT('+')))
|
|
{
|
|
//
|
|
// Its hand-edited canonical. Store the canonical
|
|
// form in szCanonical, then strip the canonical
|
|
// formatting before we store the number normally
|
|
//
|
|
|
|
m_DialInfo[i].dwPhoneInfoFlags |= PIF_USE_DIALING_RULES;
|
|
|
|
lstrcpynU(m_DialInfo[i].szCanonical, pszTmp, CELEMS(m_DialInfo[i].szCanonical));
|
|
StripCanonical(pszTmp);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// If UDR check is disabled, then its a hand edited number,
|
|
// so remove canonical form of the number - as an indicator.
|
|
//
|
|
|
|
if (!IsWindowEnabled(GetDlgItem(m_hWnd, i ?
|
|
IDC_GENERAL_UDR2_CHECKBOX :
|
|
IDC_GENERAL_UDR1_CHECKBOX)))
|
|
{
|
|
m_DialInfo[i].szCanonical[0] = TEXT('\0');
|
|
}
|
|
}
|
|
|
|
lstrcpynU(m_DialInfo[i].szPhoneNumber, pszTmp, CELEMS(m_DialInfo[i].szPhoneNumber));
|
|
CmFree(pszDialable);
|
|
CmFree(pszPhone);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// No number, clear everything
|
|
//
|
|
|
|
ZeroMemory(&m_DialInfo[i], sizeof(PHONEINFO));
|
|
}
|
|
|
|
CmFree(pszTmp);
|
|
}
|
|
|
|
//
|
|
// Copy the new phone #'s back to our global struct
|
|
//
|
|
|
|
lstrcpynU(m_pArgs->aDialInfo[i].szPhoneBookFile,
|
|
m_DialInfo[i].szPhoneBookFile, CELEMS(m_pArgs->aDialInfo[i].szPhoneBookFile));
|
|
|
|
lstrcpynU(m_pArgs->aDialInfo[i].szDUN,
|
|
m_DialInfo[i].szDUN, CELEMS(m_pArgs->aDialInfo[i].szDUN));
|
|
|
|
lstrcpynU(m_pArgs->aDialInfo[i].szPhoneNumber,
|
|
m_DialInfo[i].szPhoneNumber, CELEMS(m_pArgs->aDialInfo[i].szPhoneNumber));
|
|
|
|
//
|
|
// Always store canonical as canonical
|
|
//
|
|
|
|
lstrcpynU(m_pArgs->aDialInfo[i].szCanonical,
|
|
m_DialInfo[i].szCanonical, CELEMS(m_pArgs->aDialInfo[i].szCanonical));
|
|
|
|
lstrcpynU(m_pArgs->aDialInfo[i].szDialablePhoneNumber,
|
|
m_DialInfo[i].szDialablePhoneNumber, CELEMS(m_pArgs->aDialInfo[i].szDialablePhoneNumber));
|
|
|
|
lstrcpynU(m_pArgs->aDialInfo[i].szDisplayablePhoneNumber,
|
|
m_DialInfo[i].szDisplayablePhoneNumber, CELEMS(m_pArgs->aDialInfo[i].szDisplayablePhoneNumber));
|
|
|
|
lstrcpynU(m_pArgs->aDialInfo[i].szDesc, m_DialInfo[i].szDesc, CELEMS(m_pArgs->aDialInfo[i].szDesc));
|
|
|
|
m_pArgs->aDialInfo[i].dwCountryID = m_DialInfo[i].dwCountryID;
|
|
|
|
lstrcpynU(m_pArgs->aDialInfo[i].szServiceType,
|
|
m_DialInfo[i].szServiceType, CELEMS(m_pArgs->aDialInfo[i].szServiceType));
|
|
|
|
lstrcpynU(m_pArgs->aDialInfo[i].szRegionName,
|
|
m_DialInfo[i].szRegionName, CELEMS(m_pArgs->aDialInfo[i].szRegionName));
|
|
|
|
m_pArgs->aDialInfo[i].dwPhoneInfoFlags = m_DialInfo[i].dwPhoneInfoFlags;
|
|
|
|
//
|
|
// Write them out to cmp
|
|
//
|
|
|
|
PutPhoneByIdx(m_pArgs,
|
|
i,
|
|
m_pArgs->aDialInfo[i].szPhoneNumber,
|
|
m_pArgs->aDialInfo[i].szDesc,
|
|
m_pArgs->aDialInfo[i].szDUN,
|
|
m_pArgs->aDialInfo[i].dwCountryID,
|
|
m_pArgs->aDialInfo[i].szRegionName,
|
|
m_pArgs->aDialInfo[i].szServiceType,
|
|
m_pArgs->aDialInfo[i].szPhoneBookFile,
|
|
m_pArgs->aDialInfo[i].szCanonical,
|
|
m_pArgs->aDialInfo[i].dwPhoneInfoFlags);
|
|
|
|
} // for {}
|
|
}
|
|
|
|
//
|
|
// Update fUseTunneling by examining first phonenumber.
|
|
//
|
|
|
|
if (fDirect)
|
|
{
|
|
m_pArgs->fUseTunneling = TRUE;
|
|
}
|
|
else
|
|
{
|
|
m_pArgs->fUseTunneling = UseTunneling(m_pArgs, 0);
|
|
}
|
|
|
|
if (FAILED(CheckAccessToCmpAndRasPbk(m_hWnd, m_pArgs)))
|
|
{
|
|
SetPropSheetResult(PSNRET_INVALID_NOCHANGEPAGE);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
SetPropSheetResult(PSNRET_NOERROR);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CGeneralPage::OnKillActive
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_NOTIFY with PSN_KILLACTIVE
|
|
// Notifies a page that it is about to lose activation either because
|
|
// another page is being activated or the user has clicked the OK button.
|
|
// Arguments: None
|
|
//
|
|
// Returns: BOOL - return value of the message
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL CGeneralPage::OnKillActive()
|
|
{
|
|
//
|
|
// Notify the event listener for the current connection type selection
|
|
//
|
|
if (m_pEventListener)
|
|
{
|
|
m_pEventListener->OnGeneralPageKillActive(
|
|
IsDlgButtonChecked(m_hWnd, IDC_RADIO_DIRECT));
|
|
}
|
|
|
|
//
|
|
// Hide any open balloon tips
|
|
//
|
|
if (m_pArgs->pBalloonTip)
|
|
{
|
|
m_pArgs->pBalloonTip->HideBalloonTip();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// Help id pairs for the page
|
|
//
|
|
const DWORD CInetPage::m_dwHelp[] = {
|
|
IDC_INET_USERNAME_STATIC, IDH_INTERNET_USER_NAME,
|
|
IDC_INET_USERNAME, IDH_INTERNET_USER_NAME,
|
|
IDC_INET_PASSWORD_STATIC, IDH_INTERNET_PASSWORD,
|
|
IDC_INET_PASSWORD, IDH_INTERNET_PASSWORD,
|
|
IDC_INET_REMEMBER, IDH_INTERNET_SAVEPASS,
|
|
0,0};
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CInetPage::CInetPage
|
|
//
|
|
// Synopsis: Constructor
|
|
//
|
|
// Arguments: ArgsStruct* pArgs - Information needed for the page
|
|
// UINT nIDTemplate - Resource ID
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
CInetPage::CInetPage(ArgsStruct* pArgs, UINT nIDTemplate)
|
|
: CPropertiesPage(nIDTemplate, m_dwHelp, pArgs->pszHelpFile)
|
|
{
|
|
MYDBGASSERT(pArgs);
|
|
m_pArgs = pArgs;
|
|
m_fDirect = pArgs->IsDirectConnect();
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: OnInetInit
|
|
//
|
|
// Synopsis: Init the 'Internet Sign-In' properties property sheet.
|
|
//
|
|
// Arguments: hwndDlg [dlg window handle]
|
|
// pArgs [the ptr to ArgsStruct]
|
|
//
|
|
// Returns: NONE
|
|
//
|
|
// History: henryt Created 4/30/97
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
void CInetPage::OnInetInit(
|
|
HWND hwndDlg,
|
|
ArgsStruct *pArgs
|
|
)
|
|
{
|
|
//
|
|
// The inet dialog/page is displayed only if fUseSameUserName is FALSE
|
|
//
|
|
MYDBGASSERT( pArgs->fUseSameUserName == FALSE);
|
|
|
|
//
|
|
// set the length limit for the edit controls
|
|
//
|
|
UINT i;
|
|
|
|
HWND hwndUserName = GetDlgItem(hwndDlg, IDC_INET_USERNAME);
|
|
if (hwndUserName)
|
|
{
|
|
i = (UINT)pArgs->piniService->GPPI(c_pszCmSection, c_pszCmEntryMaxUserName, UNLEN);
|
|
SendDlgItemMessageU(hwndDlg, IDC_INET_USERNAME, EM_SETLIMITTEXT, __min(UNLEN, i), 0);
|
|
SetDlgItemTextU(hwndDlg, IDC_INET_USERNAME, pArgs->szInetUserName);
|
|
SendMessageU(hwndUserName, EM_SETMODIFY, (WPARAM)FALSE, 0L);
|
|
}
|
|
|
|
HWND hwndInetPassword = GetDlgItem(hwndDlg, IDC_INET_PASSWORD);
|
|
if (hwndInetPassword)
|
|
{
|
|
i = (UINT)pArgs->piniService->GPPI(c_pszCmSection, c_pszCmEntryMaxPassword, PWLEN);
|
|
SendDlgItemMessageU(hwndDlg, IDC_INET_PASSWORD, EM_SETLIMITTEXT, __min(PWLEN, i), 0);
|
|
|
|
LPTSTR pszClearInetPassword = NULL;
|
|
DWORD cbClearInetPassword = 0;
|
|
BOOL fRetPassword = FALSE;
|
|
|
|
fRetPassword = pArgs->SecureInetPW.GetPasswordWithAlloc(&pszClearInetPassword, &cbClearInetPassword);
|
|
|
|
if (fRetPassword && pszClearInetPassword)
|
|
{
|
|
SetDlgItemTextU(hwndDlg, IDC_INET_PASSWORD, pszClearInetPassword);
|
|
|
|
//
|
|
// Clear and Free the clear-text password
|
|
//
|
|
|
|
pArgs->SecureInetPW.ClearAndFree(&pszClearInetPassword, cbClearInetPassword);
|
|
}
|
|
|
|
SendMessageU(hwndInetPassword, EM_SETMODIFY, (WPARAM)FALSE, 0L);
|
|
|
|
//
|
|
// hide and the "remember password checkbox if needed
|
|
//
|
|
if (pArgs->fHideRememberInetPassword)
|
|
{
|
|
ShowWindow(GetDlgItem(hwndDlg, IDC_INET_REMEMBER), SW_HIDE);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Check the button first, then adjust it.
|
|
//
|
|
CheckDlgButton(hwndDlg, IDC_INET_REMEMBER, pArgs->fRememberInetPassword);
|
|
|
|
BOOL fPasswordOptional = pArgs->piniService->GPPB(c_pszCmSection,c_pszCmEntryPwdOptional);
|
|
BOOL fEmptyPassword = pArgs->SecureInetPW.IsEmptyString();
|
|
|
|
//
|
|
// Enable/Disable check/uncheck the "Save Password" accordingly
|
|
// fPasswordOptional is always FALSE for the dialog
|
|
//
|
|
AdjustSavePasswordCheckBox(GetDlgItem(hwndDlg, IDC_INET_REMEMBER),
|
|
fEmptyPassword, pArgs->fDialAutomatically, fPasswordOptional);
|
|
}
|
|
}
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: OnInetOk
|
|
//
|
|
// Synopsis: Save the data associated with the 'Internet Sign-In' property sheet.
|
|
// when the user clicks OK.
|
|
//
|
|
// Arguments: hwndDlg [dlg window handle]
|
|
// pArgs [the ptr to ArgsStruct]
|
|
//
|
|
// Returns: NONE
|
|
//
|
|
// History: henryt Created 4/30/97
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
void CInetPage::OnInetOk(
|
|
HWND hwndDlg,
|
|
ArgsStruct *pArgs
|
|
)
|
|
{
|
|
LPTSTR pszTmp = NULL;
|
|
|
|
|
|
//
|
|
// update password
|
|
//
|
|
|
|
if (GetDlgItem(hwndDlg, IDC_INET_PASSWORD))
|
|
{
|
|
pszTmp = CmGetWindowTextAlloc(hwndDlg, IDC_INET_PASSWORD);
|
|
|
|
if (!pArgs->fHideRememberInetPassword)
|
|
{
|
|
pArgs->fRememberInetPassword = IsDlgButtonChecked(hwndDlg, IDC_INET_REMEMBER);
|
|
SaveUserInfo(pArgs,
|
|
UD_ID_REMEMBER_INET_PASSWORD,
|
|
(PVOID)&pArgs->fRememberInetPassword);
|
|
}
|
|
|
|
//
|
|
// If don't remember password, then store an empty string, but keep
|
|
// the existing one in memory. Otherwise, save the user's password.
|
|
//
|
|
|
|
if (pArgs->fRememberInetPassword)
|
|
{
|
|
if (OS_NT5)
|
|
{
|
|
//
|
|
// If we are saving user creds, we can leave globals
|
|
//
|
|
if (CM_CREDS_GLOBAL == pArgs->dwCurrentCredentialType)
|
|
{
|
|
//
|
|
// Delete local/user since we are saving global credentials
|
|
//
|
|
DeleteSavedCredentials(pArgs, CM_CREDS_TYPE_INET, CM_DELETE_SAVED_CREDS_KEEP_GLOBALS, CM_DELETE_SAVED_CREDS_DELETE_IDENTITY);
|
|
pArgs->dwExistingCredentials &= ~CM_EXIST_CREDS_INET_USER;
|
|
}
|
|
}
|
|
|
|
SaveUserInfo(pArgs, UD_ID_INET_PASSWORD, (PVOID)pszTmp);
|
|
}
|
|
else
|
|
{
|
|
if (OS_NT5)
|
|
{
|
|
if (CM_CREDS_GLOBAL == pArgs->dwCurrentCredentialType)
|
|
{
|
|
//
|
|
// Deleting Internet Globals
|
|
//
|
|
if (CM_EXIST_CREDS_INET_GLOBAL & pArgs->dwExistingCredentials)
|
|
{
|
|
DeleteSavedCredentials(pArgs, CM_CREDS_TYPE_INET, CM_DELETE_SAVED_CREDS_DELETE_GLOBALS, CM_DELETE_SAVED_CREDS_DELETE_IDENTITY);
|
|
pArgs->dwExistingCredentials &= ~CM_EXIST_CREDS_INET_GLOBAL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Deleting Internet User
|
|
//
|
|
if (CM_EXIST_CREDS_INET_USER & pArgs->dwExistingCredentials)
|
|
{
|
|
DeleteSavedCredentials(pArgs, CM_CREDS_TYPE_INET, CM_DELETE_SAVED_CREDS_KEEP_GLOBALS, CM_DELETE_SAVED_CREDS_KEEP_IDENTITY);
|
|
pArgs->dwExistingCredentials &= ~CM_EXIST_CREDS_INET_USER;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DeleteUserInfo(pArgs, UD_ID_INET_PASSWORD);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Update pArgs
|
|
//
|
|
|
|
(VOID)pArgs->SecureInetPW.SetPassword(pszTmp);
|
|
|
|
CmWipePassword(pszTmp);
|
|
CmFree(pszTmp);
|
|
pszTmp = NULL;
|
|
}
|
|
|
|
|
|
DWORD dwCurrentCreds = pArgs->dwCurrentCredentialType;
|
|
|
|
//
|
|
// If the user isn't saving his password and the credential
|
|
// store is global, then we need to switch to the user
|
|
// credential store in order to cache the user name for next use
|
|
//
|
|
if ((FALSE == pArgs->fRememberInetPassword) &&
|
|
(CM_CREDS_GLOBAL == pArgs->dwCurrentCredentialType))
|
|
{
|
|
pArgs->dwCurrentCredentialType = CM_CREDS_USER;
|
|
}
|
|
|
|
//
|
|
// Get User name
|
|
//
|
|
if (GetDlgItem(hwndDlg, IDC_INET_USERNAME))
|
|
{
|
|
pszTmp = CmGetWindowTextAlloc(hwndDlg, IDC_INET_USERNAME);
|
|
lstrcpyU(pArgs->szInetUserName, pszTmp);
|
|
|
|
//
|
|
// update username if we are saving credentials or
|
|
// we are saving to the user/local credential store.
|
|
//
|
|
if ((pArgs->fRememberInetPassword) || (CM_CREDS_USER == pArgs->dwCurrentCredentialType))
|
|
{
|
|
SaveUserInfo(pArgs, UD_ID_INET_USERNAME, (PVOID)pszTmp);
|
|
}
|
|
CmFree(pszTmp);
|
|
pszTmp = NULL;
|
|
}
|
|
|
|
//
|
|
// In case the current credential store was changed to user, we now
|
|
// need to switch it back to global.
|
|
//
|
|
pArgs->dwCurrentCredentialType = dwCurrentCreds;
|
|
|
|
//
|
|
// Need to refresh to see which creds now exist since we could have saved or deleted some
|
|
//
|
|
BOOL fReturn = RefreshCredentialTypes(pArgs, FALSE);
|
|
|
|
CmWipePassword(pszTmp);
|
|
CmFree(pszTmp);
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CInetPage::AdjustSavePasswordCheckBox
|
|
//
|
|
// Synopsis: Enable/Disable, Check/Uncheck the "save Password" check box
|
|
// according to other information
|
|
//
|
|
// Arguments: HWND hwndCheckBox - The window handle of "Save Password" check box
|
|
// BOOL fEmptyPassword - Whether the password edit box is empty
|
|
// BOOL fDialAutomatically - Whether dial automatically is checked
|
|
// BOOL fPasswordOptional - Whether the password is optional
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: fengsun Created Header 4/24/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
void CInetPage::AdjustSavePasswordCheckBox(HWND hwndCheckBox, BOOL fEmptyPassword,
|
|
BOOL fDialAutomatically, BOOL fPasswordOptional)
|
|
{
|
|
MYDBGASSERT(IsWindow(hwndCheckBox)); // if password hidden, no need to adjust
|
|
|
|
//
|
|
// Enable/Disable the check box
|
|
//
|
|
if (fDialAutomatically)
|
|
{
|
|
EnableWindow(hwndCheckBox, FALSE);
|
|
}
|
|
else if (fEmptyPassword && !fPasswordOptional)
|
|
{
|
|
EnableWindow(hwndCheckBox, FALSE);
|
|
}
|
|
else
|
|
{
|
|
EnableWindow(hwndCheckBox, TRUE);
|
|
}
|
|
|
|
//
|
|
// Check/Uncheck the check box
|
|
//
|
|
if (fEmptyPassword && !fPasswordOptional)
|
|
{
|
|
//
|
|
// If there is no password and password is not optional,
|
|
// uncheck the checkbox
|
|
//
|
|
SendMessageU(hwndCheckBox, BM_SETCHECK, BST_UNCHECKED, 0);
|
|
}
|
|
else if (fDialAutomatically)
|
|
{
|
|
//
|
|
// If dial automaticly, which means the checkbox is disabled,
|
|
// check the box if has password or password is optional
|
|
//
|
|
SendMessageU(hwndCheckBox, BM_SETCHECK, BST_CHECKED, 0);
|
|
}
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CInetPage::OnInitDialog
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_INITDIALOG message
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: BOOL - return value of the message
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL CInetPage::OnInitDialog()
|
|
{
|
|
UpdateFont(m_hWnd);
|
|
|
|
m_fPasswordOptional = m_pArgs->piniService->GPPB(c_pszCmSection, c_pszCmEntryPwdOptional);
|
|
|
|
//
|
|
// Initialize all the controls
|
|
//
|
|
OnInetInit(m_hWnd, m_pArgs);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CInetPage::OnCommand
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_COMMAND
|
|
//
|
|
// Arguments: WPARAM - wParam of the message
|
|
// LPARAM - lParam of the message
|
|
//
|
|
// Returns: DWORD - return value of the message
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CInetPage::OnCommand(WPARAM wParam, LPARAM)
|
|
{
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDC_INET_PASSWORD:
|
|
if ((HIWORD(wParam) == EN_CHANGE))
|
|
{
|
|
if (!m_pArgs->fHideRememberInetPassword && !m_pArgs->fHideInetPassword)
|
|
{
|
|
//
|
|
// if there's no password, disable and uncheck "remember password"
|
|
//
|
|
BOOL fEmptyPassword = !SendDlgItemMessageU(m_hWnd, IDC_INET_PASSWORD,
|
|
WM_GETTEXTLENGTH, 0, (LPARAM)0);
|
|
|
|
//
|
|
// Enable/Disable check/uncheck the "Save Password" accordingly
|
|
// fPasswordOptional is always FALSE for the dialog
|
|
//
|
|
AdjustSavePasswordCheckBox(GetDlgItem(m_hWnd, IDC_INET_REMEMBER),
|
|
fEmptyPassword, m_pArgs->fDialAutomatically, m_fPasswordOptional);
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_INET_REMEMBER:
|
|
{
|
|
//
|
|
// If the password wasn't modified by the user we want to clear
|
|
// the edit box. Once the password edit box is empty the
|
|
// Save Password option is disabled, thus we don't ever need to
|
|
// reload the password from memory like on the main dialog.
|
|
//
|
|
BOOL fSavePW = IsDlgButtonChecked(m_hWnd, IDC_INET_REMEMBER);
|
|
|
|
HWND hwndInetPW = GetDlgItem(m_hWnd, IDC_INET_PASSWORD);
|
|
if (hwndInetPW)
|
|
{
|
|
BOOL fInetPWChanged = (BOOL)SendMessageU(hwndInetPW, EM_GETMODIFY, 0L, 0L);
|
|
|
|
if (FALSE == fSavePW && FALSE == fInetPWChanged)
|
|
{
|
|
//
|
|
// Didn't change thus clear the edit box
|
|
//
|
|
SetDlgItemTextU(m_hWnd, IDC_INET_PASSWORD, TEXT(""));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CInetPage::OnApply
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_NOTIFY with PSN_APPLY
|
|
// Indicates that the user clicked the OK or Apply Now button
|
|
// and wants all changes to take effect.
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: NONE
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
void CInetPage::OnApply()
|
|
{
|
|
//
|
|
// Save information only if user chose dial-up
|
|
//
|
|
OnInetOk(m_hWnd, m_pArgs);
|
|
|
|
SetPropSheetResult(PSNRET_NOERROR);
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CInetPage::OnGeneralPageKillActive
|
|
//
|
|
// Synopsis: Receive the KillActive event from General page
|
|
//
|
|
// Arguments: BOOL fDirect - Whehter the current connection type selection in
|
|
// General page is Direct
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: Created Header 4/24/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
void CInetPage::OnGeneralPageKillActive(BOOL fDirect)
|
|
{
|
|
m_fDirect = fDirect;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CInetPage::OnSetActive
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_NOTIFY with PSN_SETACTIVE
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: BOOL - return value of the message
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL CInetPage::OnSetActive()
|
|
{
|
|
//
|
|
// Enable/Disable the control according to the current connection type
|
|
//
|
|
EnableWindow(GetDlgItem(m_hWnd,IDC_INET_USERNAME_STATIC), !m_fDirect);
|
|
EnableWindow(GetDlgItem(m_hWnd,IDC_INET_USERNAME), !m_fDirect);
|
|
EnableWindow(GetDlgItem(m_hWnd,IDC_INET_PASSWORD_STATIC), !m_fDirect);
|
|
EnableWindow(GetDlgItem(m_hWnd,IDC_INET_PASSWORD), !m_fDirect);
|
|
|
|
if (m_fDirect)
|
|
{
|
|
EnableWindow(GetDlgItem(m_hWnd,IDC_INET_REMEMBER), FALSE);
|
|
}
|
|
else if (!m_pArgs->fHideRememberInetPassword && !m_pArgs->fHideInetPassword)
|
|
{
|
|
BOOL fEmptyPassword = !SendDlgItemMessageU(m_hWnd,
|
|
IDC_INET_PASSWORD,
|
|
WM_GETTEXTLENGTH,
|
|
0,
|
|
(LPARAM)0);
|
|
//
|
|
// Enable/Disable check/uncheck the "Save Password" accordingly
|
|
// fPasswordOptional is always FALSE for the dialog
|
|
//
|
|
|
|
AdjustSavePasswordCheckBox(GetDlgItem(m_hWnd, IDC_INET_REMEMBER),
|
|
fEmptyPassword, m_pArgs->fDialAutomatically, m_fPasswordOptional);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
//
|
|
// Help id pairs
|
|
//
|
|
const DWORD COptionPage::m_dwHelp[] = {
|
|
IDC_OPTIONS_IDLETIME_LIST, IDH_OPTIONS_IDLEDIS,
|
|
IDC_STATIC_MINUTES, IDH_OPTIONS_IDLEDIS,
|
|
IDC_OPTIONS_REDIALCOUNT_SPIN, IDH_OPTIONS_REDIAL,
|
|
IDC_OPTIONS_REDIALCOUNT_EDIT, IDH_OPTIONS_REDIAL,
|
|
IDC_STATIC_TIMES, IDH_OPTIONS_REDIAL,
|
|
IDC_OPTIONS_LOGGING, IDH_OPTIONS_LOGGING,
|
|
IDC_OPTIONS_CLEAR_LOG, IDH_OPTIONS_CLEAR_LOG,
|
|
IDC_OPTIONS_VIEW_LOG, IDH_OPTIONS_VIEW_LOG,
|
|
0,0};
|
|
|
|
const DWORD COptionPage::m_adwTimeConst[] = {0,1, 5, 10, 30, 1*60, 2*60, 4*60, 8*60, 24*60};
|
|
const int COptionPage::m_nTimeConstElements = sizeof(m_adwTimeConst)/sizeof(m_adwTimeConst[0]);
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: COptionPage::COptionPage
|
|
//
|
|
// Synopsis: Constructor
|
|
//
|
|
// Arguments: ArgsStruct* pArgs - Information needed for the page
|
|
// UINT nIDTemplate - Resource ID
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
COptionPage::COptionPage(ArgsStruct* pArgs, UINT nIDTemplate)
|
|
: CPropertiesPage(nIDTemplate, m_dwHelp, pArgs->pszHelpFile)
|
|
{
|
|
MYDBGASSERT(pArgs);
|
|
m_pArgs = pArgs;
|
|
m_fEnableLog = FALSE;
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: COptionPage::InitIdleTimeList
|
|
//
|
|
// Synopsis: Populate the IdleTime combo box and set the initial selection
|
|
//
|
|
// Arguments: HWND hwndList - Combo box window handle
|
|
// DWORD dwMinutes - Time in minutes
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: fengsun Created Header 4/22/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
void COptionPage::InitIdleTimeList(HWND hwndList, DWORD dwMinutes)
|
|
{
|
|
MYDBGASSERT(hwndList);
|
|
MYDBGASSERT(IsWindow(hwndList));
|
|
|
|
//
|
|
// Load the string from resource and populate the idle timeout list
|
|
//
|
|
MYDBGASSERT(IDS_IDLETIME_24HOURS - IDS_IDLETIME_NEVER == m_nTimeConstElements-1);
|
|
for (int i= IDS_IDLETIME_NEVER; i<= IDS_IDLETIME_24HOURS; i++)
|
|
{
|
|
LPTSTR pszText = CmLoadString(g_hInst, i);
|
|
MYDBGASSERT(pszText);
|
|
SendMessageU(hwndList, CB_ADDSTRING, 0, (LPARAM)pszText);
|
|
CmFree(pszText);
|
|
}
|
|
|
|
//
|
|
// Value are round down for 1.0 profile
|
|
// Note 0 means never. We are safe, since there is no gap between 0 and 1 minute.
|
|
//
|
|
|
|
int nSel; // the initial selection
|
|
|
|
for (nSel=m_nTimeConstElements-1; nSel>=0;nSel--)
|
|
{
|
|
if (dwMinutes >= m_adwTimeConst[nSel])
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
SendMessageU(hwndList, CB_SETCURSEL, nSel, 0);
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: COptionPage::GetIdleTimeList
|
|
//
|
|
// Synopsis: Retrieve the IdleTime value selected
|
|
//
|
|
// Arguments: HWND hwndList - Combo box window handle
|
|
//
|
|
// Returns: DWORD - User selected timeout value in minutes
|
|
//
|
|
// History: fengsun Created Header 4/22/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD COptionPage::GetIdleTimeList(HWND hwndList)
|
|
{
|
|
//
|
|
// Get the current selection and convert it into minutes
|
|
//
|
|
|
|
DWORD dwSel = (DWORD)SendMessageU(hwndList, CB_GETCURSEL, 0, 0);
|
|
|
|
MYDBGASSERT(dwSel < m_nTimeConstElements);
|
|
if (dwSel >= m_nTimeConstElements) // in case of CB_ERR
|
|
{
|
|
dwSel = 0;
|
|
}
|
|
|
|
return m_adwTimeConst[dwSel];
|
|
}
|
|
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: COptionPage::OnInitDialog()
|
|
//
|
|
// Synopsis: Init the Options property sheet.
|
|
//
|
|
// Returns: NONE
|
|
//
|
|
// History: henryt Created 4/30/97
|
|
// byao Modified 5/12/97 - disable all controls in
|
|
// 'Dialing with connectoid' mode
|
|
//----------------------------------------------------------------------------
|
|
BOOL COptionPage::OnInitDialog()
|
|
{
|
|
UpdateFont(m_hWnd);
|
|
|
|
//
|
|
// init the "Idle timeout before hangup"
|
|
//
|
|
InitIdleTimeList(GetDlgItem(m_hWnd, IDC_OPTIONS_IDLETIME_LIST), m_pArgs->dwIdleTimeout);
|
|
|
|
//
|
|
// init the "Number of redial attempt"
|
|
// Limit Redial edit field to 2 characters, redial spin 0-99
|
|
//
|
|
|
|
SendDlgItemMessageU(m_hWnd, IDC_OPTIONS_REDIALCOUNT_EDIT, EM_SETLIMITTEXT, MAX_REDIAL_CHARS, 0);
|
|
SendDlgItemMessageU(m_hWnd, IDC_OPTIONS_REDIALCOUNT_SPIN, UDM_SETRANGE , 0, MAKELONG(MAX_NUMBER_OF_REDIALS,0));
|
|
SetDlgItemInt(m_hWnd, IDC_OPTIONS_REDIALCOUNT_EDIT, m_pArgs->nMaxRedials, FALSE);
|
|
|
|
//
|
|
// set logging state
|
|
//
|
|
m_fEnableLog = m_pArgs->Log.IsEnabled();
|
|
CheckDlgButton(m_hWnd, IDC_OPTIONS_LOGGING, m_fEnableLog);
|
|
|
|
if (IsLogonAsSystem() || (FALSE == m_fEnableLog))
|
|
{
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_OPTIONS_VIEW_LOG), FALSE);
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_OPTIONS_CLEAR_LOG), FALSE);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: COptionPage::OnCommand
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_COMMAND
|
|
//
|
|
// Arguments: WPARAM - wParam of the message
|
|
// LPARAM - lParam of the message
|
|
//
|
|
// Returns: DWORD - return value of the message
|
|
//
|
|
// History: SumitC Created 7/18/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD COptionPage::OnCommand(WPARAM wParam, LPARAM)
|
|
{
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDC_OPTIONS_LOGGING:
|
|
{
|
|
BOOL fEnabled = ToggleLogging();
|
|
|
|
if (FALSE == IsLogonAsSystem())
|
|
{
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_OPTIONS_VIEW_LOG), fEnabled);
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_OPTIONS_CLEAR_LOG), fEnabled);
|
|
}
|
|
|
|
//
|
|
// Also, toggle the SafeNet log setting if we are using it...
|
|
//
|
|
if (ConfiguredToDialWithSafeNet(m_pArgs))
|
|
{
|
|
SafeNetLinkageStruct SnLinkage = {0};
|
|
|
|
if (LinkToSafeNet(&SnLinkage))
|
|
{
|
|
if (SnLinkage.pfnSnPolicySet(SN_USELOGFILE, (VOID*)&fEnabled))
|
|
{
|
|
MYVERIFY(0 != SnLinkage.pfnSnPolicyReload());
|
|
}
|
|
else
|
|
{
|
|
DWORD dwError = GetLastError();
|
|
CMTRACE1(TEXT("COptionPage::OnCommand -- unable to toggle the SafeNet log file. SnPolicySet failed with GLE %d"), dwError);
|
|
}
|
|
|
|
UnLinkFromSafeNet(&SnLinkage);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_OPTIONS_CLEAR_LOG:
|
|
MYDBGASSERT(FALSE == IsLogonAsSystem());
|
|
if (FALSE == IsLogonAsSystem())
|
|
{
|
|
m_pArgs->Log.Clear();
|
|
m_pArgs->Log.Log(CLEAR_LOG_EVENT);
|
|
|
|
//
|
|
// Also, clear the SafeNet log if we are using it...
|
|
//
|
|
if (ConfiguredToDialWithSafeNet(m_pArgs))
|
|
{
|
|
SafeNetLinkageStruct SnLinkage = {0};
|
|
BOOL bUseLogFile = FALSE;
|
|
|
|
if (LinkToSafeNet(&SnLinkage))
|
|
{
|
|
if (SnLinkage.pfnSnPolicySet(SN_USELOGFILE, (VOID*)&bUseLogFile) && SnLinkage.pfnSnPolicyReload())
|
|
{
|
|
LPTSTR pszFullPathToSafeNetLogFile = GetPathToSafeNetLogFile();
|
|
|
|
if (pszFullPathToSafeNetLogFile)
|
|
{
|
|
DWORD dwCount = 0;
|
|
|
|
//
|
|
// Unfortunately, the SafeNet log file isn't always ready to be deleted when the
|
|
// policy reload function returns. Thus I have added this nasty little loop to
|
|
// check to see if the file exists and then try to delete it. If it fails to delete it
|
|
// (usually with a last error of 0 in my testing), then we sleep for a second and try
|
|
// again. Usually it works the first or second time but we will try up to five times.
|
|
// if it doesn't work by then not a huge loss...
|
|
//
|
|
while (FileExists(pszFullPathToSafeNetLogFile) && (dwCount <= 5))
|
|
{
|
|
if (0 == DeleteFileU(pszFullPathToSafeNetLogFile))
|
|
{
|
|
CMTRACE(TEXT("COptionPage::OnCommand -- unable to delete the SafeNet log file. Sleeping 1 second..."));
|
|
Sleep(1000);
|
|
}
|
|
|
|
dwCount++;
|
|
}
|
|
|
|
CmFree(pszFullPathToSafeNetLogFile);
|
|
|
|
bUseLogFile = TRUE;
|
|
MYVERIFY(0 != SnLinkage.pfnSnPolicySet(SN_USELOGFILE, (VOID*)&bUseLogFile));
|
|
MYVERIFY(0 != SnLinkage.pfnSnPolicyReload());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DWORD dwError = GetLastError();
|
|
CMTRACE1(TEXT("COptionPage::OnCommand -- unable to clear the log file. SnPolicySet failed with GLE %d"), dwError);
|
|
}
|
|
|
|
UnLinkFromSafeNet(&SnLinkage);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_OPTIONS_VIEW_LOG:
|
|
MYDBGASSERT(FALSE == IsLogonAsSystem());
|
|
if (FALSE == IsLogonAsSystem())
|
|
{
|
|
LPCTSTR pszLogFile = m_pArgs->Log.GetLogFilePath();
|
|
|
|
HANDLE hFile = CreateFile(pszLogFile, 0,
|
|
FILE_SHARE_READ,
|
|
NULL, OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL, NULL);
|
|
|
|
if (INVALID_HANDLE_VALUE != hFile)
|
|
{
|
|
BOOL bReturn;
|
|
SHELLEXECUTEINFO sei;
|
|
|
|
ZeroMemory(&sei, sizeof(SHELLEXECUTEINFO));
|
|
|
|
//
|
|
// Fill in the Execute Struct
|
|
//
|
|
sei.cbSize = sizeof(SHELLEXECUTEINFO);
|
|
sei.hwnd = NULL;
|
|
sei.lpVerb = TEXT("open");
|
|
sei.lpFile = TEXT("notepad.exe");
|
|
sei.lpParameters = pszLogFile;
|
|
sei.nShow = SW_SHOWNORMAL;
|
|
|
|
bReturn = m_pArgs->m_ShellDll.ExecuteEx(&sei);
|
|
|
|
if (FALSE == bReturn)
|
|
{
|
|
CMTRACE1(TEXT("COptionPage::OnCommand, failed to View Log, GLE=%d"), GetLastError());
|
|
|
|
LPTSTR pszMsg = CmFmtMsg(g_hInst, IDMSG_CANT_VIEW_LOG, pszLogFile);
|
|
if (pszMsg)
|
|
{
|
|
MessageBox(m_hWnd, pszMsg, m_pArgs->szServiceName, MB_OK | MB_ICONERROR);
|
|
CmFree(pszMsg);
|
|
}
|
|
}
|
|
|
|
CloseHandle(hFile);
|
|
}
|
|
else
|
|
{
|
|
CMTRACE(TEXT("COptionPage::OnCommand, no log file, nothing to view"));
|
|
LPTSTR pszMsg = CmFmtMsg(g_hInst, IDMSG_NO_LOG_FILE);
|
|
if (pszMsg)
|
|
{
|
|
MessageBox(m_hWnd, pszMsg, m_pArgs->szServiceName, MB_OK | MB_ICONERROR);
|
|
CmFree(pszMsg);
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: COptionPage::OnApply()
|
|
//
|
|
// Synopsis: Save the data associated with the 'Options' property sheet.
|
|
// when the user clicks OK.
|
|
//
|
|
// Returns: NONE
|
|
//
|
|
// History: henryt Created 4/30/97
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
void COptionPage::OnApply()
|
|
{
|
|
//
|
|
// Accessing RedialCount and IdleTimeout. Make sure to use piniBothNonFav
|
|
// because these settings are per user, per profile.
|
|
//
|
|
|
|
//
|
|
// save the "Idle timeout before hangup"
|
|
//
|
|
m_pArgs->dwIdleTimeout = GetIdleTimeList(GetDlgItem(m_hWnd, IDC_OPTIONS_IDLETIME_LIST));
|
|
m_pArgs->piniBothNonFav->WPPI(c_pszCmSection, c_pszCmEntryIdleTimeout, m_pArgs->dwIdleTimeout);
|
|
|
|
//
|
|
// save the redial settings
|
|
//
|
|
|
|
m_pArgs->nMaxRedials = GetDlgItemInt(m_hWnd, IDC_OPTIONS_REDIALCOUNT_EDIT, NULL, FALSE);
|
|
m_pArgs->piniBothNonFav->WPPI(c_pszCmSection, c_pszCmEntryRedialCount, m_pArgs->nMaxRedials);
|
|
|
|
//
|
|
// NOTE: Logging is enabled/disabled immediately when the logging checkbox
|
|
// is clicked. Thus there is no code here to handle the Apply.
|
|
//
|
|
|
|
SetPropSheetResult(PSNRET_NOERROR);
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: COptionPage::ToggleLogging
|
|
//
|
|
// Synopsis: Helper function, responds to logging being enabled/disabled.
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: BOOL - Is logging now enabled or disabled?
|
|
//
|
|
// History: SumitC Created 11/07/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL COptionPage::ToggleLogging()
|
|
{
|
|
//
|
|
// save the Logging settings
|
|
//
|
|
|
|
BOOL fEnableLog = IsDlgButtonChecked(m_hWnd, IDC_OPTIONS_LOGGING);
|
|
|
|
m_pArgs->piniBothNonFav->WPPB(c_pszCmSection, c_pszCmEntryEnableLogging, fEnableLog);
|
|
|
|
if ((!!fEnableLog != !!m_fEnableLog))
|
|
{
|
|
// if the value has changed
|
|
if (fEnableLog)
|
|
{
|
|
DWORD dwMaxSize = m_pArgs->piniService->GPPI(c_pszCmSectionLogging, c_pszCmEntryMaxLogFileSize, c_dwMaxFileSize);
|
|
LPTSTR pszFileDir = m_pArgs->piniService->GPPS(c_pszCmSectionLogging, c_pszCmEntryLogFileDirectory, c_szLogFileDirectory);
|
|
|
|
m_pArgs->Log.SetParams(TRUE, dwMaxSize, pszFileDir); // TRUE == fEnabled
|
|
|
|
CmFree(pszFileDir);
|
|
|
|
m_pArgs->Log.Start(TRUE); // TRUE => write a banner as well
|
|
m_pArgs->Log.Log(LOGGING_ENABLED_EVENT);
|
|
}
|
|
else
|
|
{
|
|
m_pArgs->Log.Log(LOGGING_DISABLED_EVENT);
|
|
m_pArgs->Log.Stop();
|
|
}
|
|
|
|
m_fEnableLog = fEnableLog;
|
|
}
|
|
|
|
return m_fEnableLog;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CAboutPage::CAboutPage
|
|
//
|
|
// Synopsis: Constructor
|
|
//
|
|
// Arguments: UINT nIDTemplate - Dialog resource ID
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
CAboutPage::CAboutPage(ArgsStruct* pArgs, UINT nIDTemplate)
|
|
: CPropertiesPage(nIDTemplate)
|
|
{
|
|
MYDBGASSERT(pArgs);
|
|
m_pArgs = pArgs;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CAboutPage::OnInitDialog()
|
|
//
|
|
// Synopsis: Init the About property sheet.
|
|
//
|
|
// Arguments: m_hWnd [dlg window handle]
|
|
//
|
|
// Returns: NONE
|
|
//
|
|
// History: henryt Created 4/30/97
|
|
// byao Modified 5/12/97 - disable all controls in
|
|
// 'Dialing with connectoid' mode
|
|
//----------------------------------------------------------------------------
|
|
BOOL CAboutPage::OnInitDialog()
|
|
{
|
|
UpdateFont(m_hWnd);
|
|
|
|
LPTSTR pszTmp;
|
|
LPTSTR pszExt;
|
|
|
|
//
|
|
// Set the warning text. We can't put it the dialog template because it's
|
|
// longer than 256 chars.
|
|
//
|
|
|
|
if (!(pszTmp = CmLoadString(g_hInst, IDMSG_ABOUT_WARNING_PART1)))
|
|
{
|
|
pszTmp = CmStrCpyAlloc(NULL);
|
|
}
|
|
|
|
if (!(pszExt = CmLoadString(g_hInst, IDMSG_ABOUT_WARNING_PART2)))
|
|
{
|
|
pszExt = CmStrCpyAlloc(NULL);
|
|
}
|
|
|
|
pszTmp = CmStrCatAlloc(&pszTmp, pszExt);
|
|
|
|
SetDlgItemTextU(m_hWnd, IDC_ABOUT_WARNING, pszTmp);
|
|
CmFree(pszTmp);
|
|
CmFree(pszExt);
|
|
|
|
//#150147
|
|
|
|
LPTSTR pszVersion = (LPTSTR)CmMalloc(sizeof(TCHAR)*(lstrlenA(VER_PRODUCTVERSION_STR) + 1));
|
|
|
|
if (pszVersion)
|
|
{
|
|
wsprintfU(pszVersion, TEXT("%S"), VER_PRODUCTVERSION_STR);
|
|
|
|
if (!(pszTmp = CmFmtMsg(g_hInst, IDMSG_ABOUT_BUILDVERSION, pszVersion)))
|
|
{
|
|
pszTmp = CmStrCpyAlloc(pszVersion);
|
|
}
|
|
|
|
CmFree(pszVersion);
|
|
|
|
if (pszTmp)
|
|
{
|
|
SetDlgItemTextU(m_hWnd, IDC_ABOUT_VERSION, pszTmp);
|
|
CmFree(pszTmp);
|
|
}
|
|
}
|
|
|
|
return (TRUE);
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CAboutPage::OnOtherMessage
|
|
//
|
|
// Synopsis: Callup opun message other than WM_INITDIALOG and WM_COMMAND
|
|
//
|
|
// Arguments: UINT - Message Id
|
|
// WPARAM - wParam of the message
|
|
// LPARAM - lParam of the message
|
|
//
|
|
// Returns: DWORD - return value of the message
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CAboutPage::OnOtherMessage(UINT uMsg, WPARAM wParam, LPARAM )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CAboutPage::OnSetActive()
|
|
//
|
|
// Synopsis: Creates DI bitmap, etc. for about tab bitmap
|
|
//
|
|
// Arguments: None
|
|
//
|
|
//
|
|
// Returns: NONE
|
|
//
|
|
// History: nickball Created 7/14/97
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
BOOL CAboutPage::OnSetActive()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CAboutPage::OnKillActive
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_NOTIFY with PSN_KILLACTIVE
|
|
// Notifies a page that it is about to lose activation either because
|
|
// another page is being activated or the user has clicked the OK button.
|
|
// Arguments: None
|
|
//
|
|
// Returns: BOOL - return value of the message
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL CAboutPage::OnKillActive()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CAboutPage::OnApply
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_NOTIFY with PSN_APPLY
|
|
// Indicates that the user clicked the OK or Apply Now button
|
|
// and wants all changes to take effect.
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: NONE
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
void CAboutPage::OnApply()
|
|
{
|
|
SetPropSheetResult(PSNRET_NOERROR);
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CAboutPage::OnReset
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_NOTIFY with PSN_RESET
|
|
// Notifies a page that the user has clicked the Cancel button and
|
|
// the property sheet is about to be destroyed.
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: NONE
|
|
//
|
|
// History: fengsun Created Header 2/26/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
void CAboutPage::OnReset()
|
|
{
|
|
//nothing
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CChangePasswordDlg::OnInitDialog
|
|
//
|
|
// Synopsis: Virtual function. Call upon WM_INITDIALOG message
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: BOOL - Return value of WM_INITDIALOG
|
|
//
|
|
// History: v-vijayb Created Header 7/3/99
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL CChangePasswordDlg::OnInitDialog()
|
|
{
|
|
DWORD cMaxPassword;
|
|
|
|
SetForegroundWindow(m_hWnd);
|
|
|
|
m_pArgs->hWndChangePassword = m_hWnd;
|
|
UpdateFont(m_hWnd);
|
|
|
|
int iMaxPasswordFromCMS = m_pArgs->piniService->GPPI(c_pszCmSection, c_pszCmEntryMaxPassword, PWLEN);
|
|
|
|
if (InBetween(0, iMaxPasswordFromCMS, PWLEN))
|
|
{
|
|
cMaxPassword = iMaxPasswordFromCMS;
|
|
}
|
|
else
|
|
{
|
|
cMaxPassword = PWLEN;
|
|
}
|
|
|
|
SendDlgItemMessageU(m_hWnd, IDC_NEW_PASSWORD, EM_SETLIMITTEXT, cMaxPassword, 0);
|
|
SendDlgItemMessageU(m_hWnd, IDC_CONFIRMNEWPASSWORD, EM_SETLIMITTEXT, cMaxPassword, 0);
|
|
SetFocus(GetDlgItem(m_hWnd, IDC_NEW_PASSWORD));
|
|
|
|
//
|
|
// Must return FALSE when setting focus
|
|
//
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CChangePasswordDlg::OnOK
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_COMMAND with IDOK
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: v-vijayb Created Header 7/3/99
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
void CChangePasswordDlg::OnOK()
|
|
{
|
|
TCHAR szNewConfirmPassword[PWLEN+1];
|
|
TCHAR szNewPassword[PWLEN+1];
|
|
|
|
GetDlgItemText(m_hWnd, IDC_NEW_PASSWORD, szNewPassword, PWLEN+1);
|
|
GetDlgItemText(m_hWnd, IDC_CONFIRMNEWPASSWORD, szNewConfirmPassword, PWLEN+1);
|
|
|
|
//
|
|
// Both must match exactly
|
|
//
|
|
|
|
if (lstrcmpU(szNewPassword, szNewConfirmPassword) == 0)
|
|
{
|
|
//
|
|
// Process password according to our handling rules
|
|
//
|
|
|
|
ApplyPasswordHandlingToBuffer(m_pArgs, szNewPassword);
|
|
|
|
//
|
|
// Now we need to figure which credentials these are.
|
|
// This used to work because we were directly using RASDIALPARAMS,
|
|
// but by removing it, we need to figure out the type of password
|
|
// we need to save.
|
|
//
|
|
BOOL fUsingInetCredentials = (!m_pArgs->fUseSameUserName &&
|
|
!IsDialingTunnel(m_pArgs) &&
|
|
UseTunneling(m_pArgs, m_pArgs->nDialIdx));
|
|
|
|
if (fUsingInetCredentials)
|
|
{
|
|
(VOID)m_pArgs->SecureInetPW.SetPassword(szNewPassword);
|
|
m_pArgs->fChangedInetPassword = TRUE;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Securely store password in memory.
|
|
//
|
|
|
|
(VOID)m_pArgs->SecurePW.SetPassword(szNewPassword);
|
|
m_pArgs->fChangedPassword = TRUE;
|
|
}
|
|
|
|
m_pArgs->hWndChangePassword = NULL;
|
|
|
|
m_pArgs->Log.Log(PASSWORD_EXPIRED_EVENT, TEXT("ok"));
|
|
|
|
EndDialog(m_hWnd, TRUE);
|
|
}
|
|
else
|
|
{
|
|
HWND hWnd = GetDlgItem(m_hWnd, IDC_NEW_PASSWORD);
|
|
MYDBGASSERT(hWnd);
|
|
|
|
if (hWnd)
|
|
{
|
|
TCHAR *pszTmp;
|
|
|
|
|
|
pszTmp = CmFmtMsg(g_hInst, IDMSG_NOMATCHPASSWORD);
|
|
MYDBGASSERT(pszTmp);
|
|
if (pszTmp)
|
|
{
|
|
MessageBoxEx(m_hWnd, pszTmp, m_pArgs->szServiceName, MB_OK | MB_ICONERROR, LANG_USER_DEFAULT);
|
|
CmFree(pszTmp);
|
|
}
|
|
|
|
SetFocus(hWnd);
|
|
SendMessageU(hWnd, EM_SETSEL, 0, MAKELONG(0, -1));
|
|
}
|
|
}
|
|
|
|
CmWipePassword(szNewConfirmPassword);
|
|
CmWipePassword(szNewPassword);
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CChangePasswordDlg::OnCancel
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_COMMAND with IDCANCEL
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: v-vijayb Created Header 7/16/99
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
void CChangePasswordDlg::OnCancel()
|
|
{
|
|
m_pArgs->fChangedPassword = FALSE;
|
|
m_pArgs->fChangedInetPassword = FALSE;
|
|
m_pArgs->hWndChangePassword = NULL;
|
|
m_pArgs->Log.Log(PASSWORD_EXPIRED_EVENT, TEXT("cancel"));
|
|
EndDialog(m_hWnd, FALSE);
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CChangePasswordDlg::OnOtherCommand
|
|
//
|
|
// Synopsis: Virtual function. Call upon WM_COMMAND with command other than IDOK
|
|
// and IDCANCEL
|
|
//
|
|
// Arguments: WPARAM wParam - wParam of WM_COMMAND
|
|
// LPARAM -
|
|
//
|
|
// Returns: DWORD -
|
|
//
|
|
// History: v-vijayb Created Header 7/3/99
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CChangePasswordDlg::OnOtherCommand(WPARAM wParam, LPARAM)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CCallbackNumberDlg::OnInitDialog
|
|
//
|
|
// Synopsis: Virtual function. Call upon WM_INITDIALOG message
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: BOOL - Return value of WM_INITDIALOG
|
|
//
|
|
// History: nickball created 03/01/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL CCallbackNumberDlg::OnInitDialog()
|
|
{
|
|
SetForegroundWindow(m_hWnd);
|
|
|
|
//
|
|
// Store window handle globally and setup edit control
|
|
//
|
|
|
|
m_pArgs->hWndCallbackNumber = m_hWnd;
|
|
UpdateFont(m_hWnd);
|
|
|
|
SendDlgItemMessageU(m_hWnd, IDC_CALLBACK_NUM_EDIT, EM_SETLIMITTEXT, RAS_MaxCallbackNumber , 0);
|
|
|
|
//
|
|
// See if we have anything from previous use. If so, add it to the control.
|
|
//
|
|
|
|
SetWindowTextU(GetDlgItem(m_hWnd, IDC_CALLBACK_NUM_EDIT), m_pArgs->pRasDialParams->szCallbackNumber);
|
|
|
|
//
|
|
// Set focus, must return FALSE when doing so.
|
|
//
|
|
|
|
SetFocus(GetDlgItem(m_hWnd, IDC_CALLBACK_NUM_EDIT));
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CCallbackNumberDlg::OnOK
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_COMMAND with IDOK
|
|
// Retrieves the number for callback and stores in dial params.
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: nickball created 03/01/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
void CCallbackNumberDlg::OnOK()
|
|
{
|
|
TCHAR szNumber[RAS_MaxCallbackNumber+1];
|
|
|
|
GetDlgItemText(m_hWnd, IDC_CALLBACK_NUM_EDIT, szNumber, RAS_MaxCallbackNumber);
|
|
|
|
//
|
|
// Although one would expect that the length of the number would be
|
|
// verified, this is not the case with RAS. In the interests of
|
|
// behavioral parity we will allow an empty number field.
|
|
//
|
|
|
|
//
|
|
// We're good to go, fill in Dial Params and ski-dadle.
|
|
//
|
|
|
|
lstrcpyU(m_pArgs->pRasDialParams->szCallbackNumber, szNumber);
|
|
|
|
//
|
|
// Succesful callback, store the number in the .CMP
|
|
//
|
|
|
|
m_pArgs->piniProfile->WPPS(c_pszCmSection, c_pszCmEntryCallbackNumber, m_pArgs->pRasDialParams->szCallbackNumber);
|
|
|
|
m_pArgs->hWndCallbackNumber = NULL;
|
|
|
|
m_pArgs->Log.Log(CALLBACK_NUMBER_EVENT, TEXT("ok"), m_pArgs->pRasDialParams->szCallbackNumber);
|
|
|
|
EndDialog(m_hWnd, TRUE);
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CCallbackNumberDlg::OnCancel
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_COMMAND with IDCANCEL
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: nickball created 03/01/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
void CCallbackNumberDlg::OnCancel()
|
|
{
|
|
m_pArgs->fWaitingForCallback = FALSE;
|
|
m_pArgs->hWndCallbackNumber = NULL;
|
|
m_pArgs->Log.Log(CALLBACK_NUMBER_EVENT, TEXT("cancel"), TEXT("none"));
|
|
EndDialog(m_hWnd, FALSE);
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CCallbackNumberDlg::OnOtherCommand
|
|
//
|
|
// Synopsis: Virtual function. Call upon WM_COMMAND with command other than IDOK
|
|
// and IDCANCEL
|
|
//
|
|
// Arguments: WPARAM wParam - wParam of WM_COMMAND
|
|
// LPARAM -
|
|
//
|
|
// Returns: DWORD -
|
|
//
|
|
// History: nickball created 03/01/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CCallbackNumberDlg::OnOtherCommand(WPARAM wParam, LPARAM)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// No help on OK or Cancel button
|
|
//
|
|
const DWORD CRetryAuthenticationDlg::m_dwHelp[] = {
|
|
IDC_RETRY_REMEMBER, IDH_RETRY_REMEMBER,
|
|
IDC_RETRY_USERNAME_STATIC, IDH_RETRY_USERNAME_STATIC,
|
|
IDC_RETRY_USERNAME, IDH_RETRY_USERNAME,
|
|
IDC_RETRY_PASSWORD_STATIC, IDH_RETRY_PASSWORD_STATIC,
|
|
IDC_RETRY_PASSWORD, IDH_RETRY_PASSWORD,
|
|
IDC_RETRY_DOMAIN_STATIC, IDH_RETRY_DOMAIN_STATIC,
|
|
IDC_RETRY_DOMAIN, IDH_RETRY_DOMAIN,
|
|
IDOK, IDH_RETRY_OK,
|
|
IDCANCEL, IDH_RETRY_CANCEL,
|
|
0,0};
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CRetryAuthenticationDlg::OnInitDialog
|
|
//
|
|
// Synopsis: Virtual function. Call upon WM_INITDIALOG message to intialize
|
|
// the dialog.
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: BOOL - Return value of WM_INITDIALOG
|
|
//
|
|
// History: nickball created 03/01/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL CRetryAuthenticationDlg::OnInitDialog()
|
|
{
|
|
DWORD dwMax = MAX_PATH;
|
|
|
|
m_pArgs->Log.Log(RETRY_AUTH_EVENT);
|
|
|
|
SetForegroundWindow(m_hWnd);
|
|
|
|
//
|
|
// Brand the dialog
|
|
//
|
|
|
|
if (m_pArgs->hSmallIcon)
|
|
{
|
|
SendMessageU(m_hWnd, WM_SETICON, ICON_SMALL, (LPARAM) m_pArgs->hSmallIcon);
|
|
}
|
|
|
|
if (m_pArgs->hBigIcon)
|
|
{
|
|
SendMessageU(m_hWnd, WM_SETICON, ICON_BIG, (LPARAM) m_pArgs->hBigIcon);
|
|
SendMessageU(GetDlgItem(m_hWnd, IDC_INET_ICON), STM_SETIMAGE, IMAGE_ICON, (LPARAM) m_pArgs->hBigIcon);
|
|
}
|
|
|
|
//
|
|
// Store window handle globally and setup edit control
|
|
//
|
|
|
|
m_pArgs->hWndRetryAuthentication = m_hWnd;
|
|
UpdateFont(m_hWnd);
|
|
|
|
//
|
|
// If not Inet dial, then use the service as the title
|
|
//
|
|
|
|
if (!m_fInetCredentials)
|
|
{
|
|
LPTSTR pszTitle = CmStrCpyAlloc(m_pArgs->szServiceName);
|
|
SetWindowTextU(m_hWnd, pszTitle);
|
|
CmFree(pszTitle);
|
|
}
|
|
|
|
//
|
|
// Fill password as appropriate to the template and dial type.
|
|
//
|
|
|
|
HWND hwndPassword = GetDlgItem(m_hWnd, IDC_RETRY_PASSWORD);
|
|
|
|
if (hwndPassword)
|
|
{
|
|
//
|
|
// Limit user entry according to current config.
|
|
//
|
|
int iMaxPasswordFromCMS = m_pArgs->piniService->GPPI(c_pszCmSection, c_pszCmEntryMaxPassword, PWLEN);
|
|
|
|
if (InBetween(0, iMaxPasswordFromCMS, PWLEN))
|
|
{
|
|
dwMax = iMaxPasswordFromCMS;
|
|
}
|
|
else
|
|
{
|
|
dwMax = PWLEN;
|
|
}
|
|
|
|
SendDlgItemMessageU(m_hWnd, IDC_RETRY_PASSWORD, EM_SETLIMITTEXT, dwMax, 0);
|
|
MYDBGASSERT(dwMax <= PWLEN && dwMax > 0);
|
|
|
|
//
|
|
// Do we have any data to display?
|
|
//
|
|
|
|
BOOL fHasPassword = FALSE;
|
|
|
|
if (m_fInetCredentials)
|
|
{
|
|
if (FALSE == m_pArgs->SecureInetPW.IsEmptyString())
|
|
{
|
|
LPTSTR pszClearInetPassword = NULL;
|
|
DWORD cbClearInetPassword = 0;
|
|
BOOL fRetPassword = FALSE;
|
|
|
|
fRetPassword = m_pArgs->SecureInetPW.GetPasswordWithAlloc(&pszClearInetPassword, &cbClearInetPassword);
|
|
|
|
if (fRetPassword && pszClearInetPassword)
|
|
{
|
|
SetDlgItemTextU(m_hWnd, IDC_RETRY_PASSWORD, pszClearInetPassword);
|
|
fHasPassword = TRUE;
|
|
|
|
//
|
|
// Clear and Free the clear-text password
|
|
//
|
|
|
|
m_pArgs->SecureInetPW.ClearAndFree(&pszClearInetPassword, cbClearInetPassword);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (FALSE == m_pArgs->SecurePW.IsEmptyString())
|
|
{
|
|
LPTSTR pszClearPassword = NULL;
|
|
DWORD cbClearPassword = 0;
|
|
BOOL fRetPassword = FALSE;
|
|
|
|
fRetPassword = m_pArgs->SecurePW.GetPasswordWithAlloc(&pszClearPassword, &cbClearPassword);
|
|
|
|
if (fRetPassword && pszClearPassword)
|
|
{
|
|
SetDlgItemTextU(m_hWnd, IDC_RETRY_PASSWORD, pszClearPassword);
|
|
fHasPassword = TRUE;
|
|
|
|
//
|
|
// Clear and Free the clear-text password
|
|
//
|
|
|
|
m_pArgs->SecurePW.ClearAndFree(&pszClearPassword, cbClearPassword);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Decide what to do with "Save Password" check-box
|
|
//
|
|
|
|
HWND hwndSavePassword = GetDlgItem(m_hWnd, IDC_RETRY_REMEMBER);
|
|
|
|
if (hwndSavePassword)
|
|
{
|
|
//
|
|
// We have a save password control, see if we should hide it.
|
|
//
|
|
|
|
if ((m_fInetCredentials && m_pArgs->fHideRememberInetPassword) ||
|
|
(!m_fInetCredentials && m_pArgs->fHideRememberPassword))
|
|
{
|
|
ShowWindow(hwndSavePassword, SW_HIDE);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// We're not hiding, so adjust its state as needed. If no data
|
|
// then disable the control. Otherwise check according to current
|
|
// user setting.
|
|
//
|
|
|
|
if (!fHasPassword)
|
|
{
|
|
EnableWindow(GetDlgItem(m_hWnd, IDC_RETRY_REMEMBER), FALSE);
|
|
}
|
|
else
|
|
{
|
|
if ((m_fInetCredentials && m_pArgs->fRememberInetPassword) ||
|
|
(!m_fInetCredentials && m_pArgs->fRememberMainPassword))
|
|
{
|
|
SendMessageU(hwndSavePassword, BM_SETCHECK, BST_CHECKED, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Fill username as appropriate to the template and dial type.
|
|
//
|
|
|
|
HWND hwndUsername = GetDlgItem(m_hWnd, IDC_RETRY_USERNAME);
|
|
|
|
if (hwndUsername)
|
|
{
|
|
int iMaxUserNameFromCMS = m_pArgs->piniService->GPPI(c_pszCmSection, c_pszCmEntryMaxUserName, UNLEN);
|
|
|
|
if (InBetween(0, iMaxUserNameFromCMS, UNLEN))
|
|
{
|
|
dwMax = iMaxUserNameFromCMS;
|
|
}
|
|
else
|
|
{
|
|
dwMax = UNLEN;
|
|
}
|
|
|
|
SendDlgItemMessageU(m_hWnd, IDC_RETRY_USERNAME, EM_SETLIMITTEXT, dwMax, 0);
|
|
MYDBGASSERT(dwMax <= UNLEN);
|
|
|
|
if (m_fInetCredentials)
|
|
{
|
|
if (lstrlenU(m_pArgs->szInetUserName))
|
|
{
|
|
SetDlgItemTextU(m_hWnd, IDC_RETRY_USERNAME, m_pArgs->szInetUserName);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (lstrlenU(m_pArgs->szUserName))
|
|
{
|
|
SetDlgItemTextU(m_hWnd, IDC_RETRY_USERNAME, m_pArgs->szUserName);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Fill domain as appropriate to the template.
|
|
//
|
|
|
|
HWND hwndDomain = GetDlgItem(m_hWnd, IDC_RETRY_DOMAIN);
|
|
|
|
if (hwndDomain)
|
|
{
|
|
int iMaxDomainFromCMS = m_pArgs->piniService->GPPI(c_pszCmSection, c_pszCmEntryMaxDomain, DNLEN);
|
|
|
|
if (InBetween(0, iMaxDomainFromCMS, DNLEN))
|
|
{
|
|
dwMax = iMaxDomainFromCMS;
|
|
}
|
|
else
|
|
{
|
|
dwMax = DNLEN;
|
|
}
|
|
|
|
SendDlgItemMessageU(m_hWnd, IDC_RETRY_DOMAIN, EM_SETLIMITTEXT, dwMax, 0);
|
|
MYDBGASSERT(dwMax <= DNLEN);
|
|
|
|
if (lstrlenU(m_pArgs->szDomain))
|
|
{
|
|
SetDlgItemTextU(m_hWnd, IDC_RETRY_DOMAIN, m_pArgs->szDomain);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Drop focus in the first available control
|
|
//
|
|
|
|
HWND hwndFocus = hwndUsername;
|
|
|
|
if (!hwndFocus)
|
|
{
|
|
hwndFocus = hwndPassword ? hwndPassword : hwndDomain;
|
|
}
|
|
|
|
SetFocus(hwndFocus);
|
|
|
|
//
|
|
// Must return FALSE when setting focus
|
|
//
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CRetryAuthenticationDlg::OnOK
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_COMMAND with IDOK
|
|
// Retrieves the cerdentials and stores them in dial params.
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: nickball created 03/01/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
void CRetryAuthenticationDlg::OnOK()
|
|
{
|
|
LPTSTR pszBuf = NULL;
|
|
BOOL fSave = FALSE;
|
|
|
|
//
|
|
// Check Save Password (if any) to see how we should proceed
|
|
//
|
|
|
|
BOOL fSwitchToUserCredentials = FALSE;
|
|
BOOL fNeedToResaveUserName = FALSE;
|
|
BOOL fNeedToResaveDomain = FALSE;
|
|
BOOL fChecked = FALSE;
|
|
|
|
HWND hwndMainDlgSavePW = GetDlgItem(m_pArgs->hwndMainDlg, IDC_MAIN_NOPASSWORD_CHECKBOX);
|
|
HWND hwndMainDlgDialAutomatically = GetDlgItem(m_pArgs->hwndMainDlg, IDC_MAIN_NOPROMPT_CHECKBOX);
|
|
BOOL fMainDlgSavePWEnabled = FALSE;
|
|
BOOL fMainDlgDialAutoEnabled = FALSE;
|
|
|
|
//
|
|
// In order not to trigger change notification when updating Main dialog controls.
|
|
// This is set back to FALSE at the bottom of the funtion.
|
|
//
|
|
m_pArgs->fIgnoreChangeNotification = TRUE;
|
|
|
|
|
|
//
|
|
// Gets the inital state of the checkboxes
|
|
//
|
|
if (hwndMainDlgSavePW)
|
|
{
|
|
fMainDlgSavePWEnabled = IsWindowEnabled(hwndMainDlgSavePW);
|
|
}
|
|
|
|
if (hwndMainDlgDialAutomatically)
|
|
{
|
|
fMainDlgDialAutoEnabled = IsWindowEnabled(hwndMainDlgDialAutomatically);
|
|
}
|
|
|
|
if (GetDlgItem(m_hWnd, IDC_RETRY_REMEMBER))
|
|
{
|
|
fChecked = IsDlgButtonChecked(m_hWnd, IDC_RETRY_REMEMBER);
|
|
|
|
|
|
if (m_fInetCredentials)
|
|
{
|
|
if (m_pArgs->fRememberInetPassword != fChecked)
|
|
{
|
|
|
|
if (fChecked && (FALSE == m_pArgs->fRememberInetPassword))
|
|
{
|
|
//
|
|
// This time around the user wants to save credentials,
|
|
// but before (in main dialog) he didn't want to save anything.
|
|
// Thus we should resave username and domain
|
|
//
|
|
fNeedToResaveUserName = TRUE;
|
|
}
|
|
|
|
m_pArgs->fRememberInetPassword = fChecked;
|
|
|
|
//
|
|
// Even at winlogon the user should be able to save the RememberInternet Password
|
|
// checkbox. Plus we don't want to be saving the password for ICS, although
|
|
// this case should not happen.
|
|
//
|
|
if (CM_LOGON_TYPE_ICS != m_pArgs->dwWinLogonType)
|
|
{
|
|
SaveUserInfo(m_pArgs,
|
|
UD_ID_REMEMBER_INET_PASSWORD,
|
|
(PVOID)&m_pArgs->fRememberInetPassword);
|
|
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m_pArgs->fRememberMainPassword != fChecked)
|
|
{
|
|
if (fChecked && (FALSE == m_pArgs->fRememberMainPassword))
|
|
{
|
|
//
|
|
// This time around the user wants to save credentials,
|
|
// but before (in main dialog) he didn't want to save anything.
|
|
// Thus we should resave username and domain
|
|
//
|
|
fNeedToResaveUserName = TRUE;
|
|
fNeedToResaveDomain = TRUE;
|
|
}
|
|
|
|
m_pArgs->fRememberMainPassword = fChecked;
|
|
|
|
if (CM_LOGON_TYPE_USER == m_pArgs->dwWinLogonType)
|
|
{
|
|
SaveUserInfo(m_pArgs,
|
|
UD_ID_REMEMBER_PWD,
|
|
(PVOID)&m_pArgs->fRememberMainPassword);
|
|
}
|
|
|
|
//
|
|
// There has been a change to main creds, update main display
|
|
//
|
|
CheckDlgButton(m_pArgs->hwndMainDlg,
|
|
IDC_MAIN_NOPASSWORD_CHECKBOX,
|
|
m_pArgs->fRememberMainPassword);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// If the password field is enabled & the save pw checkbox is unchecked then delete creds.
|
|
// But not for ICS case.
|
|
//
|
|
HWND hwndPassword = GetDlgItem(m_hWnd, IDC_RETRY_PASSWORD);
|
|
|
|
if (hwndPassword && OS_NT51 && (FALSE == fChecked) && (CM_LOGON_TYPE_ICS != m_pArgs->dwWinLogonType))
|
|
{
|
|
if (CM_CREDS_GLOBAL == m_pArgs->dwCurrentCredentialType)
|
|
{
|
|
//
|
|
// Since the user has unchecked the 'Save Password' flag and the current credential type is global,
|
|
// we are deleting globals, but we need to save the userinfo into the USER (local) credential store
|
|
// in order for CM to correctly pick up the username and password on next launch.
|
|
//
|
|
fSwitchToUserCredentials = TRUE;
|
|
}
|
|
|
|
if (m_fInetCredentials)
|
|
{
|
|
//
|
|
// Unsaving Internet credentials
|
|
// Even if we are using the same username, we shouldn't delete main credentials
|
|
// on this dialog, since we are re-authing for Internet credentials
|
|
//
|
|
if (CM_CREDS_GLOBAL == m_pArgs->dwCurrentCredentialType)
|
|
{
|
|
//
|
|
// Unsaving Internet Global
|
|
//
|
|
|
|
//
|
|
// Local Inet shouldn't exist in this case, so we shouldn't delete the Identity,
|
|
// but for globals, we don't support just deleting password. This is from the RAS
|
|
// code base and the delete function actually enforces this.
|
|
//
|
|
if (CM_EXIST_CREDS_INET_GLOBAL & m_pArgs->dwExistingCredentials)
|
|
{
|
|
DeleteSavedCredentials(m_pArgs, CM_CREDS_TYPE_INET, CM_DELETE_SAVED_CREDS_DELETE_GLOBALS, CM_DELETE_SAVED_CREDS_DELETE_IDENTITY);
|
|
m_pArgs->dwExistingCredentials &= ~CM_EXIST_CREDS_INET_GLOBAL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Unsaving Internet local (user)
|
|
// Even if we are using the same username, we shouldn't delete main credentials
|
|
// on this dialog, since we are just re-authing for Internet password
|
|
//
|
|
if (CM_EXIST_CREDS_INET_USER & m_pArgs->dwExistingCredentials)
|
|
{
|
|
//
|
|
// Internet user credentials exist, so now delete the identity based on if the
|
|
// global inet creds exist
|
|
//
|
|
if (CM_EXIST_CREDS_INET_GLOBAL & m_pArgs->dwExistingCredentials)
|
|
{
|
|
DeleteSavedCredentials(m_pArgs, CM_CREDS_TYPE_INET, CM_DELETE_SAVED_CREDS_KEEP_GLOBALS, CM_DELETE_SAVED_CREDS_DELETE_IDENTITY);
|
|
}
|
|
else
|
|
{
|
|
DeleteSavedCredentials(m_pArgs, CM_CREDS_TYPE_INET, CM_DELETE_SAVED_CREDS_KEEP_GLOBALS, CM_DELETE_SAVED_CREDS_KEEP_IDENTITY);
|
|
}
|
|
|
|
m_pArgs->dwExistingCredentials &= ~CM_EXIST_CREDS_INET_USER;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// ReAuth for Main credentials & Delete main set of credentials
|
|
// Most of this code is taken from a section in TryToDeleteAndSaveCredentials
|
|
// since most of the logic remains the same if the user unchecks the 'Save Password'
|
|
// option on the main dialog, except that here we don't prompt the user.
|
|
// If the user got promted it happened on the main dialog and the creds were either
|
|
// kept or deleted according to his selection. Thus we don't need to ask here.
|
|
//
|
|
|
|
//
|
|
// Check which option button is currently selected
|
|
//
|
|
if (CM_CREDS_GLOBAL == m_pArgs->dwCurrentCredentialType)
|
|
{
|
|
//
|
|
// Since global is selected then we actually want to delete both sets of credentials
|
|
//
|
|
|
|
if (CM_EXIST_CREDS_MAIN_GLOBAL & m_pArgs->dwExistingCredentials)
|
|
{
|
|
//
|
|
// Delete the global credentials.
|
|
// Note from RAS codebase: Note that we have to delete the global identity
|
|
// as well because we do not support deleting
|
|
// just the global password. This is so that
|
|
// RasSetCredentials can emulate RasSetDialParams.
|
|
//
|
|
|
|
DeleteSavedCredentials(m_pArgs, CM_CREDS_TYPE_MAIN, CM_DELETE_SAVED_CREDS_DELETE_GLOBALS, CM_DELETE_SAVED_CREDS_DELETE_IDENTITY);
|
|
m_pArgs->dwExistingCredentials &= ~CM_EXIST_CREDS_MAIN_GLOBAL;
|
|
}
|
|
|
|
if (CM_EXIST_CREDS_INET_GLOBAL & m_pArgs->dwExistingCredentials)
|
|
{
|
|
if (m_pArgs->fUseSameUserName || (FALSE == m_pArgs->fRememberInetPassword))
|
|
{
|
|
DeleteSavedCredentials(m_pArgs, CM_CREDS_TYPE_INET, CM_DELETE_SAVED_CREDS_DELETE_GLOBALS, CM_DELETE_SAVED_CREDS_DELETE_IDENTITY);
|
|
m_pArgs->dwExistingCredentials &= ~CM_EXIST_CREDS_INET_GLOBAL;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Delete the password saved per-user. Keep the user name
|
|
// and domain saved, however unless global credentials exist.
|
|
// Whenever global credential exist, and we are deleting user credentials
|
|
// we must always delete all of the information (identity + password) associated
|
|
// with the user credentials.
|
|
//
|
|
|
|
if (CM_EXIST_CREDS_MAIN_USER & m_pArgs->dwExistingCredentials)
|
|
{
|
|
if (CM_EXIST_CREDS_MAIN_GLOBAL & m_pArgs->dwExistingCredentials)
|
|
{
|
|
DeleteSavedCredentials(m_pArgs, CM_CREDS_TYPE_MAIN, CM_DELETE_SAVED_CREDS_KEEP_GLOBALS, CM_DELETE_SAVED_CREDS_DELETE_IDENTITY);
|
|
}
|
|
else
|
|
{
|
|
DeleteSavedCredentials(m_pArgs, CM_CREDS_TYPE_MAIN, CM_DELETE_SAVED_CREDS_KEEP_GLOBALS, CM_DELETE_SAVED_CREDS_KEEP_IDENTITY);
|
|
}
|
|
m_pArgs->dwExistingCredentials &= ~CM_EXIST_CREDS_MAIN_USER;
|
|
}
|
|
|
|
if (CM_EXIST_CREDS_INET_USER & m_pArgs->dwExistingCredentials)
|
|
{
|
|
if (m_pArgs->fUseSameUserName || (FALSE == m_pArgs->fRememberInetPassword))
|
|
{
|
|
if (CM_EXIST_CREDS_INET_GLOBAL & m_pArgs->dwExistingCredentials)
|
|
{
|
|
DeleteSavedCredentials(m_pArgs, CM_CREDS_TYPE_INET, CM_DELETE_SAVED_CREDS_KEEP_GLOBALS, CM_DELETE_SAVED_CREDS_DELETE_IDENTITY);
|
|
}
|
|
else
|
|
{
|
|
DeleteSavedCredentials(m_pArgs, CM_CREDS_TYPE_INET, CM_DELETE_SAVED_CREDS_KEEP_GLOBALS, CM_DELETE_SAVED_CREDS_KEEP_IDENTITY);
|
|
}
|
|
m_pArgs->dwExistingCredentials &= ~CM_EXIST_CREDS_INET_USER;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fSwitchToUserCredentials)
|
|
{
|
|
//
|
|
// Since this flag was set when we deleted global credentials, we need
|
|
// to save the userinfo into the USER (local) credential store
|
|
// in order for CM to correctly pick up the username and password on next launch.
|
|
// We cannnot store userinfo w/o a password in the global store, because the RAS API
|
|
// doesn't support that. (From rasdlg code).
|
|
//
|
|
|
|
m_pArgs->dwCurrentCredentialType = CM_CREDS_USER;
|
|
}
|
|
|
|
|
|
if (hwndPassword)
|
|
{
|
|
pszBuf = CmGetWindowTextAlloc(m_hWnd, IDC_RETRY_PASSWORD);
|
|
|
|
if (pszBuf)
|
|
{
|
|
//
|
|
// Process password according to our handling and encoding rules.
|
|
//
|
|
|
|
ApplyPasswordHandlingToBuffer(m_pArgs, pszBuf);
|
|
|
|
//
|
|
// Password is prepped, update our memory based storage.
|
|
//
|
|
|
|
if (m_fInetCredentials)
|
|
{
|
|
(VOID)m_pArgs->SecureInetPW.SetPassword(pszBuf);
|
|
}
|
|
else
|
|
{
|
|
(VOID)m_pArgs->SecurePW.SetPassword(pszBuf);
|
|
}
|
|
|
|
//
|
|
// Make sure we set the persistent user info store correctly.
|
|
// Blank if save password is not checked or if we aren't using ras
|
|
// cred store. On Win2K+ the creds we marked and deleted so passwords
|
|
// doesn't need to be set to blank.
|
|
//
|
|
|
|
if (m_fInetCredentials)
|
|
{
|
|
if (OS_NT5 && m_pArgs->bUseRasCredStore)
|
|
{
|
|
//
|
|
// For Win2K+ we have the ras store. If the checkbox is checked
|
|
// and a user is logged in then we want to save it.
|
|
// To fix a bug and stay consistent, at winlogon the user
|
|
// is allowed to save the Internet Password. We don't want to
|
|
// save the password for ICS although this case should not happen.
|
|
//
|
|
if (fChecked && (CM_LOGON_TYPE_ICS != m_pArgs->dwWinLogonType))
|
|
{
|
|
SaveUserInfo(m_pArgs,
|
|
UD_ID_INET_PASSWORD,
|
|
(PVOID)pszBuf);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// We don't have to ras cred store so we either save the password
|
|
// or set it to an empty string since deleting marked credentials
|
|
// doesn't do anything on no Win2K+ platforms
|
|
//
|
|
SaveUserInfo(m_pArgs,
|
|
UD_ID_INET_PASSWORD,
|
|
(PVOID) (fChecked ? pszBuf : TEXT("")));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (OS_NT5 && m_pArgs->bUseRasCredStore)
|
|
{
|
|
//
|
|
// For Win2K+ we have the ras store. If the checkbox is checked
|
|
// and a user is logged in then we want to save it.
|
|
//
|
|
if (fChecked && CM_LOGON_TYPE_USER == m_pArgs->dwWinLogonType)
|
|
{
|
|
SaveUserInfo(m_pArgs,
|
|
UD_ID_PASSWORD,
|
|
(PVOID)pszBuf);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// We don't have to ras cred store so we either save the password
|
|
// or set it to an empty string since deleting marked credentials
|
|
// doesn't do anything on no Win2K+ platforms
|
|
//
|
|
SaveUserInfo(m_pArgs,
|
|
UD_ID_PASSWORD,
|
|
(PVOID) (fChecked ? pszBuf : TEXT("")));
|
|
}
|
|
//
|
|
// If there's been a change to main creds, update main display.
|
|
//
|
|
|
|
if (SendMessageU(hwndPassword, EM_GETMODIFY, 0L, 0L))
|
|
{
|
|
SetDlgItemTextU(m_pArgs->hwndMainDlg, IDC_MAIN_PASSWORD_EDIT, pszBuf);
|
|
}
|
|
}
|
|
|
|
CmWipePassword(pszBuf); // Clear before release
|
|
CmFree(pszBuf);
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Retrieve Domain and copy to CM data store and RasDialParams. We process
|
|
// the domain first because the construction of the username that we hand
|
|
// to RAS depends on it.
|
|
//
|
|
// Note: RAS updates its store whenever the users selects OK. We will too.
|
|
//
|
|
|
|
HWND hwndDomain = GetDlgItem(m_hWnd, IDC_RETRY_DOMAIN);
|
|
|
|
//
|
|
// If the checkbox is false, the creds were
|
|
// deleted above so we now need to re-save the domain.
|
|
//
|
|
if ((hwndDomain && SendMessageU(hwndDomain, EM_GETMODIFY, 0L, 0L)) ||
|
|
(hwndDomain && FALSE == fChecked) ||
|
|
(hwndDomain && fNeedToResaveDomain))
|
|
{
|
|
pszBuf = CmGetWindowTextAlloc(m_hWnd, IDC_RETRY_DOMAIN);
|
|
|
|
if (pszBuf)
|
|
{
|
|
lstrcpyU(m_pArgs->szDomain, pszBuf);
|
|
lstrcpyU(m_pArgs->pRasDialParams->szDomain, pszBuf);
|
|
|
|
if (CM_LOGON_TYPE_ICS != m_pArgs->dwWinLogonType)
|
|
{
|
|
SaveUserInfo(m_pArgs, UD_ID_DOMAIN, (PVOID)pszBuf);
|
|
}
|
|
|
|
//
|
|
// There has been a change to main creds, update main display
|
|
//
|
|
|
|
SetDlgItemTextU(m_pArgs->hwndMainDlg, IDC_MAIN_DOMAIN_EDIT, pszBuf);
|
|
|
|
CmFree(pszBuf);
|
|
}
|
|
}
|
|
|
|
if (NULL == hwndDomain && FALSE == m_fInetCredentials)
|
|
{
|
|
//
|
|
// The domain field is hidden, but we still need to save the domain info from the
|
|
// pArgs structure in order for us to pre-populate later if it's not internet creds.
|
|
//
|
|
if (CM_LOGON_TYPE_ICS != m_pArgs->dwWinLogonType)
|
|
{
|
|
SaveUserInfo(m_pArgs, UD_ID_DOMAIN, (PVOID)m_pArgs->szDomain);
|
|
}
|
|
}
|
|
//
|
|
// Retrieve UserName and copy to CM data store and the RasDialParams struct
|
|
//
|
|
HWND hwndUsername = GetDlgItem(m_hWnd, IDC_RETRY_USERNAME);
|
|
|
|
//
|
|
// If the checkbox is false, the creds were
|
|
// deleted above so we now need to re-save the username.
|
|
//
|
|
if ((hwndUsername && SendMessageU(hwndUsername, EM_GETMODIFY, 0L, 0L)) ||
|
|
(hwndUsername && FALSE == fChecked) ||
|
|
(hwndUsername && fNeedToResaveUserName))
|
|
{
|
|
pszBuf = CmGetWindowTextAlloc(m_hWnd, IDC_RETRY_USERNAME);
|
|
|
|
if (pszBuf)
|
|
{
|
|
if (m_fInetCredentials)
|
|
{
|
|
lstrcpyU(m_pArgs->szInetUserName, pszBuf);
|
|
SaveUserInfo(m_pArgs, UD_ID_INET_USERNAME, (PVOID)pszBuf);
|
|
}
|
|
else
|
|
{
|
|
lstrcpyU(m_pArgs->szUserName, pszBuf);
|
|
if (CM_LOGON_TYPE_ICS != m_pArgs->dwWinLogonType)
|
|
{
|
|
SaveUserInfo(m_pArgs, UD_ID_USERNAME, (PVOID)pszBuf);
|
|
}
|
|
|
|
//
|
|
// There has been a change to main creds, update main display
|
|
//
|
|
|
|
SetDlgItemTextU(m_pArgs->hwndMainDlg, IDC_MAIN_USERNAME_EDIT, pszBuf);
|
|
}
|
|
|
|
//
|
|
// We'll need the service file for the current number. If we're actively
|
|
// tunneling, make sure that we get the top-level service files, so we
|
|
// don't pick up any settings from a referenced dial-up service.
|
|
//
|
|
|
|
CIni *piniService = NULL;
|
|
BOOL bNeedToFree = FALSE;
|
|
|
|
if (IsDialingTunnel(m_pArgs))
|
|
{
|
|
piniService = m_pArgs->piniService;
|
|
}
|
|
else
|
|
{
|
|
piniService = GetAppropriateIniService(m_pArgs, m_pArgs->nDialIdx);
|
|
bNeedToFree = TRUE;
|
|
}
|
|
|
|
MYDBGASSERT(piniService);
|
|
|
|
if (piniService)
|
|
{
|
|
//
|
|
// Apply suffix, prefix, to username as necessary
|
|
//
|
|
|
|
LPTSTR pszTmp = ApplyPrefixSuffixToBufferAlloc(m_pArgs, piniService, pszBuf);
|
|
|
|
if (pszTmp)
|
|
{
|
|
//
|
|
// Apply domain to username as necessary. Note that we only want to do this on modem calls,
|
|
// not tunnels.
|
|
//
|
|
LPTSTR pszUsername = NULL;
|
|
|
|
if (IsDialingTunnel(m_pArgs))
|
|
{
|
|
lstrcpynU(m_pArgs->pRasDialParams->szUserName, pszTmp, sizeof(m_pArgs->pRasDialParams->szUserName)/sizeof(TCHAR));
|
|
}
|
|
else
|
|
{
|
|
pszUsername = ApplyDomainPrependToBufferAlloc(m_pArgs, piniService, pszTmp, (m_pArgs->aDialInfo[m_pArgs->nDialIdx].szDUN));
|
|
|
|
if (pszUsername)
|
|
{
|
|
lstrcpynU(m_pArgs->pRasDialParams->szUserName, pszUsername, sizeof(m_pArgs->pRasDialParams->szUserName)/sizeof(TCHAR));
|
|
}
|
|
}
|
|
|
|
CmFree(pszUsername);
|
|
CmFree(pszTmp);
|
|
}
|
|
|
|
if (bNeedToFree)
|
|
{
|
|
delete piniService;
|
|
}
|
|
}
|
|
}
|
|
|
|
CmFree(pszBuf);
|
|
}
|
|
|
|
if (NULL == hwndUsername)
|
|
{
|
|
//
|
|
// The username field is hidden, but we still need to save it
|
|
// in order for us to pre-populate later.
|
|
//
|
|
if (CM_LOGON_TYPE_ICS != m_pArgs->dwWinLogonType)
|
|
{
|
|
SaveUserInfo(m_pArgs, UD_ID_USERNAME, (PVOID)m_pArgs->szUserName);
|
|
}
|
|
}
|
|
|
|
|
|
m_pArgs->fIgnoreChangeNotification = FALSE;
|
|
|
|
if (fSwitchToUserCredentials)
|
|
{
|
|
//
|
|
// Now that we saved the user name to the local/user cred store
|
|
// we need to switch the credential type back to global in order
|
|
// to maintain the correct state.
|
|
//
|
|
m_pArgs->dwCurrentCredentialType = CM_CREDS_GLOBAL;
|
|
}
|
|
|
|
//
|
|
// Resets the state of the checkboxes
|
|
//
|
|
if (hwndMainDlgSavePW)
|
|
{
|
|
EnableWindow(hwndMainDlgSavePW, fMainDlgSavePWEnabled);
|
|
}
|
|
|
|
if (hwndMainDlgDialAutomatically)
|
|
{
|
|
EnableWindow(hwndMainDlgDialAutomatically, fMainDlgDialAutoEnabled);
|
|
}
|
|
|
|
//
|
|
// Need to refresh to see which creds exist
|
|
//
|
|
BOOL fReturn = RefreshCredentialTypes(m_pArgs, FALSE);
|
|
|
|
//
|
|
// Cleanup state and go.
|
|
//
|
|
|
|
m_pArgs->hWndRetryAuthentication = NULL;
|
|
|
|
EndDialog(m_hWnd, TRUE);
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CRetryAuthenticationDlg::OnCancel
|
|
//
|
|
// Synopsis: Virtual function. Called upon WM_COMMAND with IDCANCEL
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// History: nickball created 03/01/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
void CRetryAuthenticationDlg::OnCancel()
|
|
{
|
|
m_pArgs->hWndRetryAuthentication = NULL;
|
|
EndDialog(m_hWnd, FALSE);
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CRetryAuthenticationDlg::OnOtherCommand
|
|
//
|
|
// Synopsis: Virtual function. Call upon WM_COMMAND with command other than IDOK
|
|
// and IDCANCEL
|
|
//
|
|
// Arguments: WPARAM wParam - wParam of WM_COMMAND
|
|
// LPARAM -
|
|
//
|
|
// Returns: DWORD -
|
|
//
|
|
// History: nickball created 03/01/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CRetryAuthenticationDlg::OnOtherCommand(WPARAM wParam, LPARAM)
|
|
{
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDC_RETRY_PASSWORD:
|
|
{
|
|
if (HIWORD(wParam) == EN_CHANGE)
|
|
{
|
|
//
|
|
// There has been a change to the password edit control, see
|
|
// if there is any text and set the check-box accordingly.
|
|
//
|
|
HWND hwndSavePassword = GetDlgItem(m_hWnd, IDC_RETRY_REMEMBER);
|
|
|
|
MYDBGASSERT(hwndSavePassword);
|
|
|
|
if (hwndSavePassword)
|
|
{
|
|
if (0 == SendDlgItemMessageU(m_hWnd, IDC_RETRY_PASSWORD, WM_GETTEXTLENGTH, 0, 0))
|
|
{
|
|
//
|
|
// No text. If the control is checked, then uncheck it.
|
|
// Also, disable it.
|
|
//
|
|
|
|
if (IsDlgButtonChecked(m_hWnd, IDC_RETRY_REMEMBER))
|
|
{
|
|
SendMessageU(hwndSavePassword, BM_SETCHECK, BST_UNCHECKED, 0);
|
|
}
|
|
|
|
EnableWindow(hwndSavePassword, FALSE);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// There is data, if disabled, then enable appropriately
|
|
//
|
|
|
|
if (FALSE == IsWindowEnabled(GetDlgItem(m_hWnd, IDC_RETRY_REMEMBER)))
|
|
{
|
|
EnableWindow(hwndSavePassword, TRUE);
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CRetryAuthenticationDlg::GetDlgTemplate
|
|
//
|
|
// Synopsis: Encapsulates determining which template is to be used
|
|
// for the Retry dialog. Same model a MainDlg, but the
|
|
// determinants are slightly different as the dialog proc
|
|
// and templates serve double-duty for Inet and VPN.
|
|
//
|
|
// Arguments: ArgsStruct *pArgs - Ptr to global Args struct
|
|
//
|
|
// Returns: UINT - Dlg template ID.
|
|
//
|
|
// History: nickball Created 03/04/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
UINT CRetryAuthenticationDlg::GetDlgTemplate()
|
|
{
|
|
MYDBGASSERT(m_pArgs);
|
|
|
|
//
|
|
// First set the mask according to the .CMS flags for each value.
|
|
//
|
|
|
|
UINT uiMainDlgID = 0;
|
|
DWORD dwTemplateMask = 0;
|
|
|
|
//
|
|
// If Inet and not UseSameUserName, then honor Inet flags for Username
|
|
//
|
|
|
|
if (m_fInetCredentials)
|
|
{
|
|
if (!m_pArgs->fHideInetUsername)
|
|
{
|
|
dwTemplateMask |= CMTM_UID;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Otherwise, the main Username display rules apply.
|
|
//
|
|
|
|
if (!m_pArgs->fHideUserName)
|
|
{
|
|
dwTemplateMask |= CMTM_UID;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If Inet and not UseSameUserName, then honor Inet flags for password
|
|
//
|
|
|
|
if (m_fInetCredentials)
|
|
{
|
|
if (!m_pArgs->fHideInetPassword)
|
|
{
|
|
dwTemplateMask |= CMTM_PWD;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Otherwise, the main password display rules apply.
|
|
//
|
|
|
|
if (!m_pArgs->fHidePassword)
|
|
{
|
|
dwTemplateMask |= CMTM_PWD;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Previously, the OS was the determinant for domain display.
|
|
// Nowadays, we want to display a domain when:
|
|
//
|
|
// a) Its not a straight Inet dial
|
|
//
|
|
// AND
|
|
//
|
|
// b) The domain field is not explicitly hidden
|
|
//
|
|
|
|
|
|
|
|
if (!m_fInetCredentials && !m_pArgs->fHideDomain)
|
|
{
|
|
dwTemplateMask |= CMTM_DMN;
|
|
}
|
|
|
|
switch (dwTemplateMask)
|
|
{
|
|
case CMTM_U_P_D:
|
|
uiMainDlgID = IDD_RETRY_UID_PWD_DMN;
|
|
break;
|
|
|
|
case CMTM_UID:
|
|
uiMainDlgID = IDD_RETRY_UID_ONLY;
|
|
break;
|
|
|
|
case CMTM_PWD:
|
|
uiMainDlgID = IDD_RETRY_PWD_ONLY;
|
|
break;
|
|
|
|
case CMTM_DMN:
|
|
uiMainDlgID = IDD_RETRY_DMN_ONLY;
|
|
break;
|
|
|
|
case CMTM_UID_AND_PWD:
|
|
uiMainDlgID = IDD_RETRY_UID_AND_PWD;
|
|
break;
|
|
|
|
case CMTM_UID_AND_DMN:
|
|
uiMainDlgID = IDD_RETRY_UID_AND_DMN;
|
|
break;
|
|
|
|
case CMTM_PWD_AND_DMN:
|
|
uiMainDlgID = IDD_RETRY_PWD_AND_DMN;
|
|
break;
|
|
|
|
default:
|
|
MYDBGASSERT(FALSE);
|
|
uiMainDlgID = 0;
|
|
break;
|
|
}
|
|
|
|
return uiMainDlgID;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Func: AccessPointInfoChanged
|
|
//
|
|
// Desc: Checks all the controls to determine if any changes have been made
|
|
//
|
|
// Args: NONE
|
|
//
|
|
// Return: BOOL - True if any information has changed
|
|
//
|
|
// Notes:
|
|
//
|
|
// History: t-urama 07/31/2000 Created
|
|
//-----------------------------------------------------------------------------
|
|
|
|
BOOL CGeneralPage::AccessPointInfoChanged()
|
|
{
|
|
if (m_bAPInfoChanged)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
if (0 != SendDlgItemMessageU(m_hWnd, IDC_GENERAL_PRIMARY_EDIT, EM_GETMODIFY, 0, 0))
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
if (0 != SendDlgItemMessageU(m_hWnd, IDC_GENERAL_BACKUP_EDIT, EM_GETMODIFY, 0, 0))
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Func: CGeneralPage::DeleteAccessPoint
|
|
//
|
|
// Desc: Handler for the delete Access Point button
|
|
//
|
|
// Args: NONE
|
|
//
|
|
// Return: NONE
|
|
//
|
|
// Notes:
|
|
//
|
|
// History: t-urama 07/31/2000 Created
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CGeneralPage::DeleteAccessPoint()
|
|
{
|
|
|
|
// Now try to delete the key for the access point from the registry
|
|
|
|
LPTSTR pszRegPath = BuildUserInfoSubKey(m_pArgs->szServiceName, m_pArgs->fAllUser);
|
|
|
|
MYDBGASSERT(pszRegPath);
|
|
|
|
if (NULL == pszRegPath)
|
|
{
|
|
return;
|
|
}
|
|
|
|
CmStrCatAlloc(&pszRegPath, TEXT("\\"));
|
|
CmStrCatAlloc(&pszRegPath, c_pszRegKeyAccessPoints);
|
|
CmStrCatAlloc(&pszRegPath, TEXT("\\"));
|
|
|
|
MYDBGASSERT(pszRegPath);
|
|
|
|
if (NULL == pszRegPath)
|
|
{
|
|
return;
|
|
}
|
|
|
|
CmStrCatAlloc(&pszRegPath, m_pArgs->pszCurrentAccessPoint);
|
|
MYDBGASSERT(pszRegPath);
|
|
|
|
if (NULL == pszRegPath)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (pszRegPath)
|
|
{
|
|
DWORD dwRes;
|
|
HKEY hKeyCm;
|
|
|
|
dwRes = RegOpenKeyExU(HKEY_CURRENT_USER,
|
|
pszRegPath,
|
|
0,
|
|
KEY_ALL_ACCESS,
|
|
&hKeyCm);
|
|
|
|
if (ERROR_SUCCESS == dwRes)
|
|
{
|
|
RegCloseKey(hKeyCm);
|
|
dwRes = RegDeleteKeyU(HKEY_CURRENT_USER, pszRegPath);
|
|
|
|
if (ERROR_SUCCESS != dwRes)
|
|
{
|
|
CMTRACE1(TEXT("Delete AP failed, GLE=%d"), GetLastError());
|
|
}
|
|
else
|
|
{
|
|
CMTRACE1(TEXT("Deleted Access Point - %s"), m_pArgs->pszCurrentAccessPoint);
|
|
}
|
|
|
|
// First delete the Accesspoint from the combo box and load the new settings
|
|
|
|
DWORD dwIdx = (DWORD)SendDlgItemMessageU(m_hWnd, IDC_GENERAL_ACCESSPOINT_COMBO, CB_GETCURSEL, 0, 0);
|
|
|
|
if (CB_ERR != dwIdx)
|
|
{
|
|
if (0 == dwIdx)
|
|
{
|
|
SendDlgItemMessageU(m_hWnd, IDC_GENERAL_ACCESSPOINT_COMBO, CB_SETCURSEL, dwIdx+1, 0);
|
|
}
|
|
else
|
|
{
|
|
SendDlgItemMessageU(m_hWnd, IDC_GENERAL_ACCESSPOINT_COMBO, CB_SETCURSEL, dwIdx-1, 0);
|
|
}
|
|
|
|
if (ChangedAccessPoint(m_pArgs, m_hWnd, IDC_GENERAL_ACCESSPOINT_COMBO))
|
|
{
|
|
UpdateForNewAccessPoint(TRUE);
|
|
}
|
|
|
|
SendDlgItemMessageU(m_hWnd, IDC_GENERAL_ACCESSPOINT_COMBO, CB_DELETESTRING, dwIdx, 0);
|
|
}
|
|
|
|
//
|
|
// If the number of APs becomes 1, then make the AccessPointsEnabled Flag FAlSE
|
|
//
|
|
|
|
DWORD dwCnt = (DWORD)SendDlgItemMessageU(m_hWnd, IDC_GENERAL_ACCESSPOINT_COMBO, CB_GETCOUNT, 0, 0);
|
|
if (dwCnt == 1)
|
|
{
|
|
m_pArgs->fAccessPointsEnabled = FALSE;
|
|
WriteUserInfoToReg(m_pArgs, UD_ID_ACCESSPOINTENABLED, (PVOID) &m_pArgs->fAccessPointsEnabled);
|
|
WriteUserInfoToReg(m_pArgs, UD_ID_CURRENTACCESSPOINT, (PVOID) m_pArgs->pszCurrentAccessPoint);
|
|
}
|
|
|
|
}
|
|
|
|
CmFree(pszRegPath);
|
|
}
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CNewAccessPointDlg::OnInitDialog
|
|
//
|
|
// Synopsis: Virtual function. Call upon WM_INITDIALOG message to intialize
|
|
// the dialog.
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: BOOL - Return value of WM_INITDIALOG
|
|
//
|
|
// History: t-urama created 08/02/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL CNewAccessPointDlg::OnInitDialog()
|
|
{
|
|
|
|
SetForegroundWindow(m_hWnd);
|
|
|
|
//
|
|
// Brand the dialog
|
|
//
|
|
|
|
LPTSTR pszTitle = CmStrCpyAlloc(m_pArgs->szServiceName);
|
|
MYDBGASSERT(pszTitle);
|
|
if (pszTitle)
|
|
{
|
|
SetWindowTextU(m_hWnd, pszTitle);
|
|
}
|
|
|
|
CmFree(pszTitle);
|
|
if (m_pArgs->hSmallIcon)
|
|
{
|
|
SendMessageU(m_hWnd, WM_SETICON, ICON_SMALL, (LPARAM) m_pArgs->hSmallIcon);
|
|
}
|
|
|
|
if (m_pArgs->hBigIcon)
|
|
{
|
|
SendMessageU(m_hWnd, WM_SETICON, ICON_BIG, (LPARAM) m_pArgs->hBigIcon);
|
|
SendMessageU(GetDlgItem(m_hWnd, IDC_INET_ICON), STM_SETIMAGE, IMAGE_ICON, (LPARAM) m_pArgs->hBigIcon);
|
|
}
|
|
|
|
UpdateFont(m_hWnd);
|
|
|
|
EnableWindow(GetDlgItem(m_hWnd, IDOK), FALSE);
|
|
|
|
HWND hwndEdit = GetDlgItem(m_hWnd, IDC_NEWAP_NAME_EDIT);
|
|
|
|
if (hwndEdit)
|
|
{
|
|
//
|
|
// Subclass the edit control
|
|
//
|
|
m_pfnOrgEditWndProc = (WNDPROC)SetWindowLongU(hwndEdit, GWLP_WNDPROC, (LONG_PTR)SubClassEditProc);
|
|
|
|
//
|
|
// Set focus to the edit control
|
|
//
|
|
SetFocus(hwndEdit);
|
|
|
|
//
|
|
// Limit the text length of the control
|
|
//
|
|
SendMessageU(hwndEdit, EM_SETLIMITTEXT, MAX_ACCESSPOINT_LENGTH, 0);
|
|
}
|
|
|
|
//
|
|
// Must return FALSE when setting focus
|
|
//
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CNewAccessPointDlg::SubClassEditProc
|
|
//
|
|
// Synopsis: Subclassed edit proc so that back slash chars can be prevented from
|
|
// being entered into the new access point name edit control.
|
|
//
|
|
// Arguments: standard win32 window proc params
|
|
//
|
|
// Returns: standard win32 window proc return value
|
|
//
|
|
// History: quintinb created 08/22/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
LRESULT CALLBACK CNewAccessPointDlg::SubClassEditProc(HWND hwnd, UINT uMsg,
|
|
WPARAM wParam, LPARAM lParam)
|
|
{
|
|
//
|
|
// If user types a back slash character, Beep and do not accept that character
|
|
//
|
|
|
|
if ((uMsg == WM_CHAR) && (VK_BACK != wParam))
|
|
{
|
|
if (TEXT('\\') == (TCHAR)wParam)
|
|
{
|
|
Beep(2000, 100);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Call the original window procedure for default processing.
|
|
//
|
|
return CallWindowProcU(m_pfnOrgEditWndProc, hwnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CNewAccessPointDlg::OnOK
|
|
//
|
|
// Synopsis: Virtual function. Call when user hits the OK button
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: None
|
|
//
|
|
// History: t-urama created 08/02/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
void CNewAccessPointDlg::OnOK()
|
|
{
|
|
LPTSTR pszNewAPName = CmGetWindowTextAlloc(m_hWnd, IDC_NEWAP_NAME_EDIT);
|
|
MYDBGASSERT(pszNewAPName);
|
|
|
|
if (pszNewAPName && TEXT('\0') != pszNewAPName[0])
|
|
{
|
|
if (m_ppszAPName)
|
|
{
|
|
CmFree(*m_ppszAPName);
|
|
*m_ppszAPName = pszNewAPName;
|
|
}
|
|
EndDialog(m_hWnd, TRUE);
|
|
}
|
|
else
|
|
{
|
|
CmFree(pszNewAPName);
|
|
}
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CNewAccessPointDlg::OnOtherCommand
|
|
//
|
|
// Synopsis: Virtual function. Enables the OK button once the user enters
|
|
// a name for the Access Point
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: None
|
|
//
|
|
// History: t-urama created 08/02/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD CNewAccessPointDlg::OnOtherCommand(WPARAM wParam, LPARAM)
|
|
{
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDC_NEWAP_NAME_EDIT:
|
|
{
|
|
HWND hwndEdit = GetDlgItem(m_hWnd, IDC_NEWAP_NAME_EDIT);
|
|
HWND hwndOK = GetDlgItem(m_hWnd, IDOK);
|
|
|
|
if (hwndEdit && hwndOK)
|
|
{
|
|
size_t nLen = GetWindowTextLengthU(hwndEdit);
|
|
|
|
if (nLen > 0)
|
|
{
|
|
EnableWindow(hwndOK, TRUE);
|
|
}
|
|
else
|
|
{
|
|
EnableWindow(hwndOK, FALSE);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Func: CGeneralPage::AddNewAPToReg
|
|
//
|
|
// Desc: Adds an AP under the Access Points key in the registry and also to the
|
|
// combo box
|
|
//
|
|
// Args: LPTSTR pszNewAPName - New access point name to add
|
|
// BOOL fRefreshUiWwithCurrentValues - overwrite the values currently in UI dlg boxes
|
|
//
|
|
// Return: Nothing
|
|
//
|
|
// Notes:
|
|
//
|
|
// History: t-urama 07/31/2000 Created
|
|
//-----------------------------------------------------------------------------
|
|
void CGeneralPage::AddNewAPToReg(LPTSTR pszNewAPName, BOOL fRefreshUiWwithCurrentValues)
|
|
{
|
|
MYDBGASSERT(pszNewAPName);
|
|
|
|
if (!pszNewAPName)
|
|
{
|
|
return;
|
|
}
|
|
|
|
LPTSTR pszNewAPNameTmp = CmStrCpyAlloc(pszNewAPName);
|
|
|
|
|
|
DWORD dwIdx = (DWORD)SendDlgItemMessageU(m_hWnd,
|
|
IDC_GENERAL_ACCESSPOINT_COMBO,
|
|
CB_FINDSTRINGEXACT,
|
|
0,
|
|
(LPARAM)pszNewAPName);
|
|
if (CB_ERR != dwIdx)
|
|
{
|
|
UINT iSuffix = 1;
|
|
TCHAR szAPNameTemp[MAX_PATH + 10];
|
|
do
|
|
{
|
|
wsprintfU(szAPNameTemp, TEXT("%s%u"), pszNewAPNameTmp, iSuffix);
|
|
|
|
dwIdx = (DWORD)SendDlgItemMessageU(m_hWnd,
|
|
IDC_GENERAL_ACCESSPOINT_COMBO,
|
|
CB_FINDSTRINGEXACT,
|
|
0,
|
|
(LPARAM)szAPNameTemp);
|
|
iSuffix++;
|
|
} while(dwIdx != CB_ERR);
|
|
|
|
CmFree(pszNewAPNameTmp);
|
|
pszNewAPNameTmp = CmStrCpyAlloc(szAPNameTemp);
|
|
}
|
|
|
|
MYDBGASSERT(pszNewAPNameTmp);
|
|
if (pszNewAPNameTmp)
|
|
{
|
|
|
|
LPTSTR pszRegPath = BuildUserInfoSubKey(m_pArgs->szServiceName, m_pArgs->fAllUser);
|
|
|
|
MYDBGASSERT(pszRegPath);
|
|
|
|
if (NULL == pszRegPath)
|
|
{
|
|
return;
|
|
}
|
|
|
|
CmStrCatAlloc(&pszRegPath, TEXT("\\"));
|
|
CmStrCatAlloc(&pszRegPath, c_pszRegKeyAccessPoints);
|
|
CmStrCatAlloc(&pszRegPath, TEXT("\\"));
|
|
|
|
MYDBGASSERT(pszRegPath);
|
|
|
|
if (NULL == pszRegPath)
|
|
{
|
|
return;
|
|
}
|
|
|
|
CmStrCatAlloc(&pszRegPath,pszNewAPNameTmp);
|
|
|
|
MYDBGASSERT(pszRegPath);
|
|
|
|
if (NULL == pszRegPath)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (pszRegPath)
|
|
{
|
|
DWORD dwRes;
|
|
HKEY hKeyCm;
|
|
DWORD dwDisposition;
|
|
|
|
|
|
dwRes = RegCreateKeyExU(HKEY_CURRENT_USER,
|
|
pszRegPath,
|
|
0,
|
|
TEXT(""),
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&hKeyCm,
|
|
&dwDisposition);
|
|
if (ERROR_SUCCESS == dwRes)
|
|
{
|
|
|
|
dwRes = (DWORD)SendDlgItemMessageU(m_hWnd, IDC_GENERAL_ACCESSPOINT_COMBO, CB_ADDSTRING,
|
|
0, (LPARAM)pszNewAPNameTmp);
|
|
if (CB_ERR != dwRes)
|
|
{
|
|
CMTRACE1(TEXT("Added new Access point - %s"), pszNewAPNameTmp);
|
|
SendDlgItemMessageU(m_hWnd, IDC_GENERAL_ACCESSPOINT_COMBO, CB_SETCURSEL, (WPARAM)dwRes, 0L);
|
|
if (ChangedAccessPoint(m_pArgs, m_hWnd, IDC_GENERAL_ACCESSPOINT_COMBO))
|
|
{
|
|
this->UpdateForNewAccessPoint(fRefreshUiWwithCurrentValues);
|
|
}
|
|
|
|
//
|
|
// if access points are enabled for the first time, make the AccessPointsEnabled flag TRUE
|
|
//
|
|
|
|
if (!m_pArgs->fAccessPointsEnabled)
|
|
{
|
|
m_pArgs->fAccessPointsEnabled = TRUE;
|
|
WriteUserInfoToReg(m_pArgs, UD_ID_ACCESSPOINTENABLED, (PVOID) &m_pArgs->fAccessPointsEnabled);
|
|
}
|
|
}
|
|
RegCloseKey(hKeyCm);
|
|
}
|
|
}
|
|
CmFree(pszRegPath);
|
|
}
|
|
|
|
CmFree(pszNewAPNameTmp);
|
|
|
|
}
|
|
|
|
//
|
|
// Help id pairs
|
|
//
|
|
const DWORD CVpnPage::m_dwHelp[] = {
|
|
IDC_VPN_SEL_COMBO, IDH_VPN_SELECTOR,
|
|
0,0};
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Func: CVpnPage::CVpnPage
|
|
//
|
|
// Desc: Constructor for the CVpnPage class.
|
|
//
|
|
// Args: ArgsStruct* pArgs - pointer to the Args structure
|
|
// UINT nIDTemplate - template ID of the VPN page, passed to its parent
|
|
//
|
|
// Return: Nothing
|
|
//
|
|
// Notes:
|
|
//
|
|
// History: quintinb 11/01/2000 Created
|
|
//-----------------------------------------------------------------------------
|
|
CVpnPage::CVpnPage(ArgsStruct* pArgs, UINT nIDTemplate)
|
|
: CPropertiesPage(nIDTemplate, m_dwHelp, pArgs->pszHelpFile)
|
|
{
|
|
MYDBGASSERT(pArgs);
|
|
m_pArgs = pArgs;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Func: CVpnPage::OnInitDialog
|
|
//
|
|
// Desc: Handles the WM_INITDLG processing for the VPN page of the CM
|
|
// property sheet. Basically fills the VPN message text, fills the
|
|
// VPN selector combo and selects an item in the list as necessary.
|
|
//
|
|
// Args: None
|
|
//
|
|
// Return: BOOL - TRUE if it initialized successfully.
|
|
//
|
|
// Notes:
|
|
//
|
|
// History: quintinb 11/01/2000 Created
|
|
//-----------------------------------------------------------------------------
|
|
BOOL CVpnPage::OnInitDialog()
|
|
{
|
|
if (m_pArgs->pszVpnFile)
|
|
{
|
|
//
|
|
// Add the VPN friendly names to the combo
|
|
//
|
|
AddAllKeysInCurrentSectionToCombo(m_hWnd, IDC_VPN_SEL_COMBO, c_pszCmSectionVpnServers, m_pArgs->pszVpnFile);
|
|
|
|
//
|
|
// Now we need to select a friendly name in the combo box if the user has already selected something or
|
|
// if the user has yet to select something but their Admin specified a default.
|
|
//
|
|
LPTSTR pszDefault = m_pArgs->piniBothNonFav->GPPS(c_pszCmSection, c_pszCmEntryTunnelDesc);
|
|
|
|
if ((NULL == pszDefault) || (TEXT('\0') == pszDefault[0]))
|
|
{
|
|
CmFree(pszDefault);
|
|
pszDefault = GetPrivateProfileStringWithAlloc(c_pszCmSectionSettings, c_pszCmEntryVpnDefault, TEXT(""), m_pArgs->pszVpnFile);
|
|
}
|
|
|
|
if (pszDefault && pszDefault[0])
|
|
{
|
|
LONG_PTR lPtr = SendDlgItemMessageU(m_hWnd, IDC_VPN_SEL_COMBO, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)pszDefault);
|
|
|
|
if (CB_ERR != lPtr)
|
|
{
|
|
SendDlgItemMessageU(m_hWnd, IDC_VPN_SEL_COMBO, CB_SETCURSEL, (WPARAM)lPtr, (LPARAM)0);
|
|
}
|
|
}
|
|
|
|
CmFree(pszDefault);
|
|
|
|
//
|
|
// If the Admin specified a message, let's read that and set the static text control
|
|
//
|
|
LPTSTR pszMessage = GetPrivateProfileStringWithAlloc(c_pszCmSectionSettings, c_pszCmEntryVpnMessage, TEXT(""), m_pArgs->pszVpnFile);
|
|
|
|
if (pszMessage && pszMessage[0])
|
|
{
|
|
SendDlgItemMessageU(m_hWnd, IDC_VPN_MSG, WM_SETTEXT, (WPARAM)0, (LPARAM)pszMessage);
|
|
}
|
|
|
|
CmFree(pszMessage);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Func: CVpnPage::OnApply
|
|
//
|
|
// Desc: Called when the user hits the OK button for the CM property sheet.
|
|
// Handles saving the VPN server address and DUN setting name.
|
|
//
|
|
// Args: None
|
|
//
|
|
// Return: Nothing
|
|
//
|
|
// Notes:
|
|
//
|
|
// History: quintinb 11/01/2000 Created
|
|
//-----------------------------------------------------------------------------
|
|
void CVpnPage::OnApply()
|
|
{
|
|
//
|
|
// Okay, let's figure out what the user selected in the combo
|
|
//
|
|
LONG_PTR lPtr = SendDlgItemMessageU(m_hWnd, IDC_VPN_SEL_COMBO, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);
|
|
|
|
if (CB_ERR != lPtr)
|
|
{
|
|
LONG_PTR lTextLen = SendDlgItemMessageU(m_hWnd, IDC_VPN_SEL_COMBO, CB_GETLBTEXTLEN, (WPARAM)lPtr, (LPARAM)0);
|
|
|
|
if (CB_ERR != lTextLen)
|
|
{
|
|
LPTSTR pszFriendlyName = (LPTSTR)CmMalloc(sizeof(TCHAR)*(lTextLen+1));
|
|
|
|
if (pszFriendlyName)
|
|
{
|
|
lPtr = SendDlgItemMessageU(m_hWnd, IDC_VPN_SEL_COMBO, CB_GETLBTEXT, (WPARAM)lPtr, (LPARAM)pszFriendlyName);
|
|
|
|
if (CB_ERR != lPtr)
|
|
{
|
|
//
|
|
// Write the friendly name as the TunnelDesc
|
|
//
|
|
m_pArgs->piniBothNonFav->WPPS(c_pszCmSection, c_pszCmEntryTunnelDesc, pszFriendlyName);
|
|
|
|
//
|
|
// Now get the actual data and write it
|
|
//
|
|
LPTSTR pszVpnAddress = GetPrivateProfileStringWithAlloc(c_pszCmSectionVpnServers, pszFriendlyName, TEXT(""), m_pArgs->pszVpnFile);
|
|
|
|
//
|
|
// Now parse the line into the server name/IP and the DUN name if it exists.
|
|
//
|
|
if (pszVpnAddress)
|
|
{
|
|
LPTSTR pszVpnSetting = CmStrchr(pszVpnAddress, TEXT(','));
|
|
|
|
if (pszVpnSetting)
|
|
{
|
|
*pszVpnSetting = TEXT('\0');
|
|
pszVpnSetting++;
|
|
CmStrTrim(pszVpnSetting);
|
|
} // else it is NULL and we want to clear the existing key if it exists.
|
|
|
|
m_pArgs->piniBothNonFav->WPPS(c_pszCmSection, c_pszCmEntryTunnelDun, pszVpnSetting);
|
|
|
|
CmStrTrim(pszVpnAddress);
|
|
m_pArgs->piniBothNonFav->WPPS(c_pszCmSection, c_pszCmEntryTunnelAddress, pszVpnAddress);
|
|
|
|
//
|
|
// Since we may have changed the Network settings from PPTP to L2TP (or vice versa) on downlevel
|
|
// clients using the SafeNet client we will need to re-pick our tunnel device.
|
|
//
|
|
if (IsSafeNetClientAvailable())
|
|
{
|
|
MYVERIFY(PickTunnelDevice(m_pArgs, m_pArgs->szTunnelDeviceType, m_pArgs->szTunnelDeviceName));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("CVpnPage::OnApply -- GetPrivateProfileStringWithAlloc failed for pszVpnAddress"));
|
|
}
|
|
|
|
CmFree(pszVpnAddress);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CMASSERTMSG(FALSE, TEXT("CVpnPage::OnApply -- CmMalloc failed for pszFriendlyName"));
|
|
}
|
|
|
|
CmFree(pszFriendlyName);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|