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.
4754 lines
172 KiB
4754 lines
172 KiB
/////////////////////////////////////////////////////////////////////////////
|
|
// Copyright (C) 1993-1996 Microsoft Corporation. All Rights Reserved.
|
|
//
|
|
// MODULE: Server.cpp
|
|
//
|
|
// PURPOSE: Contains the dialog callback and supporting functions for
|
|
// the Add/Remove news server dialog.
|
|
//
|
|
|
|
#include "pch.hxx"
|
|
#include <mimeole.h>
|
|
#include <commctrl.h>
|
|
#include <wininet.h>
|
|
#include <shlwapi.h>
|
|
#include <shlwapip.h>
|
|
#include <ras.h>
|
|
#include "imnact.h"
|
|
#include "acctman.h"
|
|
#include "connect.h"
|
|
#include "acctui.h"
|
|
#include "server.h"
|
|
#include "strconst.h"
|
|
#include "dllmain.h"
|
|
#include <icwcfg.h>
|
|
#include "resource.h"
|
|
#include "accthelp.h"
|
|
#include <icwacct.h>
|
|
#include <acctimp.h>
|
|
#include "icwwiz.h"
|
|
#include <wincrypt.h>
|
|
#include <wintrust.h>
|
|
#include <cryptdlg.h>
|
|
#include "htmlhelp.h"
|
|
#include "shared.h"
|
|
#include "oeconprp.h"
|
|
#include "demand.h"
|
|
|
|
#ifdef _UNICODE
|
|
#define _T(x) L ## x
|
|
#else
|
|
#define _T(x) x
|
|
#endif
|
|
|
|
ASSERTDATA
|
|
|
|
typedef struct tagFilterInfo
|
|
{
|
|
TCHAR *szEmail;
|
|
BOOL fEncryption;
|
|
DWORD dwFlags;
|
|
} ACCTFILTERINFO;
|
|
|
|
typedef struct tagSVRDLGINFO
|
|
{
|
|
SERVER_TYPE sfType;
|
|
DWORD dwDirty;
|
|
BOOL dwInit;
|
|
BOOL fNoValidate;
|
|
} SVRDLGINFO;
|
|
|
|
typedef struct tagSECPAGEINFO
|
|
{
|
|
PCCERT_CONTEXT pCert;
|
|
HCERTSTORE hCertStore;
|
|
PCCERT_CONTEXT pEncryptCert;
|
|
} SECPAGEINFO;
|
|
|
|
typedef struct tagSMTPAUTHINFO
|
|
{
|
|
BOOL fDirty;
|
|
SMTPAUTHTYPE authtype;
|
|
CHAR szUserName[CCHMAX_USERNAME];
|
|
CHAR szPassword[CCHMAX_PASSWORD];
|
|
BOOL fPromptPassword;
|
|
} SMTPAUTHINFO, *LPSMTPAUTHINFO;
|
|
|
|
INT_PTR CALLBACK ServerProp_GeneralDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
INT_PTR CALLBACK ServerProp_ServerDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
INT_PTR CALLBACK ServerProp_AdvancedDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
|
|
INT_PTR CALLBACK SmtpLogonSettingsDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
|
|
INT_PTR CALLBACK MailServer_GeneralDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
INT_PTR CALLBACK MailServer_ServersDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
INT_PTR CALLBACK MailServer_SecurityDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
INT_PTR CALLBACK MailServer_AdvancedDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
INT_PTR CALLBACK MailServer_IMAPDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
|
|
INT_PTR CALLBACK DirServer_GeneralDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
INT_PTR CALLBACK DirServer_AdvancedDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
|
|
void ImapRemoveTrailingHC(LPSTR pszPath, UINT uiLen);
|
|
BOOL ValidateAccountName(HWND hwnd, HWND hwndEdit, IImnAccount *pAcct, int *pidsError);
|
|
void GetAccountName(HWND hwndEdit, IImnAccount *pAcct);
|
|
|
|
void InitUserInformation(HWND hwnd, IImnAccount *pAcct, BOOL fNews);
|
|
BOOL ValidateUserInformation(HWND hwnd, IImnAccount *pAcct, BOOL fNews, HWND *phwndErr, int *puIdsErr, BOOL fApply);
|
|
void GetUserInformation(HWND hwnd, IImnAccount *pAcct, BOOL fNews);
|
|
|
|
BOOL ValidateServerName(HWND hwnd, HWND hwndEdit, IImnAccount *pAcct, DWORD dwPropSvr, int *pidsError, BOOL fApply);
|
|
void GetServerName(HWND hwndEdit, IImnAccount *pAcct, DWORD dwPropSvr);
|
|
|
|
BOOL ValidateLogonSettings(HWND hwnd, DWORD dwDlgFlags, HWND *phwndError, int *pidsError);
|
|
void GetLogonSettings(HWND hwnd, IImnAccount *pAcct, BOOL fLogon, DWORD srv);
|
|
|
|
BOOL fWarnDomainName(HWND hwnd, DWORD dwDlgFlags, LPTSTR pszPreviousLoginName);
|
|
|
|
int CALLBACK PropSheetProc(HWND hwndDlg, UINT uMsg, LPARAM lParam);
|
|
|
|
BOOL ValidateCertificate(HWND hwnd, IImnAccount *pAcct, SVRDLGINFO *psdi, HWND *phwndErr, int *puIdsErr);
|
|
BOOL DoCertDialog(HWND hwndOwner, HWND hwndEmail, PCCERT_CONTEXT *ppCert, HCERTSTORE hCertStore, int *pidsError, DWORD dwFlags, BOOL fEncription);
|
|
BOOL CertFilterFunction(PCCERT_CONTEXT pCertContext, LPARAM dwEmailAddr, DWORD dwFlags, DWORD);
|
|
void GetCertificate(HWND hwnd, IImnAccount *pAcct, SVRDLGINFO *psdi);
|
|
DWORD InitCertificateData(TCHAR * szEmail, SVRDLGINFO *psdi, IImnAccount *pAcct);
|
|
|
|
DWORD InitEncryptData(TCHAR * szEmail, SECPAGEINFO *psdi, IImnAccount *pAcct);
|
|
int CheckKeyUsage(PCCERT_CONTEXT pCert, DWORD dwFlag);
|
|
HRESULT HrGetHighestSymcaps(LPBYTE * ppbSymcap, ULONG *pcbSymcap);
|
|
BOOL AdvSec_FillEncAlgCombo(HWND hwnd, IImnAccount *pAcct, PCCERT_CONTEXT * prgCerts);
|
|
BOOL AdvSec_GetEncryptAlgCombo(HWND hwnd, IImnAccount *pAcct);
|
|
|
|
void GetDigitalID(HWND hwnd);
|
|
|
|
DWORD DwGenerateTrustedChain(
|
|
HWND hwnd,
|
|
DWORD dwFlags,
|
|
PCCERT_CONTEXT pcCertToTest,
|
|
DWORD dwToIgnore,
|
|
BOOL fFullSearch,
|
|
DWORD * pcChain,
|
|
PCCERT_CONTEXT ** prgChain);
|
|
|
|
|
|
#define SERVERPROP_PAGEMAX 7
|
|
|
|
typedef struct tagSERVERPROP_PAGE
|
|
{
|
|
UINT uDlgId;
|
|
DLGPROC pfnDlg;
|
|
} SERVERPROP_PAGE;
|
|
|
|
typedef struct tagSERVERPROP_PARAMS
|
|
{
|
|
UINT uIcon;
|
|
UINT idsCaption;
|
|
SERVERPROP_PAGE rgPage[SERVERPROP_PAGEMAX];
|
|
} SERVERPROP_PARAMS;
|
|
|
|
static const SERVERPROP_PARAMS c_rgServerPropParams[ACCT_LAST] = {
|
|
// news
|
|
{ idiNewsServer,
|
|
idsNewsAcctProperties,
|
|
{{iddServerProp_General, ServerProp_GeneralDlgProc},
|
|
{iddServerProp_Server, ServerProp_ServerDlgProc},
|
|
{iddServerProp_Connect, ConnectPage_DlgProc},
|
|
{iddServerProp_Advanced, ServerProp_AdvancedDlgProc},
|
|
{0, NULL},
|
|
{0, NULL},
|
|
{0, NULL}}
|
|
},
|
|
|
|
// mail
|
|
{ idiMailServer,
|
|
idsMailAcctProperties,
|
|
{{iddMailSvrProp_General, MailServer_GeneralDlgProc},
|
|
{iddMailSvrProp_Servers, MailServer_ServersDlgProc},
|
|
{iddMailSvrProp_HttpServer, MailServer_ServersDlgProc},
|
|
{iddServerProp_Connect, ConnectPage_DlgProc},
|
|
{iddMailSvrProp_Security, MailServer_SecurityDlgProc},
|
|
{iddMailSvrProp_Advanced, MailServer_AdvancedDlgProc},
|
|
{iddMailSvrProp_IMAP, MailServer_IMAPDlgProc}}
|
|
},
|
|
|
|
// directory service
|
|
{ idiLDAPServer,
|
|
idsDirSrvAcctProperties,
|
|
{{iddDirServProp_General, DirServer_GeneralDlgProc},
|
|
{iddDirServProp_Advanced, DirServer_AdvancedDlgProc},
|
|
{0, NULL},
|
|
{0, NULL},
|
|
{0, NULL},
|
|
{0, NULL},
|
|
{0, NULL}}
|
|
}
|
|
};
|
|
|
|
// generate static prop tables for each of the protocols
|
|
|
|
#define GEN_PROPS(type) \
|
|
{ \
|
|
AP_##type##_SERVER, \
|
|
AP_##type##_USERNAME, \
|
|
AP_##type##_PASSWORD, \
|
|
AP_##type##_PROMPT_PASSWORD, \
|
|
AP_##type##_USE_SICILY \
|
|
}
|
|
|
|
static MAILSERVERPROPSINFO c_rgMailServerProps[] =
|
|
{
|
|
GEN_PROPS(POP3),
|
|
GEN_PROPS(IMAP),
|
|
GEN_PROPS(HTTPMAIL),
|
|
GEN_PROPS(NNTP),
|
|
{ AP_LDAP_SERVER, AP_LDAP_USERNAME, AP_LDAP_PASSWORD, 0, AP_LDAP_AUTHENTICATION }
|
|
};
|
|
|
|
#undef GEN_PROPS
|
|
|
|
// Public constants
|
|
|
|
BOOL GetServerProps(SERVER_TYPE serverType, LPMAILSERVERPROPSINFO *psp)
|
|
{
|
|
Assert(psp);
|
|
|
|
switch (serverType)
|
|
{
|
|
case SERVER_MAIL:
|
|
*psp = &c_rgMailServerProps[0];
|
|
break;
|
|
|
|
case SERVER_IMAP:
|
|
*psp = &c_rgMailServerProps[1];
|
|
break;
|
|
|
|
case SERVER_HTTPMAIL:
|
|
*psp = &c_rgMailServerProps[2];
|
|
break;
|
|
|
|
case SERVER_NEWS:
|
|
*psp = &c_rgMailServerProps[3];
|
|
break;
|
|
|
|
case SERVER_LDAP:
|
|
*psp = &c_rgMailServerProps[4];
|
|
break;
|
|
|
|
default:
|
|
*psp = NULL;
|
|
break;
|
|
}
|
|
|
|
return (NULL != *psp);
|
|
}
|
|
|
|
void MarkPageDirty(HWND hwnd, LPARAM page)
|
|
{
|
|
PropSheet_QuerySiblings(GetParent(hwnd), SM_SETDIRTY, page);
|
|
PropSheet_Changed(GetParent(hwnd), hwnd);
|
|
}
|
|
|
|
int HandleQuerySiblings(HWND hwnd, SVRDLGINFO *psdi, IImnAccount *pAcct, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
int fRet;
|
|
DWORD dwPage, *pdw;
|
|
TCHAR sz[CCHMAX_ACCT_PROP_SZ];
|
|
HWND hwndT, hwndPage;
|
|
ULONG uidsError, idCtrl, idd;
|
|
|
|
Assert(psdi != NULL);
|
|
Assert(pAcct != NULL);
|
|
|
|
fRet = TRUE;
|
|
|
|
switch (wParam)
|
|
{
|
|
case MSM_GETSERVERTYPE:
|
|
Assert(lParam != NULL);
|
|
Assert(psdi->sfType == SERVER_MAIL || psdi->sfType == SERVER_IMAP || psdi->sfType == SERVER_HTTPMAIL);
|
|
*((SERVER_TYPE *)lParam) = psdi->sfType;
|
|
break;
|
|
|
|
case MSM_GETEMAILADDRESS:
|
|
GetDlgItemText(hwnd, IDE_EMAIL_ADDRESS, sz, ARRAYSIZE(sz));
|
|
StrCpyN((LPTSTR)lParam, sz, CCHMAX_EMAIL_ADDRESS);
|
|
break;
|
|
|
|
case MSM_GETDISPLAYNAME:
|
|
GetDlgItemText(hwnd, IDE_DISPLAY_NAME, sz, ARRAYSIZE(sz));
|
|
StrCpyN((LPTSTR)lParam, sz, CCHMAX_DISPLAY_NAME);
|
|
break;
|
|
|
|
case SM_SETDIRTY:
|
|
if (!!(psdi->dwInit & lParam))
|
|
psdi->dwDirty = (psdi->dwDirty | (DWORD) lParam);
|
|
break;
|
|
|
|
case SM_SAVECHANGES:
|
|
pdw = (DWORD *)lParam;
|
|
if (!!(psdi->dwInit & *pdw) && psdi->dwDirty != 0)
|
|
{
|
|
psdi->dwDirty = (psdi->dwDirty & ~(*pdw));
|
|
if (psdi->dwDirty == 0)
|
|
{
|
|
uidsError = 0;
|
|
dwPage = PAGE_SERVER;
|
|
|
|
if (psdi->sfType == SERVER_MAIL || psdi->sfType == SERVER_IMAP)
|
|
{
|
|
if (FAILED(pAcct->GetPropSz(AP_SMTP_SERVER, sz, ARRAYSIZE(sz))))
|
|
{
|
|
uidsError = idsEnterSmtpServer;
|
|
idCtrl = IDC_SMTP_EDIT;
|
|
idd = iddMailSvrProp_Servers;
|
|
}
|
|
else if (psdi->sfType == SERVER_MAIL &&
|
|
FAILED(pAcct->GetPropSz(AP_POP3_SERVER, sz, ARRAYSIZE(sz))))
|
|
{
|
|
uidsError = idsEnterPop3Server;
|
|
idCtrl = IDC_POP3_EDIT;
|
|
idd = iddMailSvrProp_Servers;
|
|
}
|
|
else if (psdi->sfType == SERVER_IMAP &&
|
|
FAILED(pAcct->GetPropSz(AP_IMAP_SERVER, sz, ARRAYSIZE(sz))))
|
|
{
|
|
uidsError = idsEnterIMAPServer;
|
|
idCtrl = IDC_POP3_EDIT;
|
|
idd = iddMailSvrProp_Servers;
|
|
}
|
|
else if (psdi->sfType == SERVER_HTTPMAIL &&
|
|
FAILED(pAcct->GetPropSz(AP_HTTPMAIL_SERVER, sz, ARRAYSIZE(sz))))
|
|
{
|
|
uidsError = idsEnterHTTPMailServer;
|
|
idCtrl = IDC_POP3_EDIT;
|
|
idd = iddMailSvrProp_Servers;
|
|
}
|
|
}
|
|
else if (psdi->sfType == SERVER_NEWS)
|
|
{
|
|
if (FAILED(pAcct->GetPropSz(AP_NNTP_SERVER, sz, ARRAYSIZE(sz))))
|
|
{
|
|
uidsError = idsEnterIMAPServer;
|
|
idCtrl = IDC_NEWSNAME_EDIT;
|
|
idd = iddServerProp_Server;
|
|
}
|
|
}
|
|
|
|
if (uidsError != 0)
|
|
{
|
|
AcctMessageBox(hwnd, MAKEINTRESOURCE(idsAccountManager),
|
|
MAKEINTRESOURCE(uidsError), 0, MB_ICONEXCLAMATION | MB_OK);
|
|
|
|
SendMessage(GetParent(hwnd), PSM_SETCURSELID, 0, (LPARAM)idd);
|
|
hwndPage = PropSheet_GetCurrentPageHwnd(GetParent(hwnd));
|
|
|
|
psdi->dwDirty = (psdi->dwDirty | dwPage);
|
|
PropSheet_Changed(GetParent(hwnd), hwndPage);
|
|
|
|
hwndT = GetDlgItem(hwndPage, idCtrl);
|
|
SendMessage(hwndT, EM_SETSEL, 0, -1);
|
|
SetFocus(hwndT);
|
|
|
|
*pdw = (DWORD)-1;
|
|
|
|
break;
|
|
}
|
|
|
|
pAcct->SaveChanges();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case SM_INITIALIZED:
|
|
psdi->dwInit = (psdi->dwInit | (DWORD) lParam);
|
|
break;
|
|
|
|
default:
|
|
fRet = FALSE;
|
|
break;
|
|
}
|
|
|
|
return(fRet);
|
|
}
|
|
|
|
BOOL InvalidAcctProp(HWND hwndPage, HWND hwndEdit, int idsError, UINT idPage)
|
|
{
|
|
HWND hwndCurr, hwndParent;
|
|
|
|
Assert(hwndPage != NULL);
|
|
Assert(idPage != 0);
|
|
|
|
hwndParent = GetParent(hwndPage);
|
|
|
|
if (idsError != 0)
|
|
AcctMessageBox(hwndPage, MAKEINTRESOURCE(idsAccountManager), MAKEINTRESOURCE(idsError), 0, MB_ICONEXCLAMATION | MB_OK);
|
|
|
|
hwndCurr = PropSheet_GetCurrentPageHwnd(hwndParent);
|
|
if (hwndCurr != hwndPage)
|
|
SendMessage(hwndParent, PSM_SETCURSELID, 0, (LPARAM)idPage);
|
|
|
|
if (hwndEdit != NULL)
|
|
{
|
|
SendMessage(hwndEdit, EM_SETSEL, 0, -1);
|
|
SetFocus(hwndEdit);
|
|
}
|
|
|
|
SetWindowLongPtr(hwndPage, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
void InitAcctPropEdit(HWND hwnd, IImnAccount *pAcct, DWORD dwProp, UINT cchMax)
|
|
{
|
|
TCHAR sz[CCHMAX_ACCT_PROP_SZ];
|
|
|
|
Assert(pAcct != NULL);
|
|
|
|
SetIntlFont(hwnd);
|
|
if (SUCCEEDED(pAcct->GetPropSz(dwProp, sz, ARRAYSIZE(sz))))
|
|
SetWindowText(hwnd, sz);
|
|
SendMessage(hwnd, EM_LIMITTEXT, cchMax, 0L);
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// CAccount::ShowProperties
|
|
// -----------------------------------------------------------------------------
|
|
STDMETHODIMP CAccount::ShowProperties(HWND hwndParent, DWORD dwFlags)
|
|
{
|
|
HRESULT hr;
|
|
int i, iReturn;
|
|
PROPSHEETPAGE *ppsp, psp[SERVERPROP_PAGEMAX];
|
|
PROPSHEETHEADER psh;
|
|
SERVERPROP_PARAMS *pProp;
|
|
SERVERPROP_PAGE *pPage;
|
|
TCHAR szFmt[256], sz[512];
|
|
DWORD dw = 0;
|
|
BOOL fIMAP;
|
|
BOOL fHttp;
|
|
INITCOMMONCONTROLSEX icex = { sizeof(icex), ICC_FLAGS };
|
|
|
|
Assert(m_AcctType < ACCT_LAST);
|
|
|
|
// Find out if we're an IMAP server
|
|
GetServerTypes(&dw);
|
|
fIMAP = !!(dw & SRV_IMAP);
|
|
fHttp = !!(dw & SRV_HTTPMAIL);
|
|
|
|
if (0 != (dwFlags & ~ACCTDLG_ALL))
|
|
return(E_INVALIDARG);
|
|
|
|
if (m_fNoModifyAccts)
|
|
return(S_FALSE);
|
|
|
|
InitCommonControlsEx(&icex);
|
|
|
|
pProp = (SERVERPROP_PARAMS *)&c_rgServerPropParams[m_AcctType];
|
|
|
|
psh.nPages = 0;
|
|
|
|
ppsp = psp;
|
|
ZeroMemory(psp, sizeof(PROPSHEETPAGE) * 4);
|
|
|
|
for (pPage = pProp->rgPage, i = 0; i < SERVERPROP_PAGEMAX; pPage++, i++)
|
|
{
|
|
if (pPage->pfnDlg == NULL)
|
|
break;
|
|
|
|
if (pPage->uDlgId == iddMailSvrProp_Security &&
|
|
!!(dwFlags & ACCTDLG_NO_SECURITY))
|
|
continue;
|
|
|
|
if (pPage->uDlgId == iddMailSvrProp_IMAP && FALSE == fIMAP)
|
|
continue;
|
|
|
|
if (pPage->uDlgId == iddMailSvrProp_Advanced && fHttp)
|
|
continue;
|
|
|
|
if (pPage->uDlgId == iddMailSvrProp_Servers && fHttp)
|
|
continue;
|
|
|
|
if (pPage->uDlgId == iddMailSvrProp_HttpServer && !fHttp)
|
|
continue;
|
|
|
|
ppsp->dwSize = sizeof(PROPSHEETPAGE);
|
|
ppsp->dwFlags = PSP_DEFAULT;
|
|
ppsp->hInstance = g_hInstRes;
|
|
if ((pPage->uDlgId == iddServerProp_Connect) &&
|
|
(!!(dwFlags & ACCTDLG_BACKUP_CONNECT)))
|
|
{
|
|
ppsp->pszTemplate = MAKEINTRESOURCE(iddServerProp_Connect2);
|
|
}
|
|
else
|
|
{
|
|
ppsp->pszTemplate = MAKEINTRESOURCE(pPage->uDlgId);
|
|
}
|
|
ppsp->pfnDlgProc = pPage->pfnDlg;
|
|
|
|
//swap out the dialog id and the function proc if
|
|
if (((pPage->uDlgId == iddServerProp_Connect) ||
|
|
(pPage->uDlgId == iddServerProp_Connect2)) &&
|
|
(!!(dwFlags & ACCTDLG_INTERNETCONNECTION)))
|
|
{
|
|
ppsp->pszTemplate = MAKEINTRESOURCE(iddServerProp_ConnectOE);
|
|
ppsp->pfnDlgProc = OEConnProp_DlgProc;
|
|
}
|
|
|
|
|
|
ppsp->lParam = (LPARAM)this;
|
|
ppsp++;
|
|
psh.nPages++;
|
|
}
|
|
|
|
psh.dwSize = sizeof(PROPSHEETHEADER);
|
|
psh.dwFlags = PSH_USEICONID | PSH_PROPSHEETPAGE;
|
|
psh.hwndParent = hwndParent;
|
|
psh.hInstance = g_hInstRes;
|
|
psh.pszIcon = MAKEINTRESOURCE(pProp->uIcon);
|
|
if (*m_szName != 0)
|
|
{
|
|
LoadString(g_hInstRes, idsAcctPropsFmt, szFmt, ARRAYSIZE(szFmt));
|
|
wnsprintf(sz, ARRAYSIZE(sz), szFmt, m_szName);
|
|
psh.pszCaption = sz;
|
|
}
|
|
else
|
|
{
|
|
psh.pszCaption = (LPTSTR)IntToPtr(pProp->idsCaption);
|
|
}
|
|
psh.nStartPage = 0;
|
|
psh.ppsp = psp;
|
|
|
|
// bug 21535
|
|
psh.dwFlags |= PSH_USECALLBACK;
|
|
psh.pfnCallback = PropSheetProc;
|
|
|
|
m_dwDlgFlags = dwFlags;
|
|
|
|
iReturn = (int) PropertySheet(&psh);
|
|
|
|
if (iReturn < 0)
|
|
hr = E_FAIL;
|
|
else if (iReturn == 0)
|
|
hr = S_FALSE;
|
|
else
|
|
hr = S_OK;
|
|
|
|
return(hr);
|
|
}
|
|
|
|
//
|
|
// FUNCTION: ServerProp_Create()
|
|
//
|
|
// PURPOSE: Invokes the news server property sheet.
|
|
//
|
|
// PARAMETERS:
|
|
// <in> hwndParent - Handle that will be the parent of this dialog.
|
|
// <in> stType - Type of server. Must be in the SERVER_TYPE enum.
|
|
// <in> pszName - Friendly name for the server.
|
|
// <in> fNew - TRUE to add a new server.
|
|
//
|
|
// RETURN VALUE:
|
|
// TRUE if successful, or FALSE otherwise.
|
|
//
|
|
BOOL ServerProp_Create(HWND hwndParent, DWORD dwFlags, LPTSTR pszName, IImnAccount **ppAccount)
|
|
{
|
|
TCHAR szServer[CCHMAX_SERVER_NAME];
|
|
IImnAccount *pAcct;
|
|
BOOL fReturn = FALSE;
|
|
|
|
Assert(IsWindow(hwndParent));
|
|
Assert(pszName != NULL);
|
|
|
|
// Get the server object from the account manager
|
|
if (FAILED(g_pAcctMan->FindAccount(AP_ACCOUNT_NAME, pszName, &pAcct)))
|
|
return (FALSE);
|
|
|
|
Assert(pAcct != NULL);
|
|
|
|
if (S_OK == pAcct->ShowProperties(hwndParent, dwFlags))
|
|
{
|
|
fReturn = TRUE;
|
|
|
|
if (ppAccount)
|
|
{
|
|
*ppAccount = pAcct;
|
|
(*ppAccount)->AddRef();
|
|
}
|
|
}
|
|
|
|
SafeRelease(pAcct);
|
|
|
|
return (fReturn);
|
|
}
|
|
|
|
void UpdateAcctTitle(HWND hwnd, int idCtrl, ACCTTYPE AcctType)
|
|
{
|
|
TCHAR sz[512], szAcct[CCHMAX_ACCOUNT_NAME], szFmt[256];
|
|
int id, cch;
|
|
|
|
cch = GetDlgItemText(hwnd, idCtrl, szAcct, ARRAYSIZE(szAcct));
|
|
if (cch == 0)
|
|
{
|
|
LoadString(g_hInstRes, c_rgServerPropParams[AcctType].idsCaption, sz, ARRAYSIZE(sz));
|
|
}
|
|
else
|
|
{
|
|
LoadString(g_hInstRes, idsAcctPropsFmt, szFmt, ARRAYSIZE(szFmt));
|
|
wnsprintf(sz, ARRAYSIZE(sz), szFmt, szAcct);
|
|
}
|
|
|
|
PropSheet_SetTitle(GetParent(hwnd), 0, sz);
|
|
}
|
|
|
|
const static HELPMAP g_rgCtxMapNewsGen[] = {
|
|
{IDC_SERVERNAME_EDIT, IDH_MAIL_ACCOUNT},
|
|
{IDE_DISPLAY_NAME, IDH_NEWS_SERV_NAME},
|
|
{IDE_ORG_NAME, IDH_NEWS_SERV_ORG},
|
|
{IDE_EMAIL_ADDRESS, IDH_NEWS_SERV_EMAIL_ADD},
|
|
{IDE_REPLYTO_EMAIL_ADDRESS, IDH_MAIL_SERV_ADV_REPLY_TO},
|
|
{IDC_NEWSPOLL_CHECK, IDH_INCLUDE_NEWS_ACCOUNT},
|
|
{IDC_STATIC0, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC1, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC2, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC3, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC4, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC5, IDH_INETCOMM_GROUPBOX},
|
|
{0, 0}};
|
|
|
|
INT_PTR CALLBACK ServerProp_GeneralDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
BOOL fRet;
|
|
DWORD dw;
|
|
int idsError;
|
|
HWND hwndT;
|
|
NMHDR *pnmhdr;
|
|
SVRDLGINFO *psdi;
|
|
CAccount *pAcct;
|
|
TCHAR szBuffer[CCHMAX_ACCOUNT_NAME];
|
|
|
|
pAcct = (CAccount *)GetWindowLongPtr(hwnd, DWLP_USER);
|
|
psdi = (SVRDLGINFO *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
if (!MemAlloc((void **)&psdi, sizeof(SVRDLGINFO)))
|
|
return(-1);
|
|
ZeroMemory(psdi, sizeof(SVRDLGINFO));
|
|
psdi->sfType = SERVER_NEWS;
|
|
SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)psdi);
|
|
|
|
// Get the ServerParams and store them in our extra bytes
|
|
pAcct = (CAccount*) ((PROPSHEETPAGE*) lParam)->lParam;
|
|
SetWindowLongPtr(hwnd, DWLP_USER, (LPARAM) pAcct);
|
|
|
|
InitUserInformation(hwnd, pAcct, TRUE);
|
|
|
|
InitAcctPropEdit(GetDlgItem(hwnd, IDC_SERVERNAME_EDIT), pAcct, AP_ACCOUNT_NAME, CCHMAX_ACCOUNT_NAME - 1);
|
|
|
|
// Poll this account...
|
|
if (!!(pAcct->m_dwDlgFlags & ACCTDLG_NO_NEWSPOLL))
|
|
ShowWindow(GetDlgItem(hwnd, IDC_NEWSPOLL_CHECK), SW_HIDE);
|
|
|
|
if (SUCCEEDED(pAcct->GetPropDw(AP_NNTP_POLL, &dw)))
|
|
CheckDlgButton(hwnd, IDC_NEWSPOLL_CHECK, dw ? BST_CHECKED : BST_UNCHECKED);
|
|
else
|
|
CheckDlgButton(hwnd, IDC_NEWSPOLL_CHECK, BST_UNCHECKED);
|
|
|
|
psdi->dwInit = (psdi->dwInit | PAGE_GEN);
|
|
PropSheet_UnChanged(GetParent(hwnd), hwnd);
|
|
return(TRUE);
|
|
|
|
case WM_DESTROY:
|
|
psdi = (SVRDLGINFO *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
|
|
if (psdi != NULL)
|
|
MemFree(psdi);
|
|
break;
|
|
|
|
case WM_HELP:
|
|
case WM_CONTEXTMENU:
|
|
return(OnContextHelp(hwnd, uMsg, wParam, lParam, g_rgCtxMapNewsGen));
|
|
|
|
case WM_COMMAND:
|
|
if (LOWORD(wParam) == IDC_NEWSPOLL_CHECK)
|
|
{
|
|
MarkPageDirty(hwnd, PAGE_GEN);
|
|
}
|
|
else if (HIWORD(wParam) == EN_CHANGE)
|
|
{
|
|
if (LOWORD(wParam) == IDC_SERVERNAME_EDIT)
|
|
UpdateAcctTitle(hwnd, IDC_SERVERNAME_EDIT, ACCT_NEWS);
|
|
MarkPageDirty(hwnd, PAGE_GEN);
|
|
}
|
|
return (TRUE);
|
|
|
|
case PSM_QUERYSIBLINGS:
|
|
return(HandleQuerySiblings(hwnd, psdi, pAcct, wParam, lParam));
|
|
|
|
case WM_NOTIFY:
|
|
pnmhdr = (NMHDR *)lParam;
|
|
switch (pnmhdr->code)
|
|
{
|
|
case PSN_APPLY:
|
|
// BEGIN validation
|
|
|
|
hwndT = GetDlgItem(hwnd, IDC_SERVERNAME_EDIT);
|
|
if (!ValidateAccountName(hwnd, hwndT, pAcct, &idsError))
|
|
return(InvalidAcctProp(hwnd, hwndT, idsError, iddServerProp_General));
|
|
|
|
fRet = ValidateUserInformation(hwnd, pAcct, TRUE, &hwndT, &idsError, pnmhdr->code == PSN_APPLY);
|
|
if (!fRet)
|
|
return(InvalidAcctProp(hwnd, hwndT, idsError, iddServerProp_General));
|
|
|
|
// END validation
|
|
|
|
hwndT = GetDlgItem(hwnd, IDC_SERVERNAME_EDIT);
|
|
GetAccountName(hwndT, pAcct);
|
|
|
|
GetUserInformation(hwnd, pAcct, TRUE);
|
|
|
|
// News Polling
|
|
pAcct->SetPropDw(AP_NNTP_POLL, (DWORD) IsDlgButtonChecked(hwnd, IDC_NEWSPOLL_CHECK));
|
|
|
|
PropSheet_UnChanged(GetParent(hwnd), hwnd);
|
|
dw = PAGE_GEN;
|
|
PropSheet_QuerySiblings(GetParent(hwnd), SM_SAVECHANGES, (LPARAM)&dw);
|
|
if (dw == -1)
|
|
{
|
|
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
|
|
return(TRUE);
|
|
}
|
|
break;
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
return (FALSE);
|
|
}
|
|
|
|
BOOL ValidateServerName(HWND hwnd, HWND hwndEdit, IImnAccount *pAcct, DWORD dwPropSvr, int *pidsError, BOOL fApply)
|
|
{
|
|
HRESULT hr;
|
|
int idsSvr, idsPrompt;
|
|
ULONG cbSize;
|
|
TCHAR sz[CCHMAX_SERVER_NAME];
|
|
DWORD dw;
|
|
|
|
Assert(hwndEdit != NULL);
|
|
Assert(pAcct != NULL);
|
|
Assert(pidsError != NULL);
|
|
|
|
*pidsError = 0;
|
|
|
|
switch(dwPropSvr)
|
|
{
|
|
case AP_LDAP_SERVER:
|
|
idsSvr = idsEnterLdapServer;
|
|
idsPrompt = idsInvalidLdapServer;
|
|
break;
|
|
case AP_IMAP_SERVER:
|
|
idsSvr = idsEnterIMAPServer;
|
|
idsPrompt = idsInvalidIMAPServer;
|
|
break;
|
|
case AP_NNTP_SERVER:
|
|
idsSvr = idsEnterNntpServer;
|
|
idsPrompt = idsInvalidNntpServer;
|
|
break;
|
|
case AP_POP3_SERVER:
|
|
idsSvr = idsEnterPop3Server;
|
|
idsPrompt = idsInvalidPop3Server;
|
|
break;
|
|
case AP_SMTP_SERVER:
|
|
idsSvr = idsEnterSmtpServer;
|
|
idsPrompt = idsInvalidSmtpServer;
|
|
break;
|
|
case AP_HTTPMAIL_SERVER:
|
|
idsSvr = idsEnterHTTPMailServer;
|
|
idsPrompt = idsInvalidHTTPMailServer;
|
|
break;
|
|
default:
|
|
Assert(FALSE);
|
|
break;
|
|
}
|
|
|
|
cbSize = GetWindowText(hwndEdit, sz, ARRAYSIZE(sz));
|
|
UlStripWhitespace(sz, TRUE, TRUE, &cbSize);
|
|
if (cbSize == 0)
|
|
{
|
|
// it is legal to have no smtp server with httpmail
|
|
if (dwPropSvr != AP_SMTP_SERVER || FAILED(pAcct->GetServerTypes(&dw)) || !(dw & SRV_HTTPMAIL))
|
|
{
|
|
*pidsError = idsSvr;
|
|
return(FALSE);
|
|
}
|
|
}
|
|
// if the server hasn't changed, we don't need to validate it
|
|
if (0 == SendMessage(hwndEdit, EM_GETMODIFY, 0, 0))
|
|
return(TRUE);
|
|
hr = pAcct->ValidateProperty(dwPropSvr, (LPBYTE)sz, 0);
|
|
if (FAILED(hr))
|
|
{
|
|
*pidsError = idsSvr;
|
|
return(FALSE);
|
|
}
|
|
else if (hr == S_NonStandardValue && fApply)
|
|
{
|
|
if (IDNO == AcctMessageBox(hwnd, MAKEINTRESOURCE(idsAccountManager), MAKEINTRESOURCE(idsPrompt),
|
|
NULL, MB_YESNO | MB_ICONEXCLAMATION | MB_DEFBUTTON2))
|
|
return(FALSE);
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
void GetServerName(HWND hwndEdit, IImnAccount *pAcct, DWORD dwPropSvr)
|
|
{
|
|
ULONG cbSize;
|
|
TCHAR sz[CCHMAX_SERVER_NAME];
|
|
|
|
Assert(hwndEdit != NULL);
|
|
Assert(pAcct != NULL);
|
|
|
|
if (0 != SendMessage(hwndEdit, EM_GETMODIFY, 0, 0))
|
|
{
|
|
cbSize = GetWindowText(hwndEdit, sz, ARRAYSIZE(sz));
|
|
UlStripWhitespace(sz, TRUE, TRUE, &cbSize);
|
|
if (cbSize == 0)
|
|
pAcct->SetProp(dwPropSvr, NULL, 0);
|
|
else
|
|
pAcct->SetPropSz(dwPropSvr, sz);
|
|
|
|
if (dwPropSvr == AP_POP3_SERVER)
|
|
pAcct->SetProp(AP_IMAP_SERVER, NULL, 0);
|
|
else if (dwPropSvr == AP_IMAP_SERVER)
|
|
{
|
|
DWORD dw;
|
|
|
|
pAcct->SetProp(AP_POP3_SERVER, NULL, 0);
|
|
if (FAILED(pAcct->GetPropDw(AP_IMAP_DIRTY, &dw)))
|
|
dw = 0;
|
|
|
|
dw |= IMAP_FLDRLIST_DIRTY;
|
|
pAcct->SetPropDw(AP_IMAP_DIRTY, dw);
|
|
}
|
|
|
|
SendMessage(hwndEdit, EM_SETMODIFY, 0, 0);
|
|
}
|
|
}
|
|
|
|
BOOL ValidateLogonSettings(HWND hwnd, DWORD dwDlgFlags,
|
|
HWND *phwndError, int *pidsError)
|
|
{
|
|
TCHAR sz[CCHMAX_ACCT_PROP_SZ];
|
|
HWND hwndT;
|
|
ULONG cbSize;
|
|
|
|
Assert(hwnd != NULL);
|
|
Assert(phwndError != NULL);
|
|
Assert(pidsError != NULL);
|
|
|
|
BOOL fOE = ISFLAGSET(dwDlgFlags, ACCTDLG_OE);
|
|
BOOL fSPA = IsDlgButtonChecked(hwnd, IDC_LOGONSSPI_CHECK);
|
|
|
|
*phwndError = NULL;
|
|
*pidsError = 0;
|
|
|
|
hwndT = GetDlgItem(hwnd, IDC_ACCTNAME_EDIT);
|
|
cbSize = GetWindowText(hwndT, sz, ARRAYSIZE(sz));
|
|
UlStripWhitespace(sz, TRUE, TRUE, &cbSize);
|
|
if (fOE && cbSize == 0)
|
|
{
|
|
*phwndError = hwndT;
|
|
*pidsError = idsEnterAcctName;
|
|
return (FALSE);
|
|
}
|
|
|
|
return (TRUE);
|
|
}
|
|
|
|
BOOL fWarnDomainName(HWND hwnd, DWORD dwDlgFlags, LPTSTR pszPreviousLoginName)
|
|
{
|
|
TCHAR sz[CCHMAX_ACCT_PROP_SZ];
|
|
HWND hwndT;
|
|
ULONG cbSize;
|
|
BOOL fret = TRUE;
|
|
BOOL fOE = TRUE;
|
|
|
|
fOE = ISFLAGSET(dwDlgFlags, ACCTDLG_OE);
|
|
|
|
hwndT = GetDlgItem(hwnd, IDC_ACCTNAME_EDIT);
|
|
cbSize = GetWindowText(hwndT, sz, ARRAYSIZE(sz));
|
|
UlStripWhitespace(sz, TRUE, TRUE, &cbSize);
|
|
|
|
if (fOE &&
|
|
(lstrcmp(pszPreviousLoginName, sz) != 0))
|
|
{
|
|
if (ValidEmailAddressParts(sz, NULL, 0, NULL, 0) != S_OK)
|
|
{
|
|
if (IDNO == AcctMessageBox(hwnd, MAKEINTRESOURCE(idsAccountManager),
|
|
MAKEINTRESOURCE(idsAccountNameErr),
|
|
NULL, MB_YESNO))
|
|
{
|
|
fret = FALSE;
|
|
goto exit;
|
|
}
|
|
}
|
|
}
|
|
|
|
exit:
|
|
return fret;
|
|
}
|
|
|
|
|
|
void GetLogonSettings(HWND hwnd, IImnAccount *pAcct, BOOL fLogon, DWORD srv)
|
|
{
|
|
HWND hwndT;
|
|
ULONG cbSize;
|
|
TCHAR sz[CCHMAX_ACCT_PROP_SZ];
|
|
DWORD dw, fOldSicily = FALSE;
|
|
LPMAILSERVERPROPSINFO pServerProps = NULL;
|
|
BOOL fIMAPDirty = FALSE;
|
|
|
|
Assert(pAcct != NULL);
|
|
|
|
switch (srv)
|
|
{
|
|
case SRV_POP3:
|
|
GetServerProps(SERVER_MAIL, &pServerProps);
|
|
break;
|
|
|
|
case SRV_IMAP:
|
|
GetServerProps(SERVER_IMAP, &pServerProps);
|
|
break;
|
|
|
|
case SRV_HTTPMAIL:
|
|
GetServerProps(SERVER_HTTPMAIL, &pServerProps);
|
|
break;
|
|
|
|
case SRV_NNTP:
|
|
GetServerProps(SERVER_NEWS, &pServerProps);
|
|
break;
|
|
|
|
case SRV_LDAP:
|
|
GetServerProps(SERVER_LDAP, &pServerProps);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
Assert(NULL != pServerProps);
|
|
|
|
// Record old SPA setting so we can tell if user went between cleartext/SPA (IMAP dirty)
|
|
pAcct->GetPropDw(pServerProps->useSicily, &fOldSicily);
|
|
|
|
pAcct->SetProp(pServerProps->userName, NULL, 0);
|
|
pAcct->SetProp(pServerProps->password, NULL, 0);
|
|
pAcct->SetProp(pServerProps->useSicily, NULL, 0);
|
|
if (0 != pServerProps->promptPassword)
|
|
pAcct->SetProp(pServerProps->promptPassword, NULL, 0);
|
|
|
|
if (fLogon)
|
|
{
|
|
// Get User Account Name
|
|
hwndT = GetDlgItem(hwnd, IDC_ACCTNAME_EDIT);
|
|
|
|
// For IMAP, set dirty flag if username changed or went from SPA to cleartext
|
|
if (fOldSicily || (SRV_IMAP == srv && SendMessage(hwndT, EM_GETMODIFY, 0, 0)))
|
|
fIMAPDirty = TRUE;
|
|
|
|
cbSize = GetWindowText(hwndT, sz, ARRAYSIZE(sz));
|
|
UlStripWhitespace(sz, TRUE, TRUE, &cbSize);
|
|
pAcct->SetPropSz(pServerProps->userName, sz);
|
|
|
|
// Get Password if user didn't tell us to always prompt for it
|
|
if (0 != pServerProps->promptPassword)
|
|
{
|
|
dw = !IsDlgButtonChecked(hwnd, IDC_REMEMBER_PASSWORD);
|
|
pAcct->SetPropDw(pServerProps->promptPassword, dw);
|
|
}
|
|
else
|
|
// There is no LDAP setting to always prompt for password
|
|
dw = FALSE;
|
|
|
|
if (FALSE == dw)
|
|
{
|
|
cbSize = GetDlgItemText(hwnd, IDC_ACCTPASS_EDIT, sz, ARRAYSIZE(sz));
|
|
if (cbSize > 0)
|
|
pAcct->SetPropSz(pServerProps->password, sz);
|
|
}
|
|
|
|
if (!IsDlgButtonChecked(hwnd, IDC_LOGONSSPI_CHECK))
|
|
{
|
|
dw = LDAP_AUTH_PASSWORD;
|
|
}
|
|
|
|
else
|
|
{
|
|
if (srv != SRV_LDAP)
|
|
pAcct->SetPropDw(pServerProps->useSicily, TRUE);
|
|
|
|
// For IMAP, set dirty flag if we went from cleartext to SPA
|
|
if (FALSE == fOldSicily)
|
|
fIMAPDirty = TRUE;
|
|
|
|
dw = LDAP_AUTH_MEMBER_SYSTEM;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dw = LDAP_AUTH_ANONYMOUS;
|
|
}
|
|
|
|
if (srv == SRV_LDAP)
|
|
pAcct->SetPropDw(pServerProps->useSicily, dw);
|
|
|
|
if (fIMAPDirty)
|
|
{
|
|
if (FAILED(pAcct->GetPropDw(AP_IMAP_DIRTY, &dw)))
|
|
dw = 0;
|
|
|
|
dw |= IMAP_FLDRLIST_DIRTY;
|
|
pAcct->SetPropDw(AP_IMAP_DIRTY, dw);
|
|
}
|
|
}
|
|
|
|
void Server_EnableLogonWindows(HWND hwnd, BOOL fEnable)
|
|
{
|
|
HWND hwndT;
|
|
BOOL fPromptPassword;
|
|
|
|
hwndT = GetDlgItem(hwnd, IDC_REMEMBER_PASSWORD);
|
|
if (hwndT != NULL)
|
|
{
|
|
fPromptPassword = (BST_CHECKED != SendMessage(hwndT, BM_GETCHECK, 0, 0));
|
|
EnableWindow(hwndT, fEnable);
|
|
}
|
|
else
|
|
{
|
|
fPromptPassword = FALSE;
|
|
}
|
|
|
|
EnableWindow(GetDlgItem(hwnd, IDC_LOGONSSPI_CHECK), fEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ACCTNAME_EDIT), fEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ACCTNAME_STATIC), fEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ACCTPASS_EDIT), fEnable && !fPromptPassword);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ACCTPASS_STATIC), fEnable);
|
|
}
|
|
|
|
const static HELPMAP g_rgCtxMapNewsSvr[] = {
|
|
{IDC_NEWSNAME_EDIT, IDH_NEWS_SERV_INCOMING},
|
|
{IDC_LOGON_CHECK, IDH_INETCOMM_SERVER_REQ_LOGON},
|
|
{IDC_ACCTNAME_EDIT, IDH_MAIL_SERV_POP3_ACCT},
|
|
{IDC_ACCTNAME_STATIC, IDH_MAIL_SERV_POP3_ACCT},
|
|
{IDC_ACCTPASS_EDIT, IDH_MAIL_SERV_PWORD},
|
|
{IDC_ACCTPASS_STATIC, IDH_MAIL_SERV_PWORD},
|
|
{IDC_LOGONSSPI_CHECK, IDH_MAIL_LOGON_USING_SICILY},
|
|
{IDC_REMEMBER_PASSWORD, 503},
|
|
{IDC_STATIC0, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC1, IDH_INETCOMM_GROUPBOX},
|
|
{0, 0}};
|
|
|
|
INT_PTR CALLBACK ServerProp_ServerDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
HRESULT hr;
|
|
int idsError;
|
|
WORD wNotifyCode, wID;
|
|
BOOL fRet, fLogon, fValid;
|
|
TCHAR sz[CCHMAX_ACCT_PROP_SZ];
|
|
CAccount *pAcct;
|
|
DWORD flag;
|
|
HWND hwndT;
|
|
ULONG cbSize;
|
|
NMHDR *pnmhdr;
|
|
|
|
fRet = TRUE;
|
|
pAcct = (CAccount *)GetWindowLongPtr(hwnd, DWLP_USER);
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
// Get the ServerParams and store them in our extra bytes
|
|
pAcct = (CAccount *)((PROPSHEETPAGE *) lParam)->lParam;
|
|
SetWindowLongPtr(hwnd, DWLP_USER, (LPARAM)pAcct);
|
|
|
|
InitAcctPropEdit(GetDlgItem(hwnd, IDC_NEWSNAME_EDIT), pAcct, AP_NNTP_SERVER, CCHMAX_SERVER_NAME - 1);
|
|
|
|
fLogon = FALSE;
|
|
|
|
if (SUCCEEDED(pAcct->GetPropDw(AP_NNTP_USE_SICILY, (LPDWORD)&flag)) && flag)
|
|
{
|
|
CheckDlgButton(hwnd, IDC_LOGONSSPI_CHECK, BST_CHECKED);
|
|
fLogon = TRUE;
|
|
}
|
|
|
|
if (SUCCEEDED(pAcct->GetPropSz(AP_NNTP_USERNAME, sz, ARRAYSIZE(sz))) && *sz != 0)
|
|
{
|
|
SetDlgItemText(hwnd, IDC_ACCTNAME_EDIT, sz);
|
|
|
|
if (SUCCEEDED(pAcct->GetPropSz(AP_NNTP_PASSWORD, sz, ARRAYSIZE(sz))))
|
|
SetDlgItemText(hwnd, IDC_ACCTPASS_EDIT, sz);
|
|
|
|
fLogon = TRUE;
|
|
}
|
|
|
|
if (FAILED(pAcct->GetPropDw(AP_NNTP_PROMPT_PASSWORD, &flag)))
|
|
flag = FALSE;
|
|
CheckDlgButton(hwnd, IDC_REMEMBER_PASSWORD, flag ? BST_UNCHECKED : BST_CHECKED);
|
|
|
|
hwndT = GetDlgItem(hwnd, IDC_ACCTNAME_EDIT);
|
|
SetIntlFont(hwndT);
|
|
SendMessage(hwndT, EM_LIMITTEXT, CCHMAX_USERNAME - 1, 0L);
|
|
|
|
SendDlgItemMessage(hwnd, IDC_ACCTPASS_EDIT, EM_LIMITTEXT, CCHMAX_PASSWORD - 1, 0L);
|
|
|
|
CheckDlgButton(hwnd, IDC_LOGON_CHECK, fLogon);
|
|
Server_EnableLogonWindows(hwnd, fLogon);
|
|
|
|
if (SUCCEEDED(pAcct->GetPropDw(AP_SERVER_READ_ONLY, &flag)) && flag)
|
|
EnableWindow(GetDlgItem(hwnd, IDC_NEWSNAME_EDIT), FALSE);
|
|
|
|
PropSheet_QuerySiblings(GetParent(hwnd), SM_INITIALIZED, PAGE_SERVER);
|
|
PropSheet_UnChanged(GetParent(hwnd), hwnd);
|
|
break;
|
|
|
|
case WM_HELP:
|
|
case WM_CONTEXTMENU:
|
|
return(OnContextHelp(hwnd, uMsg, wParam, lParam, g_rgCtxMapNewsSvr));
|
|
|
|
case WM_COMMAND:
|
|
wNotifyCode = HIWORD(wParam);
|
|
wID = LOWORD(wParam);
|
|
|
|
switch (wID)
|
|
{
|
|
case IDC_LOGON_CHECK:
|
|
case IDC_LOGONSSPI_CHECK:
|
|
Server_EnableLogonWindows(hwnd, IsDlgButtonChecked(hwnd, IDC_LOGON_CHECK));
|
|
|
|
MarkPageDirty(hwnd, PAGE_SERVER);
|
|
break;
|
|
|
|
case IDC_REMEMBER_PASSWORD:
|
|
flag = IsDlgButtonChecked(hwnd, IDC_REMEMBER_PASSWORD);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ACCTPASS_EDIT), flag);
|
|
MarkPageDirty(hwnd, PAGE_SERVER);
|
|
break;
|
|
|
|
default:
|
|
if (wNotifyCode == EN_CHANGE)
|
|
MarkPageDirty(hwnd, PAGE_SERVER);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case WM_NOTIFY:
|
|
pnmhdr = (NMHDR *)lParam;
|
|
switch (pnmhdr->code)
|
|
{
|
|
case PSN_APPLY:
|
|
// BEGIN validation
|
|
|
|
hwndT = GetDlgItem(hwnd, IDC_NEWSNAME_EDIT);
|
|
if (!ValidateServerName(hwnd, hwndT, pAcct, AP_NNTP_SERVER, &idsError, pnmhdr->code == PSN_APPLY))
|
|
return(InvalidAcctProp(hwnd, hwndT, idsError, iddServerProp_Server));
|
|
|
|
if (IsDlgButtonChecked(hwnd, IDC_LOGON_CHECK) &&
|
|
!ValidateLogonSettings(hwnd, pAcct->m_dwDlgFlags, &hwndT, &idsError))
|
|
return(InvalidAcctProp(hwnd, hwndT, idsError, iddServerProp_Server));
|
|
|
|
// END validation
|
|
|
|
hwndT = GetDlgItem(hwnd, IDC_NEWSNAME_EDIT);
|
|
GetServerName(hwndT, pAcct, AP_NNTP_SERVER);
|
|
|
|
GetLogonSettings(hwnd, pAcct, IsDlgButtonChecked(hwnd, IDC_LOGON_CHECK), SRV_NNTP);
|
|
|
|
PropSheet_UnChanged(GetParent(hwnd), hwnd);
|
|
flag = PAGE_SERVER;
|
|
PropSheet_QuerySiblings(GetParent(hwnd), SM_SAVECHANGES, (LPARAM)&flag);
|
|
if (flag == -1)
|
|
{
|
|
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
|
|
return(TRUE);
|
|
}
|
|
break;
|
|
}
|
|
return(TRUE);
|
|
|
|
default:
|
|
fRet = FALSE;
|
|
break;
|
|
}
|
|
|
|
return(fRet);
|
|
}
|
|
|
|
BOOL ValidateAccountName(HWND hwnd, HWND hwndT, IImnAccount *pAcct, int *pidsError)
|
|
{
|
|
ULONG cbSize;
|
|
TCHAR szAccount[CCHMAX_ACCOUNT_NAME], szAcctOld[CCHMAX_ACCOUNT_NAME];
|
|
IImnAccount *pAcctT;
|
|
|
|
Assert(IsWindow(hwndT));
|
|
Assert(pAcct != NULL);
|
|
Assert(pidsError != NULL);
|
|
|
|
*pidsError = 0;
|
|
|
|
cbSize = GetWindowText(hwndT, szAccount, ARRAYSIZE(szAccount));
|
|
if (cbSize == 0)
|
|
{
|
|
*pidsError = idsInvalidAccountName;
|
|
return(FALSE);
|
|
}
|
|
|
|
if (0 == SendMessage(hwndT, EM_GETMODIFY, 0, 0))
|
|
return(TRUE);
|
|
|
|
if (FAILED(pAcct->ValidateProperty(AP_ACCOUNT_NAME, (LPBYTE)szAccount, 0)))
|
|
{
|
|
*pidsError = idsInvalidAccountName;
|
|
return(FALSE);
|
|
}
|
|
|
|
*szAcctOld = 0;
|
|
pAcct->GetPropSz(AP_ACCOUNT_NAME, szAcctOld, ARRAYSIZE(szAcctOld));
|
|
|
|
if (*szAcctOld == 0 || 0 != lstrcmpi(szAccount, szAcctOld))
|
|
{
|
|
// if we're changing the name, then we need to make sure it's unique
|
|
if (SUCCEEDED(g_pAcctMan->FindAccount(AP_ACCOUNT_NAME, szAccount, &pAcctT)))
|
|
{
|
|
pAcctT->Release();
|
|
*pidsError = idsNeedUniqueAccountName;
|
|
return(FALSE);
|
|
}
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
void GetAccountName(HWND hwndEdit, IImnAccount *pAcct)
|
|
{
|
|
UINT cbSize;
|
|
TCHAR szAccount[CCHMAX_ACCOUNT_NAME];
|
|
|
|
Assert(IsWindow(hwndEdit));
|
|
|
|
if (0 != SendMessage(hwndEdit, EM_GETMODIFY, 0, 0))
|
|
{
|
|
cbSize = GetWindowText(hwndEdit, szAccount, ARRAYSIZE(szAccount));
|
|
Assert(cbSize > 0);
|
|
|
|
pAcct->SetPropSz(AP_ACCOUNT_NAME, szAccount);
|
|
|
|
SendMessage(hwndEdit, EM_SETMODIFY, 0, 0);
|
|
}
|
|
}
|
|
|
|
// TODO: move these to somewhere appropriate
|
|
#define TIMEOUT_SEC_MIN 30
|
|
#define TIMEOUT_SEC_MAX 5 * 60
|
|
#define TIMEOUT_DSEC 30
|
|
|
|
#define CTIMEOUT (((TIMEOUT_SEC_MAX - TIMEOUT_SEC_MIN) / TIMEOUT_DSEC) + 1)
|
|
|
|
void InitTimeoutSlider(HWND hwndSlider, HWND hwndText, DWORD dwTimeout)
|
|
{
|
|
DWORD dw;
|
|
|
|
if (dwTimeout < TIMEOUT_SEC_MIN)
|
|
dwTimeout = TIMEOUT_SEC_MIN;
|
|
else if (dwTimeout > TIMEOUT_SEC_MAX)
|
|
dwTimeout = TIMEOUT_SEC_MAX;
|
|
|
|
dw = (dwTimeout / TIMEOUT_DSEC) - 1;
|
|
|
|
SendMessage(hwndSlider, TBM_SETRANGE, 0, (LPARAM)MAKELONG(0, CTIMEOUT - 1));
|
|
SendMessage(hwndSlider, TBM_SETPOS, TRUE, (LPARAM)dw);
|
|
SetTimeoutString(hwndText, dw);
|
|
}
|
|
|
|
void SetTimeoutString(HWND hwnd, UINT pos)
|
|
{
|
|
UINT cch, csec, cmin;
|
|
TCHAR szOut[128], sz[128];
|
|
|
|
csec = TIMEOUT_SEC_MIN + (pos * TIMEOUT_DSEC);
|
|
Assert(csec >= TIMEOUT_SEC_MIN && csec <= TIMEOUT_SEC_MAX);
|
|
|
|
cmin = csec / 60;
|
|
csec = csec % 60;
|
|
if (cmin > 1)
|
|
{
|
|
LoadString(g_hInstRes, idsXMinutes, sz, ARRAYSIZE(sz));
|
|
wnsprintf(szOut, ARRAYSIZE(szOut), sz, cmin);
|
|
cch = lstrlen(szOut);
|
|
}
|
|
else if (cmin == 1)
|
|
{
|
|
cch = LoadString(g_hInstRes, ids1Minute, szOut, ARRAYSIZE(szOut));
|
|
}
|
|
else
|
|
{
|
|
cch = 0;
|
|
}
|
|
|
|
if (csec != 0)
|
|
{
|
|
if (cmin > 0)
|
|
{
|
|
szOut[cch] = ' ';
|
|
cch++;
|
|
}
|
|
|
|
LoadString(g_hInstRes, idsXSeconds, sz, ARRAYSIZE(sz));
|
|
wnsprintf(&szOut[cch], (ARRAYSIZE(szOut) - cch), sz, csec);
|
|
}
|
|
|
|
SetWindowText(hwnd, szOut);
|
|
}
|
|
|
|
DWORD GetTimeoutFromSlider(HWND hwnd)
|
|
{
|
|
DWORD dw;
|
|
|
|
dw = (DWORD) SendMessage(hwnd, TBM_GETPOS, 0, 0);
|
|
dw = TIMEOUT_SEC_MIN + (dw * TIMEOUT_DSEC);
|
|
|
|
return(dw);
|
|
}
|
|
|
|
const static HELPMAP g_rgCtxMapNewsAdv[] = {
|
|
{IDC_USEDEFAULTS_BUTTON, IDH_NEWS_SERV_ADV_USE_DEFAULTS},
|
|
{IDC_SECURECONNECT_BUTTON, IDH_MAIL_ADV_REQ_SSL},
|
|
{IDC_TIMEOUT_SLIDER, IDH_NEWS_SERV_ADV_TIMEOUT},
|
|
{IDC_TIMEOUT_STATIC, IDH_NEWS_SERV_ADV_TIMEOUT},
|
|
{IDC_USEDESC_CHECK, IDH_NEWS_SERV_ADV_DESC},
|
|
{IDC_SPLIT_CHECK, IDH_NEWSMAIL_SEND_ADVSET_BREAK_UP},
|
|
{IDC_SPLIT_EDIT, IDH_NEWSMAIL_SEND_ADVSET_BREAK_UP},
|
|
{IDC_SPLIT_SPIN, IDH_NEWSMAIL_SEND_ADVSET_BREAK_UP},
|
|
{IDC_SPLIT_STATIC, IDH_NEWSMAIL_SEND_ADVSET_BREAK_UP},
|
|
{IDC_NNTPPORT_EDIT, IDH_NEWS_PORT_NUMBER},
|
|
{IDC_FORMAT_CHECK, 691},
|
|
{IDC_HTML_RADIO, 692},
|
|
{IDC_TEXT_RADIO, 692},
|
|
{IDC_STATIC0, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC1, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC2, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC3, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC4, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC5, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC6, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC7, IDH_INETCOMM_GROUPBOX},
|
|
{0, 0}};
|
|
|
|
INT_PTR CALLBACK ServerProp_AdvancedDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
HWND hwndT;
|
|
NMHDR *pnmhdr;
|
|
DWORD dw, flag, dwPort, dwSplit;
|
|
WORD code;
|
|
BOOL fTrans, fSecure;
|
|
TCHAR szBuffer[CCHMAX_ACCOUNT_NAME];
|
|
CAccount *pAcct = (CAccount *)GetWindowLongPtr(hwnd, DWLP_USER);
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
// Get the ServerParams and store them in our extra bytes
|
|
pAcct = (CAccount *) ((PROPSHEETPAGE*) lParam)->lParam;
|
|
SetWindowLongPtr(hwnd, DWLP_USER, (LPARAM) pAcct);
|
|
|
|
// Load the controls with what information we have
|
|
if (SUCCEEDED(pAcct->GetPropDw(AP_NNTP_PORT, &dw)))
|
|
SetDlgItemInt(hwnd, IDC_NNTPPORT_EDIT, dw, FALSE);
|
|
SendDlgItemMessage(hwnd, IDC_NNTPPORT_EDIT, EM_LIMITTEXT, PORT_CCHMAX, 0);
|
|
if (SUCCEEDED(pAcct->GetPropDw(AP_NNTP_SSL, (LPDWORD) &fSecure)) && fSecure)
|
|
{
|
|
EnableWindow(GetDlgItem(hwnd, IDC_USEDEFAULTS_BUTTON), dw != DEF_SNNTPPORT);
|
|
CheckDlgButton(hwnd, IDC_SECURECONNECT_BUTTON, TRUE);
|
|
}
|
|
else
|
|
{
|
|
EnableWindow(GetDlgItem(hwnd, IDC_USEDEFAULTS_BUTTON), dw != DEF_NNTPPORT);
|
|
}
|
|
|
|
dw = 0;
|
|
pAcct->GetPropDw(AP_NNTP_TIMEOUT, &dw);
|
|
InitTimeoutSlider(GetDlgItem(hwnd, IDC_TIMEOUT_SLIDER),
|
|
GetDlgItem(hwnd, IDC_TIMEOUT_STATIC), dw);
|
|
|
|
if (SUCCEEDED(pAcct->GetPropDw(AP_NNTP_USE_DESCRIPTIONS, &dw)))
|
|
CheckDlgButton(hwnd, IDC_USEDESC_CHECK, dw);
|
|
|
|
if (!!(pAcct->m_dwDlgFlags & ACCTDLG_NO_BREAKMESSAGES))
|
|
{
|
|
ShowWindow(GetDlgItem(hwnd, IDC_SPLIT_CHECK), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hwnd, IDC_SPLIT_EDIT), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hwnd, IDC_SPLIT_SPIN), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hwnd, IDC_SPLIT_STATIC), SW_HIDE);
|
|
}
|
|
|
|
// Break Message Size
|
|
dw = OPTION_OFF; // default
|
|
if (SUCCEEDED(pAcct->GetPropDw(AP_NNTP_SPLIT_MESSAGES, (LPDWORD)&flag)) && flag)
|
|
pAcct->GetPropDw(AP_NNTP_SPLIT_SIZE, (LPDWORD)&dw);
|
|
InitCheckCounter(dw, hwnd, IDC_SPLIT_CHECK, IDC_SPLIT_EDIT, IDC_SPLIT_SPIN,
|
|
BREAKSIZE_MIN, BREAKSIZE_MAX, DEF_BREAKSIZE);
|
|
|
|
pAcct->GetPropDw(AP_NNTP_POST_FORMAT, &flag);
|
|
CheckDlgButton(hwnd, IDC_FORMAT_CHECK, flag != POST_USE_DEFAULT);
|
|
CheckDlgButton(hwnd, flag == POST_USE_HTML ? IDC_HTML_RADIO : IDC_TEXT_RADIO, TRUE);
|
|
if (flag == POST_USE_DEFAULT)
|
|
{
|
|
EnableWindow(GetDlgItem(hwnd, IDC_HTML_RADIO), FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_TEXT_RADIO), FALSE);
|
|
}
|
|
|
|
PropSheet_QuerySiblings(GetParent(hwnd), SM_INITIALIZED, PAGE_ADV);
|
|
PropSheet_UnChanged(GetParent(hwnd), hwnd);
|
|
return (TRUE);
|
|
|
|
case WM_HELP:
|
|
case WM_CONTEXTMENU:
|
|
return(OnContextHelp(hwnd, uMsg, wParam, lParam, g_rgCtxMapNewsAdv));
|
|
|
|
case WM_HSCROLL:
|
|
// Update the text beside the slider
|
|
SetTimeoutString(GetDlgItem(hwnd, IDC_TIMEOUT_STATIC),
|
|
(UINT) SendMessage((HWND) lParam, TBM_GETPOS, 0, 0));
|
|
|
|
MarkPageDirty(hwnd, PAGE_ADV);
|
|
return (TRUE);
|
|
|
|
case WM_COMMAND:
|
|
// Any change to the edit controls would cause the "Apply" button
|
|
// to enable.
|
|
fSecure = IsDlgButtonChecked(hwnd, IDC_SECURECONNECT_BUTTON);
|
|
code = HIWORD(wParam);
|
|
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDC_NNTPPORT_EDIT:
|
|
if (code == EN_CHANGE)
|
|
{
|
|
dw = GetDlgItemInt(hwnd, IDC_NNTPPORT_EDIT, &fTrans, FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_USEDEFAULTS_BUTTON),
|
|
!fTrans || (fSecure ? (dw != DEF_SNNTPPORT) : (dw != DEF_NNTPPORT)));
|
|
|
|
MarkPageDirty(hwnd, PAGE_ADV);
|
|
}
|
|
break;
|
|
|
|
case IDC_USEDESC_CHECK:
|
|
case IDC_TEXT_RADIO:
|
|
case IDC_HTML_RADIO:
|
|
MarkPageDirty(hwnd, PAGE_ADV);
|
|
break;
|
|
|
|
case IDC_SPLIT_EDIT:
|
|
if (code == EN_CHANGE)
|
|
MarkPageDirty(hwnd, PAGE_ADV);
|
|
break;
|
|
|
|
case IDC_FORMAT_CHECK:
|
|
fTrans = IsDlgButtonChecked(hwnd, IDC_FORMAT_CHECK);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_HTML_RADIO), fTrans);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_TEXT_RADIO), fTrans);
|
|
|
|
MarkPageDirty(hwnd, PAGE_ADV);
|
|
break;
|
|
|
|
case IDC_SPLIT_CHECK:
|
|
fTrans = IsDlgButtonChecked(hwnd, IDC_SPLIT_CHECK);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_SPLIT_EDIT), fTrans);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_SPLIT_SPIN), fTrans);
|
|
|
|
MarkPageDirty(hwnd, PAGE_ADV);
|
|
break;
|
|
|
|
case IDC_SECURECONNECT_BUTTON:
|
|
case IDC_USEDEFAULTS_BUTTON:
|
|
// Reset the settings on this page to the default values.
|
|
SetDlgItemInt(hwnd, IDC_NNTPPORT_EDIT, fSecure ? DEF_SNNTPPORT : DEF_NNTPPORT, FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_USEDEFAULTS_BUTTON), FALSE);
|
|
|
|
MarkPageDirty(hwnd, PAGE_ADV);
|
|
|
|
SetFocus(GetDlgItem(hwnd, IDC_NNTPPORT_EDIT));
|
|
break;
|
|
}
|
|
return (TRUE);
|
|
|
|
case WM_NOTIFY:
|
|
pnmhdr = (NMHDR *)lParam;
|
|
switch (pnmhdr->code)
|
|
{
|
|
case PSN_APPLY:
|
|
// BEGIN validation
|
|
|
|
dwPort = GetDlgItemInt(hwnd, IDC_NNTPPORT_EDIT, &fTrans, FALSE);
|
|
if (!fTrans || dwPort == 0)
|
|
{
|
|
hwndT = GetDlgItem(hwnd, IDC_NNTPPORT_EDIT);
|
|
return(InvalidAcctProp(hwnd, hwndT, idsErrPortNum, iddServerProp_Advanced));
|
|
}
|
|
|
|
dwSplit = 0;
|
|
dw = IsDlgButtonChecked(hwnd, IDC_SPLIT_CHECK);
|
|
if (dw != 0)
|
|
{
|
|
dwSplit = GetDlgItemInt(hwnd, IDC_SPLIT_EDIT, &fTrans, FALSE);
|
|
if (!fTrans || dwSplit < BREAKSIZE_MIN || dwSplit > BREAKSIZE_MAX)
|
|
{
|
|
hwndT = GetDlgItem(hwnd, IDC_SPLIT_EDIT);
|
|
return(InvalidAcctProp(hwnd, hwndT, idsEnterBreakSize, iddServerProp_Advanced));
|
|
}
|
|
}
|
|
|
|
// END validation
|
|
|
|
pAcct->SetPropDw(AP_NNTP_PORT, dwPort);
|
|
|
|
dw = IsDlgButtonChecked(hwnd, IDC_SPLIT_CHECK);
|
|
pAcct->SetPropDw(AP_NNTP_SPLIT_MESSAGES, dw);
|
|
if (dw != 0)
|
|
{
|
|
Assert(dwSplit != 0);
|
|
pAcct->SetPropDw(AP_NNTP_SPLIT_SIZE, dwSplit);
|
|
}
|
|
|
|
dw = GetTimeoutFromSlider(GetDlgItem(hwnd, IDC_TIMEOUT_SLIDER));
|
|
pAcct->SetPropDw(AP_NNTP_TIMEOUT, dw);
|
|
|
|
dw = IsDlgButtonChecked(hwnd, IDC_USEDESC_CHECK);
|
|
pAcct->SetPropDw(AP_NNTP_USE_DESCRIPTIONS, dw);
|
|
|
|
dw = IsDlgButtonChecked(hwnd, IDC_SECURECONNECT_BUTTON);
|
|
pAcct->SetPropDw(AP_NNTP_SSL, dw);
|
|
|
|
dw = POST_USE_DEFAULT;
|
|
if (IsDlgButtonChecked(hwnd, IDC_FORMAT_CHECK))
|
|
{
|
|
if (IsDlgButtonChecked(hwnd, IDC_HTML_RADIO))
|
|
dw = POST_USE_HTML;
|
|
else
|
|
dw = POST_USE_PLAIN_TEXT;
|
|
}
|
|
pAcct->SetPropDw(AP_NNTP_POST_FORMAT, dw);
|
|
|
|
PropSheet_UnChanged(GetParent(hwnd), hwnd);
|
|
dw = PAGE_ADV;
|
|
PropSheet_QuerySiblings(GetParent(hwnd), SM_SAVECHANGES, (LPARAM)&dw);
|
|
if (dw == -1)
|
|
{
|
|
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
|
|
return(TRUE);
|
|
}
|
|
break;
|
|
}
|
|
return (TRUE);
|
|
}
|
|
|
|
return (FALSE);
|
|
}
|
|
|
|
void InitUserInformation(HWND hwnd, IImnAccount *pAcct, BOOL fNews)
|
|
{
|
|
TCHAR sz[CCHMAX_ACCT_PROP_SZ];
|
|
IImnAccount *pAccount;
|
|
DWORD dwProp;
|
|
HWND hwndT;
|
|
|
|
Assert(pAcct != NULL);
|
|
|
|
pAccount = NULL;
|
|
|
|
Assert(g_pAcctMan);
|
|
g_pAcctMan->GetDefaultAccount(fNews ? ACCT_NEWS : ACCT_MAIL, &pAccount);
|
|
|
|
// Get Display Name
|
|
hwndT = GetDlgItem(hwnd, IDE_DISPLAY_NAME);
|
|
SetIntlFont(hwndT);
|
|
dwProp = fNews ? AP_NNTP_DISPLAY_NAME : AP_SMTP_DISPLAY_NAME;
|
|
if (SUCCEEDED(pAcct->GetPropSz(dwProp, sz, ARRAYSIZE(sz))) ||
|
|
(pAccount != NULL && SUCCEEDED(pAccount->GetPropSz(dwProp, sz, ARRAYSIZE(sz)))))
|
|
{
|
|
SetWindowText(hwndT, sz);
|
|
}
|
|
SendMessage(hwndT, EM_LIMITTEXT, CCHMAX_DISPLAY_NAME - 1, 0L);
|
|
|
|
// Org Name
|
|
InitAcctPropEdit(GetDlgItem(hwnd, IDE_ORG_NAME), pAcct,
|
|
fNews ? AP_NNTP_ORG_NAME : AP_SMTP_ORG_NAME, CCHMAX_ORG_NAME - 1);
|
|
|
|
// Sender Email
|
|
hwndT = GetDlgItem(hwnd, IDE_EMAIL_ADDRESS);
|
|
SetIntlFont(hwndT);
|
|
dwProp = fNews ? AP_NNTP_EMAIL_ADDRESS : AP_SMTP_EMAIL_ADDRESS;
|
|
if (SUCCEEDED(pAcct->GetPropSz(dwProp, sz, ARRAYSIZE(sz))) ||
|
|
(pAccount != NULL && SUCCEEDED(pAccount->GetPropSz(dwProp, sz, ARRAYSIZE(sz)))))
|
|
{
|
|
SetWindowText(hwndT, sz);
|
|
}
|
|
SendMessage(hwndT, EM_LIMITTEXT, CCHMAX_EMAIL_ADDRESS - 1, 0L);
|
|
|
|
// Sender Reply Address
|
|
InitAcctPropEdit(GetDlgItem(hwnd, IDE_REPLYTO_EMAIL_ADDRESS), pAcct,
|
|
fNews ? AP_NNTP_REPLY_EMAIL_ADDRESS : AP_SMTP_REPLY_EMAIL_ADDRESS, CCHMAX_EMAIL_ADDRESS - 1);
|
|
|
|
if (pAccount != NULL)
|
|
pAccount->Release();
|
|
}
|
|
|
|
BOOL ValidateUserInformation(HWND hwnd, IImnAccount *pAcct, BOOL fNews, HWND *phwndErr, int *puIdsErr, BOOL fApply)
|
|
{
|
|
HRESULT hr;
|
|
TCHAR sz[CCHMAX_ACCT_PROP_SZ];
|
|
DWORD cbSize;
|
|
HWND hwndT;
|
|
|
|
*phwndErr = NULL;
|
|
*puIdsErr = 0;
|
|
|
|
// Display Name
|
|
hwndT = GetDlgItem(hwnd, IDE_DISPLAY_NAME);
|
|
cbSize = GetWindowText(hwndT, sz, ARRAYSIZE(sz));
|
|
UlStripWhitespace(sz, FALSE, TRUE, &cbSize);
|
|
if (cbSize == 0)
|
|
{
|
|
*phwndErr = hwndT;
|
|
*puIdsErr = idsEnterDisplayName;
|
|
return(FALSE);
|
|
}
|
|
|
|
// Email Address
|
|
hwndT = GetDlgItem(hwnd, IDE_EMAIL_ADDRESS);
|
|
cbSize = GetWindowText(hwndT, sz, ARRAYSIZE(sz));
|
|
UlStripWhitespace(sz, TRUE, TRUE, &cbSize);
|
|
if (cbSize == 0)
|
|
{
|
|
*phwndErr = hwndT;
|
|
*puIdsErr = idsEnterEmailAddress;
|
|
return(FALSE);
|
|
}
|
|
if (0 != SendMessage(hwndT, EM_GETMODIFY, 0, 0))
|
|
{
|
|
hr = pAcct->ValidateProperty(fNews ? AP_NNTP_EMAIL_ADDRESS : AP_SMTP_EMAIL_ADDRESS, (LPBYTE)sz, 0);
|
|
if (hr != S_OK && fApply)
|
|
{
|
|
if (IDNO == AcctMessageBox(hwnd, MAKEINTRESOURCE(idsAccountManager), MAKEINTRESOURCE(idsInvalidEmailAddress), NULL, MB_YESNO|MB_ICONEXCLAMATION |MB_DEFBUTTON2))
|
|
{
|
|
*phwndErr = hwndT;
|
|
return(FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Reply Toaddress
|
|
hwndT = GetDlgItem(hwnd, IDE_REPLYTO_EMAIL_ADDRESS);
|
|
if (0 != SendMessage(hwndT, EM_GETMODIFY, 0, 0))
|
|
{
|
|
cbSize = GetWindowText(hwndT, sz, ARRAYSIZE(sz));
|
|
UlStripWhitespace(sz, TRUE, TRUE, &cbSize);
|
|
if (cbSize > 0)
|
|
{
|
|
hr = pAcct->ValidateProperty(fNews ? AP_NNTP_REPLY_EMAIL_ADDRESS : AP_SMTP_REPLY_EMAIL_ADDRESS, (LPBYTE)sz, 0);
|
|
if (hr != S_OK && fApply)
|
|
{
|
|
if (IDNO == AcctMessageBox(hwnd, MAKEINTRESOURCE(idsAccountManager), MAKEINTRESOURCE(idsInvalidReplyToAddress), NULL, MB_YESNO|MB_ICONEXCLAMATION |MB_DEFBUTTON2))
|
|
{
|
|
*phwndErr = hwndT;
|
|
return(FALSE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
void GetUserInformation(HWND hwnd, IImnAccount *pAcct, BOOL fNews)
|
|
{
|
|
DWORD cbSize;
|
|
HWND hwndT;
|
|
TCHAR sz[CCHMAX_ACCT_PROP_SZ];
|
|
|
|
// Display Name
|
|
hwndT = GetDlgItem(hwnd, IDE_DISPLAY_NAME);
|
|
if (0 != SendMessage(hwndT, EM_GETMODIFY, 0, 0))
|
|
{
|
|
cbSize = GetWindowText(hwndT, sz, ARRAYSIZE(sz));
|
|
UlStripWhitespace(sz, FALSE, TRUE, &cbSize);
|
|
Assert(cbSize > 0);
|
|
Assert(!FIsEmpty(sz));
|
|
pAcct->SetPropSz(fNews ? AP_NNTP_DISPLAY_NAME : AP_SMTP_DISPLAY_NAME, sz);
|
|
|
|
SendMessage(hwndT, EM_SETMODIFY, 0, 0);
|
|
}
|
|
|
|
// Organization
|
|
hwndT = GetDlgItem(hwnd, IDE_ORG_NAME);
|
|
if (0 != SendMessage(hwndT, EM_GETMODIFY, 0, 0))
|
|
{
|
|
cbSize = GetWindowText(hwndT, sz, ARRAYSIZE(sz));
|
|
UlStripWhitespace(sz, FALSE, TRUE, &cbSize);
|
|
if (cbSize == 0)
|
|
pAcct->SetProp(fNews ? AP_NNTP_ORG_NAME : AP_SMTP_ORG_NAME, NULL, 0);
|
|
else
|
|
pAcct->SetPropSz(fNews ? AP_NNTP_ORG_NAME : AP_SMTP_ORG_NAME, sz);
|
|
|
|
SendMessage(hwndT, EM_SETMODIFY, 0, 0);
|
|
}
|
|
|
|
// Email Address
|
|
hwndT = GetDlgItem(hwnd, IDE_EMAIL_ADDRESS);
|
|
if (0 != SendMessage(hwndT, EM_GETMODIFY, 0, 0))
|
|
{
|
|
cbSize = GetWindowText(hwndT, sz, ARRAYSIZE(sz));
|
|
UlStripWhitespace(sz, TRUE, TRUE, &cbSize);
|
|
Assert(cbSize > 0);
|
|
pAcct->SetPropSz(fNews ? AP_NNTP_EMAIL_ADDRESS : AP_SMTP_EMAIL_ADDRESS, sz);
|
|
|
|
SendMessage(hwndT, EM_SETMODIFY, 0, 0);
|
|
}
|
|
|
|
// Reply Toaddress
|
|
hwndT = GetDlgItem(hwnd, IDE_REPLYTO_EMAIL_ADDRESS);
|
|
if (0 != SendMessage(hwndT, EM_GETMODIFY, 0, 0))
|
|
{
|
|
cbSize = GetWindowText(hwndT, sz, ARRAYSIZE(sz));
|
|
UlStripWhitespace(sz, TRUE, TRUE, &cbSize);
|
|
if (cbSize == 0)
|
|
pAcct->SetProp(fNews ? AP_NNTP_REPLY_EMAIL_ADDRESS : AP_SMTP_REPLY_EMAIL_ADDRESS, NULL, 0);
|
|
else
|
|
pAcct->SetPropSz(fNews ? AP_NNTP_REPLY_EMAIL_ADDRESS : AP_SMTP_REPLY_EMAIL_ADDRESS, sz);
|
|
|
|
SendMessage(hwndT, EM_SETMODIFY, 0, 0);
|
|
}
|
|
}
|
|
|
|
void EnableCertControls(HWND hwnd)
|
|
{
|
|
EnableWindow(GetDlgItem(hwnd, idcCertButton), TRUE);
|
|
EnableWindow(GetDlgItem(hwnd, idcCertEdit), TRUE);
|
|
EnableWindow(GetDlgItem(hwnd, idcCryptEdit), TRUE);
|
|
EnableWindow(GetDlgItem(hwnd, idcCryptButton), TRUE);
|
|
}
|
|
|
|
BOOL ValidateCertificate(HWND hwnd, IImnAccount *pAcct, SECPAGEINFO *psdi, HWND *phwndErr, int *puIdsErr)
|
|
{
|
|
UINT cbSize;
|
|
BOOL fRet = TRUE;
|
|
TCHAR sz[CCHMAX_ACCT_PROP_SZ];
|
|
LPSTR szCertEmail = NULL;
|
|
|
|
*puIdsErr = 0;
|
|
*phwndErr = NULL;
|
|
cbSize = GetWindowTextLength(GetDlgItem(hwnd, idcCertEdit));
|
|
if (cbSize)
|
|
{
|
|
GetDlgItemText(hwnd, idcCertAddress, sz, ARRAYSIZE(sz));
|
|
Assert(psdi->pCert);
|
|
szCertEmail = SzGetCertificateEmailAddress(psdi->pCert);
|
|
if (!szCertEmail || lstrcmpi(szCertEmail, sz))
|
|
goto ErrExit;
|
|
}
|
|
// More checkings for 2 keys
|
|
|
|
if(!(psdi->pCert))
|
|
{
|
|
*puIdsErr = 0;
|
|
return FALSE;
|
|
}
|
|
|
|
// Check that signing certificate is really signing certificate
|
|
if(CheckKeyUsage(psdi->pCert, CERT_DIGITAL_SIGNATURE_KEY_USAGE) < 0)
|
|
goto ErrExit;
|
|
|
|
// Check email name in encryption certificate
|
|
if(szCertEmail)
|
|
{
|
|
MemFree(szCertEmail);
|
|
szCertEmail = NULL;
|
|
}
|
|
|
|
if(psdi->pEncryptCert)
|
|
{
|
|
szCertEmail = SzGetCertificateEmailAddress(psdi->pEncryptCert);
|
|
if (!szCertEmail || lstrcmpi(szCertEmail, sz))
|
|
goto ErrExit;
|
|
|
|
// Check that encryption certificate is really encryption certificate
|
|
if(CheckKeyUsage(psdi->pEncryptCert, CERT_KEY_ENCIPHERMENT_KEY_USAGE) < 0)
|
|
{
|
|
if(CheckKeyUsage(psdi->pEncryptCert, CERT_KEY_AGREEMENT_KEY_USAGE) < 1)
|
|
goto ErrExit;
|
|
}
|
|
}
|
|
if(szCertEmail)
|
|
MemFree(szCertEmail);
|
|
return fRet;
|
|
ErrExit:
|
|
// the certificate's email address does not match the
|
|
// current choice for the account
|
|
*puIdsErr = idsBadCertChoice;
|
|
*phwndErr = GetDlgItem(hwnd, idcCertButton);
|
|
if(szCertEmail)
|
|
MemFree(szCertEmail);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void GetCertificate(HWND hwnd, IImnAccount *pAcct, SECPAGEINFO *psdi)
|
|
{
|
|
THUMBBLOB tb = {0,0};
|
|
|
|
if(psdi->pCert)
|
|
{
|
|
tb.pBlobData =(BYTE *)PVGetCertificateParam(psdi->pCert, CERT_HASH_PROP_ID, &tb.cbSize);
|
|
}
|
|
|
|
pAcct->SetProp(AP_SMTP_CERTIFICATE, tb.pBlobData, tb.cbSize);
|
|
|
|
THUMBBLOB tbEncrypt = {0,0};
|
|
if(psdi->pEncryptCert)
|
|
{
|
|
tbEncrypt.pBlobData =(BYTE *)PVGetCertificateParam(psdi->pEncryptCert, CERT_HASH_PROP_ID, &tbEncrypt.cbSize);
|
|
AdvSec_GetEncryptAlgCombo(hwnd, pAcct);
|
|
}
|
|
pAcct->SetProp(AP_SMTP_ENCRYPT_CERT, tbEncrypt.pBlobData, tbEncrypt.cbSize);
|
|
|
|
return;
|
|
}
|
|
|
|
/* InitCertificateData:
|
|
**
|
|
** Purpose:
|
|
** determine if the account has a cert set on it and also initialize
|
|
** the SVRDLGINFO.
|
|
** Takes:
|
|
** [in/out] psdi - the hCertStore and pCert fields will be updated
|
|
** [in] pAcct - account to check for currently selected cert
|
|
** Returns:
|
|
** DWORD(-1) - there was an error. don't ever enable any UI
|
|
** 0 - no cert on the account, but no error
|
|
** 1 - cert set on account and placed in psdi->pCert
|
|
*/
|
|
DWORD InitCertificateData(TCHAR * szEmail, SECPAGEINFO *psdi, IImnAccount *pAcct)
|
|
{
|
|
THUMBBLOB tb;
|
|
DWORD dwRet = DWORD(-1);
|
|
|
|
Assert(psdi && pAcct);
|
|
|
|
if(!psdi->hCertStore)
|
|
psdi->hCertStore = CertOpenStore(CERT_STORE_PROV_SYSTEM_A,
|
|
X509_ASN_ENCODING, NULL, CERT_SYSTEM_STORE_CURRENT_USER, "My");
|
|
if (psdi->hCertStore)
|
|
{
|
|
dwRet = 0;
|
|
if (SUCCEEDED(pAcct->GetProp(AP_SMTP_CERTIFICATE, NULL, &tb.cbSize)))
|
|
{
|
|
if (MemAlloc((void**)&tb.pBlobData, tb.cbSize))
|
|
{
|
|
if (SUCCEEDED(pAcct->GetProp(AP_SMTP_CERTIFICATE, tb.pBlobData, &tb.cbSize)))
|
|
{
|
|
psdi->pCert = CertFindCertificateInStore(
|
|
psdi->hCertStore,
|
|
X509_ASN_ENCODING,
|
|
0,
|
|
CERT_FIND_HASH,
|
|
(void *)(CRYPT_DIGEST_BLOB *)&tb,
|
|
NULL);
|
|
if (psdi->pCert)
|
|
{
|
|
// Double check, we must be sure that certificate is OK
|
|
ACCTFILTERINFO FilterInfo;
|
|
|
|
FilterInfo.fEncryption = FALSE;
|
|
FilterInfo.dwFlags = CRYPTDLG_REVOCATION_NONE; // No revocation checking
|
|
FilterInfo.szEmail = szEmail;
|
|
|
|
if(CertFilterFunction(psdi->pCert, (LPARAM)(&FilterInfo), 0, 0))
|
|
{
|
|
dwRet = 1;
|
|
}
|
|
else
|
|
{
|
|
CertFreeCertificateContext(psdi->pCert);
|
|
psdi->pCert = NULL;
|
|
// remove wrong certificate from property
|
|
pAcct->SetProp(AP_SMTP_CERTIFICATE, NULL, 0);
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
MemFree(tb.pBlobData);
|
|
}
|
|
else if(psdi->pEncryptCert)
|
|
{
|
|
if(CheckKeyUsage(psdi->pEncryptCert, CERT_DIGITAL_SIGNATURE_KEY_USAGE) >= 0)
|
|
{
|
|
psdi->pCert = CertDuplicateCertificateContext(psdi->pEncryptCert);
|
|
dwRet = 1;
|
|
}
|
|
|
|
}
|
|
}
|
|
return dwRet;
|
|
}
|
|
|
|
/* InitEncryptData
|
|
**
|
|
** Purpose:
|
|
** determine if the account has a encryption cert set on it and also initialize
|
|
** the SVRDLGINFO.
|
|
** Takes:
|
|
** [in/out] psdi - the hCertStore and pCert fields will be updated
|
|
** [in] pAcct - account to check for currently selected cert
|
|
** Returns:
|
|
** DWORD(-1) - there was an error. don't ever enable any UI
|
|
** 0 - no cert on the account, but no error
|
|
** 1 - cert set on account and placed in psdi->pCert
|
|
*/
|
|
DWORD InitEncryptData(TCHAR *szEmail, SECPAGEINFO *psdi, IImnAccount *pAcct)
|
|
{
|
|
THUMBBLOB tb;
|
|
DWORD dwRet = DWORD(-1);
|
|
DWORD dwUsage = 0;
|
|
|
|
if(!psdi->hCertStore)
|
|
psdi->hCertStore = CertOpenStore(CERT_STORE_PROV_SYSTEM_A,
|
|
X509_ASN_ENCODING, NULL, CERT_SYSTEM_STORE_CURRENT_USER, "My");
|
|
if (psdi->hCertStore)
|
|
{
|
|
dwRet = 0;
|
|
if (SUCCEEDED(pAcct->GetProp(AP_SMTP_ENCRYPT_CERT, NULL, &tb.cbSize)))
|
|
{
|
|
if (MemAlloc((void**)&tb.pBlobData, tb.cbSize))
|
|
{
|
|
if (SUCCEEDED(pAcct->GetProp(AP_SMTP_ENCRYPT_CERT, tb.pBlobData, &tb.cbSize)))
|
|
{
|
|
psdi->pEncryptCert = CertFindCertificateInStore(
|
|
psdi->hCertStore,
|
|
X509_ASN_ENCODING,
|
|
0,
|
|
CERT_FIND_HASH,
|
|
(void *)(CRYPT_DIGEST_BLOB *)&tb,
|
|
NULL);
|
|
if (psdi->pEncryptCert)
|
|
{
|
|
// Double check, we must be sure that certificate is OK
|
|
ACCTFILTERINFO FilterInfo;
|
|
FilterInfo.fEncryption = TRUE;
|
|
FilterInfo.dwFlags = CRYPTDLG_REVOCATION_NONE; // no revocation checking
|
|
FilterInfo.szEmail = szEmail;
|
|
|
|
if(CertFilterFunction(psdi->pEncryptCert, (LPARAM)(&FilterInfo), 0, 0))
|
|
{
|
|
dwRet = 1;
|
|
}
|
|
else
|
|
{
|
|
CertFreeCertificateContext(psdi->pEncryptCert);
|
|
psdi->pEncryptCert = NULL;
|
|
// remove wrong certificate from property
|
|
pAcct->SetProp(AP_SMTP_ENCRYPT_CERT, NULL, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
MemFree(tb.pBlobData);
|
|
}
|
|
// if encryption certificate was not set
|
|
// check that current signing certificate can be used for encryption
|
|
else if(psdi->pCert)
|
|
{
|
|
if((CheckKeyUsage(psdi->pCert, CERT_KEY_ENCIPHERMENT_KEY_USAGE) >= 0) ||
|
|
(CheckKeyUsage(psdi->pCert, CERT_KEY_AGREEMENT_KEY_USAGE) > 0))
|
|
|
|
{
|
|
psdi->pEncryptCert = CertDuplicateCertificateContext(psdi->pCert);
|
|
dwRet = 1;
|
|
}
|
|
|
|
}
|
|
}
|
|
return dwRet;
|
|
|
|
}
|
|
|
|
// Check key usage field in certificate.
|
|
// Usage:
|
|
// CheckKeyUsage(PCCERT_CONTEXT pCert, DWORD dwFlag);
|
|
// where dwFlag is tested flaf of KeyUsage field
|
|
//
|
|
// Return
|
|
// 1 - flag is set
|
|
// 0 - key usage field not found in certificate
|
|
// -1 - flag is NOT set in key usage field.
|
|
int CheckKeyUsage(PCCERT_CONTEXT pCert, DWORD dwFlag)
|
|
{
|
|
DWORD dwUsage = 0;
|
|
HRESULT hr = S_OK;
|
|
|
|
hr = HrGetCertKeyUsage(pCert, &dwUsage);
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
if(dwUsage & dwFlag)
|
|
return(1);
|
|
else
|
|
return(-1);
|
|
}
|
|
else // Certificate doesn't have KeyUsage field (like VeriSign),
|
|
return(0);
|
|
}
|
|
BOOL DoCertDialog(HWND hwndOwner, HWND hwndEmail, PCCERT_CONTEXT *ppCert, HCERTSTORE hCertStore, int *puIdsErr, DWORD dwFlags, BOOL fEncription)
|
|
{
|
|
TCHAR szEmail[CCHMAX_ACCT_PROP_SZ];
|
|
TCHAR sz[CCHMAX_ACCT_PROP_SZ];
|
|
DWORD cchEmail;
|
|
CERT_SELECT_STRUCT css;
|
|
PCCERT_CONTEXT pCurCert;
|
|
BOOL fRet = FALSE;
|
|
ACCTFILTERINFO FilterInfo;
|
|
|
|
*puIdsErr = 0;
|
|
|
|
cchEmail = GetWindowText(hwndEmail, szEmail, ARRAYSIZE(szEmail));
|
|
if (cchEmail)
|
|
{
|
|
memset(&css, 0, sizeof(css));
|
|
|
|
pCurCert = CertDuplicateCertificateContext(*ppCert);
|
|
|
|
LoadString(g_hInstRes, idsSelectCertTitle, sz, ARRAYSIZE(sz));
|
|
|
|
css.dwSize = sizeof(css);
|
|
css.hwndParent = hwndOwner;
|
|
css.hInstance = g_hInstRes;
|
|
css.szTitle = sz;
|
|
css.dwFlags = dwFlags;
|
|
// hack
|
|
|
|
FilterInfo.fEncryption = fEncription;
|
|
FilterInfo.dwFlags = dwFlags;
|
|
FilterInfo.szEmail = szEmail;
|
|
css.lCustData = (LPARAM)(&FilterInfo);
|
|
css.arrayCertStore = &hCertStore;
|
|
css.cCertStore = 1;
|
|
css.szPurposeOid = szOID_PKIX_KP_EMAIL_PROTECTION;
|
|
css.arrayCertContext = ppCert;
|
|
css.cCertContext = 1;
|
|
#ifdef DEBUG
|
|
if (GetAsyncKeyState(VK_SHIFT) & 0x8000)
|
|
css.pfnFilter = NULL;
|
|
else
|
|
css.pfnFilter = CertFilterFunction;
|
|
#else
|
|
css.pfnFilter = CertFilterFunction;
|
|
#endif
|
|
|
|
if (CertSelectCertificate(&css) && (pCurCert != *ppCert))
|
|
{
|
|
fRet = TRUE;
|
|
}
|
|
CertFreeCertificateContext(pCurCert);
|
|
}
|
|
else
|
|
*puIdsErr = idsNeedEmailForCert;
|
|
|
|
return fRet;
|
|
}
|
|
|
|
#define FILETIME_SECOND 10000000 // 100ns intervals per second
|
|
#define TIME_DELTA_SECONDS 600 // 10 minutes in seconds
|
|
|
|
BOOL CertFilterFunction(PCCERT_CONTEXT pCertContext, LPARAM lParam, DWORD dwFlags, DWORD)
|
|
{
|
|
// return TRUE to show, FALSE to hide
|
|
BOOL fRet = FALSE;
|
|
FILETIME FileTime;
|
|
SYSTEMTIME SysTime;
|
|
ACCTFILTERINFO * pFilterInfo = (ACCTFILTERINFO *) lParam;
|
|
|
|
LONG lRet = 0;
|
|
|
|
PCCERT_CONTEXT *rgCertChain = NULL;
|
|
DWORD cCertChain = 0;
|
|
const DWORD dwIgnore = CERT_VALIDITY_NO_CRL_FOUND | CERT_VALIDITY_BEFORE_START |
|
|
CERT_VALIDITY_AFTER_END | CERT_VALIDITY_NO_TRUST_DATA;
|
|
|
|
LPSTR szCertEmail = SzGetCertificateEmailAddress(pCertContext);
|
|
|
|
GetSystemTime(&SysTime);
|
|
if(SystemTimeToFileTime(&SysTime, &FileTime))
|
|
{
|
|
lRet = CertVerifyTimeValidity(&FileTime, pCertContext->pCertInfo);
|
|
if(lRet < 0)
|
|
{
|
|
FILETIME ftNow;
|
|
__int64 i64Offset;
|
|
|
|
union
|
|
{
|
|
FILETIME ftDelta;
|
|
__int64 i64Delta;
|
|
};
|
|
|
|
GetSystemTimeAsFileTime(&ftNow);
|
|
|
|
i64Delta = ftNow.dwHighDateTime;
|
|
i64Delta = i64Delta << 32;
|
|
i64Delta += ftNow.dwLowDateTime;
|
|
|
|
// Add the offset into the original time to get us a new time to check
|
|
i64Offset = FILETIME_SECOND;
|
|
i64Offset *= TIME_DELTA_SECONDS;
|
|
i64Delta += i64Offset;
|
|
|
|
lRet = CertVerifyTimeValidity(&ftDelta, pCertContext->pCertInfo);
|
|
}
|
|
if(lRet != 0)
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
if (szCertEmail)
|
|
{
|
|
fRet = !(BOOL(lstrcmpi(szCertEmail, pFilterInfo->szEmail)));
|
|
|
|
MemFree(szCertEmail);
|
|
if(!fRet)
|
|
return(FALSE);
|
|
}
|
|
|
|
if(pFilterInfo->fEncryption)
|
|
{
|
|
if(CheckKeyUsage(pCertContext, CERT_KEY_ENCIPHERMENT_KEY_USAGE) < 0)
|
|
{
|
|
if(CheckKeyUsage(pCertContext, CERT_KEY_AGREEMENT_KEY_USAGE) < 1)
|
|
return(FALSE);
|
|
}
|
|
}
|
|
else {
|
|
if(CheckKeyUsage(pCertContext, CERT_DIGITAL_SIGNATURE_KEY_USAGE) < 0)
|
|
return(FALSE);
|
|
}
|
|
if(pFilterInfo->dwFlags) // if flags != 0 check certificate
|
|
{
|
|
DWORD dwErr = DwGenerateTrustedChain(NULL, pFilterInfo->dwFlags, pCertContext, dwIgnore, TRUE, &cCertChain, &rgCertChain);
|
|
|
|
if (rgCertChain)
|
|
{
|
|
for (cCertChain--; int(cCertChain) >= 0; cCertChain--)
|
|
CertFreeCertificateContext(rgCertChain[cCertChain]);
|
|
MemFree(rgCertChain);
|
|
}
|
|
|
|
if(dwErr != 0)
|
|
return(FALSE);
|
|
}
|
|
|
|
return(fRet);
|
|
}
|
|
|
|
static const TCHAR c_szOpen[] = TEXT("open");
|
|
static const TCHAR c_szIexplore[] = TEXT("iexplore.exe");
|
|
|
|
const static HELPMAP g_rgCtxMapMailSec[] =
|
|
{
|
|
{idcCertCheck, IDH_GENERAL_USE_CERTIFICATE},
|
|
{idcCertButton, IDH_GENERAL_SELECT_CERTIFICATE},
|
|
{IDC_GETCERT, IDH_INETCOM_GET_DIGITAL_ID},
|
|
{IDC_MOREINFO, IDH_INETCOM_MORE_ON_CERTIFICATES},
|
|
{idcCertEdit, IDH_SECURITY_SIGNING_CERT},
|
|
{idcCryptEdit, IDH_SECURITY_ENCRYPTING_CERT},
|
|
{idcCryptButton, IDH_SECURITY_SELECT_ENCRYPTCERT},
|
|
{IDC_ALGCOMBO, IDH_SECURITY_ADV_ENCRYPTION},
|
|
{IDC_STATIC0, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC1, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC2, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC3, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC4, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC5, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC6, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC7, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC8, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC10, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC11, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC12, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC13, IDH_INETCOMM_GROUPBOX},
|
|
|
|
{0, 0}
|
|
};
|
|
|
|
INT_PTR CALLBACK MailServer_SecurityDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
NMHDR *pnmhdr;
|
|
CAccount *pAcct;
|
|
TCHAR sz[CCHMAX_ACCT_PROP_SZ];
|
|
DWORD dw;
|
|
BOOL fRet;
|
|
int idsError;
|
|
HWND hwndT;
|
|
SECPAGEINFO *pcpi;
|
|
|
|
pAcct = (CAccount *)GetWindowLongPtr(hwnd, DWLP_USER);
|
|
pcpi = (SECPAGEINFO *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
// Get the ServerParams and store them in our extra bytes
|
|
pAcct = (CAccount *)((PROPSHEETPAGE *)lParam)->lParam;
|
|
SetWindowLongPtr(hwnd, DWLP_USER, (LPARAM) pAcct);
|
|
|
|
Assert(pcpi == NULL);
|
|
if (!MemAlloc((void **)&pcpi, sizeof(SECPAGEINFO)))
|
|
return(-1);
|
|
ZeroMemory(pcpi, sizeof(SECPAGEINFO));
|
|
|
|
hwndT = GetDlgItem(hwnd, idcCertEdit);
|
|
SetIntlFont(hwndT);
|
|
|
|
PropSheet_QuerySiblings(GetParent(hwnd), MSM_GETEMAILADDRESS, (LPARAM)sz);
|
|
SetDlgItemText(hwnd, idcCertAddress, sz);
|
|
|
|
dw = InitCertificateData(sz, pcpi, pAcct);
|
|
if (1 == dw)
|
|
{
|
|
Assert(pcpi->pCert);
|
|
if (GetFriendlyNameOfCert(pcpi->pCert, sz, ARRAYSIZE(sz)))
|
|
SendMessage(hwndT, WM_SETTEXT, 0, (LPARAM)(LPCTSTR)sz);
|
|
}
|
|
else if (-1 == dw)
|
|
{
|
|
EnableWindow(GetDlgItem(hwnd, idcCertCheck), FALSE);
|
|
}
|
|
|
|
GetDlgItemText(hwnd, idcCertAddress, sz, ARRAYSIZE(sz));
|
|
|
|
dw = InitEncryptData(sz, pcpi, pAcct);
|
|
if(dw == 1)
|
|
{
|
|
Assert(pcpi->pEncryptCert);
|
|
hwndT = GetDlgItem(hwnd, idcCryptEdit);
|
|
SetIntlFont(hwndT);
|
|
if (GetFriendlyNameOfCert(pcpi->pEncryptCert, sz, ARRAYSIZE(sz)))
|
|
SendMessage(hwndT, WM_SETTEXT, 0, (LPARAM)(LPCTSTR)sz);
|
|
}
|
|
|
|
// Always fill this combo
|
|
AdvSec_FillEncAlgCombo(hwnd, pAcct, (dw == 1) ? &pcpi->pEncryptCert : NULL );
|
|
|
|
SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)pcpi);
|
|
|
|
EnableCertControls(hwnd);
|
|
|
|
PropSheet_QuerySiblings(GetParent(hwnd), SM_INITIALIZED, PAGE_SEC);
|
|
PropSheet_UnChanged(GetParent(hwnd), hwnd);
|
|
return (TRUE);
|
|
|
|
case WM_DESTROY:
|
|
if (pcpi != NULL)
|
|
{
|
|
if (pcpi->pCert)
|
|
CertFreeCertificateContext(pcpi->pCert);
|
|
if (pcpi->pEncryptCert)
|
|
CertFreeCertificateContext(pcpi->pEncryptCert);
|
|
if (pcpi->hCertStore)
|
|
CertCloseStore(pcpi->hCertStore, 0);
|
|
MemFree(pcpi);
|
|
}
|
|
break;
|
|
|
|
case PSM_QUERYSIBLINGS:
|
|
if (wParam == MSM_GETCERTDATA)
|
|
{
|
|
if (IsDlgButtonChecked(hwnd, idcCertCheck))
|
|
{
|
|
((SECPAGEINFO *)lParam)->pCert = pcpi->pCert;
|
|
((SECPAGEINFO *)lParam)->hCertStore = pcpi->hCertStore;
|
|
}
|
|
return(TRUE);
|
|
}
|
|
break;
|
|
|
|
case WM_HELP:
|
|
case WM_CONTEXTMENU:
|
|
return(OnContextHelp(hwnd, uMsg, wParam, lParam, g_rgCtxMapMailSec));
|
|
|
|
case WM_COMMAND:
|
|
switch(LOWORD(wParam))
|
|
{
|
|
case IDC_ALGCOMBO:
|
|
if(GET_WM_COMMAND_CMD(wParam, lParam) == CBN_SELENDOK)
|
|
MarkPageDirty(hwnd, PAGE_SEC);
|
|
break;
|
|
|
|
case idcCertCheck:
|
|
EnableCertControls(hwnd);
|
|
|
|
MarkPageDirty(hwnd, PAGE_SEC);
|
|
break;
|
|
|
|
case idcCertButton:
|
|
hwndT = GetDlgItem(hwnd, idcCertAddress);
|
|
if (DoCertDialog(hwnd, hwndT, &pcpi->pCert, pcpi->hCertStore, &idsError,
|
|
((pAcct->m_dwDlgFlags & ACCTDLG_REVOCATION) ? CRYPTDLG_REVOCATION_ONLINE : CRYPTDLG_REVOCATION_NONE), FALSE))
|
|
{
|
|
if (GetFriendlyNameOfCert(pcpi->pCert, sz, ARRAYSIZE(sz)))
|
|
SetDlgItemText(hwnd, idcCertEdit, sz);
|
|
MarkPageDirty(hwnd, PAGE_SEC);
|
|
}
|
|
else if (idsError)
|
|
InvalidAcctProp(hwnd, hwndT, idsError, iddMailSvrProp_Security);
|
|
break;
|
|
|
|
case idcCryptButton:
|
|
hwndT = GetDlgItem(hwnd, idcCertAddress);
|
|
if (DoCertDialog(hwnd, hwndT, &pcpi->pEncryptCert, pcpi->hCertStore, &idsError,
|
|
((pAcct->m_dwDlgFlags & ACCTDLG_REVOCATION) ? CRYPTDLG_REVOCATION_ONLINE : CRYPTDLG_REVOCATION_NONE), TRUE))
|
|
{
|
|
if (GetFriendlyNameOfCert(pcpi->pEncryptCert, sz, ARRAYSIZE(sz)))
|
|
SetDlgItemText(hwnd, idcCryptEdit, sz);
|
|
MarkPageDirty(hwnd, PAGE_SEC);
|
|
}
|
|
else if (idsError)
|
|
InvalidAcctProp(hwnd, hwndT, idsError, iddMailSvrProp_Security);
|
|
|
|
EnableCertControls(hwnd);
|
|
|
|
break;
|
|
|
|
case IDC_GETCERT:
|
|
GetDigitalID(hwnd);
|
|
break;
|
|
|
|
case IDC_MOREINFO:
|
|
OEHtmlHelp(hwnd, "%SYSTEMROOT%\\help\\msoe.chm>large_context", HH_DISPLAY_TOPIC, (ULONG_PTR) (LPCSTR) "mail_overview_send_secure_messages.htm");
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case WM_NOTIFY:
|
|
pnmhdr = (NMHDR *)lParam;
|
|
switch (pnmhdr->code)
|
|
{
|
|
case PSN_SETACTIVE:
|
|
PropSheet_QuerySiblings(GetParent(hwnd), MSM_GETEMAILADDRESS, (LPARAM)sz);
|
|
SetDlgItemText(hwnd, idcCertAddress, sz);
|
|
break;
|
|
|
|
case PSN_APPLY:
|
|
// BEGIN validation
|
|
|
|
#ifdef DEBUG
|
|
if (!(GetAsyncKeyState(VK_SHIFT) & 0x8000))
|
|
{
|
|
#endif
|
|
fRet = ValidateCertificate(hwnd, pAcct, pcpi, &hwndT, &idsError);
|
|
if (!fRet)
|
|
{
|
|
if(idsError != 0)
|
|
return(InvalidAcctProp(hwnd, hwndT, idsError, iddMailSvrProp_Security));
|
|
else
|
|
return FALSE;
|
|
}
|
|
#ifdef DEBUG
|
|
}
|
|
#endif
|
|
|
|
// END validation
|
|
|
|
GetCertificate(hwnd, pAcct, pcpi);
|
|
|
|
PropSheet_UnChanged(GetParent(hwnd), hwnd);
|
|
dw = PAGE_SEC;
|
|
PropSheet_QuerySiblings(GetParent(hwnd), SM_SAVECHANGES, (LPARAM)&dw);
|
|
if (dw == -1)
|
|
{
|
|
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
|
|
return(TRUE);
|
|
}
|
|
break;
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
return (FALSE);
|
|
}
|
|
|
|
INT_PTR CALLBACK CertAddressErrorDlgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
HICON hicon;
|
|
BOOL fRet = TRUE;
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
hicon = LoadIcon(NULL, MAKEINTRESOURCE(IDI_EXCLAMATION));
|
|
if (hicon != NULL)
|
|
SendDlgItemMessage(hwnd, IDC_ERR_STATIC, STM_SETICON, (WPARAM)hicon, 0);
|
|
MessageBeep(MB_ICONEXCLAMATION);
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
if (HIWORD(wParam) == BN_CLICKED)
|
|
EndDialog(hwnd, LOWORD(wParam));
|
|
break;
|
|
|
|
default:
|
|
fRet = FALSE;
|
|
break;
|
|
}
|
|
|
|
return(fRet);
|
|
}
|
|
|
|
const static HELPMAP g_rgCtxMapMailGen[] = {
|
|
{IDC_SERVERNAME_EDIT, IDH_MAIL_ACCOUNT},
|
|
{IDE_DISPLAY_NAME, IDH_NEWS_SERV_NAME},
|
|
{IDE_ORG_NAME, IDH_NEWS_SERV_ORG},
|
|
{IDE_EMAIL_ADDRESS, IDH_NEWS_SERV_EMAIL_ADD},
|
|
{IDE_REPLYTO_EMAIL_ADDRESS, IDH_MAIL_SERV_ADV_REPLY_TO},
|
|
{IDC_RECVFULL_INCLUDE, IDH_INCLUDEACCT_IN_SENDREC},
|
|
{IDC_STATIC0, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC1, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC2, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC3, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC4, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC5, IDH_INETCOMM_GROUPBOX},
|
|
{0, 0}};
|
|
|
|
INT_PTR CALLBACK MailServer_GeneralDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
NMHDR *pnmhdr;
|
|
CAccount *pAcct;
|
|
TCHAR *pszEmail, sz[CCHMAX_ACCT_PROP_SZ];
|
|
DWORD dw;
|
|
BOOL fRet, fFree, fError;
|
|
SVRDLGINFO *psdi;
|
|
SECPAGEINFO cpi;
|
|
INT idsError;
|
|
HWND hwndT;
|
|
|
|
pAcct = (CAccount *)GetWindowLongPtr(hwnd, DWLP_USER);
|
|
psdi = (SVRDLGINFO *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
// Get the ServerParams and store them in our extra bytes
|
|
pAcct = (CAccount *)((PROPSHEETPAGE *)lParam)->lParam;
|
|
SetWindowLongPtr(hwnd, DWLP_USER, (LPARAM) pAcct);
|
|
|
|
Assert(psdi == NULL);
|
|
if (!MemAlloc((void **)&psdi, sizeof(SVRDLGINFO)))
|
|
return(-1);
|
|
ZeroMemory(psdi, sizeof(SVRDLGINFO));
|
|
|
|
// figure out if we're a mail or imap account
|
|
psdi->sfType = SERVER_MAIL; // mail will be default for now...
|
|
if (SUCCEEDED(pAcct->GetServerTypes(&dw)))
|
|
{
|
|
if (!!(dw & SRV_IMAP))
|
|
psdi->sfType = SERVER_IMAP;
|
|
else if (!!(dw & SRV_HTTPMAIL))
|
|
psdi->sfType = SERVER_HTTPMAIL;
|
|
}
|
|
|
|
SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)psdi);
|
|
|
|
InitUserInformation(hwnd, pAcct, FALSE);
|
|
|
|
// Set Account Name
|
|
InitAcctPropEdit(GetDlgItem(hwnd, IDC_SERVERNAME_EDIT), pAcct, AP_ACCOUNT_NAME, CCHMAX_ACCOUNT_NAME - 1);
|
|
|
|
// if the account is an msn-related http account, swap in the msn icon
|
|
if (SERVER_HTTPMAIL == psdi->sfType)
|
|
{
|
|
DWORD dwMsnDomain = 0;
|
|
if (SUCCEEDED(pAcct->GetPropDw(AP_HTTPMAIL_DOMAIN_MSN, &dwMsnDomain)) && dwMsnDomain)
|
|
{
|
|
HICON hicon = LoadIcon(g_hInstRes, MAKEINTRESOURCE(idiMsnServer));
|
|
if (NULL != hicon)
|
|
SendDlgItemMessage(hwnd, IDC_MAILSERVER_ICON, STM_SETICON, (WPARAM)hicon, 0);
|
|
}
|
|
}
|
|
|
|
// POP3 Skip Account/IMAP Poll Unread
|
|
if (SERVER_IMAP == psdi->sfType)
|
|
{
|
|
int iIMAPStringRes;
|
|
|
|
if (pAcct->m_dwDlgFlags & ACCTDLG_NO_IMAPPOLL)
|
|
iIMAPStringRes = idsIMAPPollInbox;
|
|
else
|
|
iIMAPStringRes = idsIMAPPollForUnread;
|
|
|
|
/*
|
|
// Replace default POP3 text with text that better suits IMAP
|
|
LoadString(g_hInstRes, iIMAPStringRes, sz, sizeof(sz));
|
|
SetWindowText(GetDlgItem(hwnd, IDC_RECVFULL_INCLUDE), sz);
|
|
*/
|
|
|
|
// Load current setting and set checkbox to indicate it
|
|
if (FAILED(pAcct->GetPropDw(AP_IMAP_POLL, &dw)))
|
|
dw = FALSE; // By default, we don't poll for IMAP
|
|
|
|
CheckDlgButton(hwnd, IDC_RECVFULL_INCLUDE, dw ? BST_CHECKED : BST_UNCHECKED);
|
|
} // if
|
|
else if (SERVER_HTTPMAIL == psdi->sfType)
|
|
{
|
|
dw = FALSE;
|
|
pAcct->GetPropDw(AP_HTTPMAIL_POLL, &dw);
|
|
CheckDlgButton(hwnd, IDC_RECVFULL_INCLUDE, dw ? BST_CHECKED : BST_UNCHECKED);
|
|
}
|
|
else
|
|
{
|
|
if (!!(pAcct->m_dwDlgFlags & ACCTDLG_NO_SENDRECEIVE))
|
|
ShowWindow(GetDlgItem(hwnd, IDC_RECVFULL_INCLUDE), SW_HIDE);
|
|
else
|
|
{
|
|
if (SUCCEEDED(pAcct->GetPropDw(AP_POP3_SKIP, &dw)))
|
|
CheckDlgButton(hwnd, IDC_RECVFULL_INCLUDE, dw ? BST_UNCHECKED : BST_CHECKED);
|
|
else
|
|
CheckDlgButton(hwnd, IDC_RECVFULL_INCLUDE, BST_CHECKED);
|
|
} // else
|
|
} // else
|
|
|
|
psdi->dwInit = (psdi->dwInit | PAGE_GEN);
|
|
PropSheet_UnChanged(GetParent(hwnd), hwnd);
|
|
return (TRUE);
|
|
|
|
case WM_DESTROY:
|
|
if (psdi != NULL)
|
|
MemFree(psdi);
|
|
break;
|
|
|
|
case WM_HELP:
|
|
case WM_CONTEXTMENU:
|
|
return(OnContextHelp(hwnd, uMsg, wParam, lParam, g_rgCtxMapMailGen));
|
|
|
|
case PSM_QUERYSIBLINGS:
|
|
Assert(psdi != NULL);
|
|
Assert(pAcct != NULL);
|
|
return(HandleQuerySiblings(hwnd, psdi, pAcct, wParam, lParam));
|
|
|
|
case WM_COMMAND:
|
|
switch(GET_WM_COMMAND_ID(wParam, lParam))
|
|
{
|
|
case IDC_RECVFULL_INCLUDE:
|
|
MarkPageDirty(hwnd, PAGE_GEN);
|
|
break;
|
|
|
|
default:
|
|
if (GET_WM_COMMAND_CMD(wParam, lParam) == EN_CHANGE)
|
|
{
|
|
if (LOWORD(wParam) == IDC_SERVERNAME_EDIT)
|
|
UpdateAcctTitle(hwnd, IDC_SERVERNAME_EDIT, ACCT_MAIL);
|
|
MarkPageDirty(hwnd, PAGE_GEN);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case WM_NOTIFY:
|
|
pnmhdr = (NMHDR *)lParam;
|
|
switch (pnmhdr->code)
|
|
{
|
|
case PSN_APPLY:
|
|
// BEGIN validation
|
|
if (psdi->fNoValidate)
|
|
{
|
|
Assert(pnmhdr->code == PSN_KILLACTIVE);
|
|
break;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
if (!(GetAsyncKeyState(VK_SHIFT) & 0x8000))
|
|
{
|
|
#endif
|
|
hwndT = GetDlgItem(hwnd, IDC_SERVERNAME_EDIT);
|
|
if (!ValidateAccountName(hwnd, hwndT, pAcct, &idsError))
|
|
return(InvalidAcctProp(hwnd, hwndT, idsError, iddMailSvrProp_General));
|
|
|
|
fRet = ValidateUserInformation(hwnd, pAcct, FALSE, &hwndT, &idsError, pnmhdr->code == PSN_APPLY);
|
|
if (!fRet)
|
|
return(InvalidAcctProp(hwnd, hwndT, idsError, iddMailSvrProp_General));
|
|
|
|
if (0 == (pAcct->m_dwDlgFlags & ACCTDLG_NO_SECURITY))
|
|
{
|
|
fError = FALSE;
|
|
ZeroMemory(&cpi, sizeof(SECPAGEINFO));
|
|
hwndT = GetDlgItem(hwnd, IDE_EMAIL_ADDRESS);
|
|
GetWindowText(hwndT, sz, ARRAYSIZE(sz));
|
|
if (!!(psdi->dwInit & PAGE_SEC))
|
|
{
|
|
// the security page exists, so ask it for the cert info
|
|
PropSheet_QuerySiblings(GetParent(hwnd), MSM_GETCERTDATA, (LPARAM)&cpi);
|
|
fFree = FALSE;
|
|
}
|
|
else
|
|
{
|
|
// the security page hasn't been initialized yet,
|
|
// so we need to get this info from the acct
|
|
dw = InitCertificateData(sz, &cpi, pAcct);
|
|
Assert((dw != 1) ^ (cpi.pCert != NULL));
|
|
fFree = TRUE;
|
|
InitEncryptData(sz, &cpi, pAcct);
|
|
}
|
|
|
|
if (cpi.pCert != NULL)
|
|
{
|
|
pszEmail = SzGetCertificateEmailAddress(cpi.pCert);
|
|
if (lstrcmpi(pszEmail, sz) != 0)
|
|
{
|
|
idsError = (INT) DialogBox(g_hInstRes, MAKEINTRESOURCE(iddCertAddressError),
|
|
hwnd, CertAddressErrorDlgProc);
|
|
switch (idsError)
|
|
{
|
|
case IDCANCEL:
|
|
SendMessage(hwndT, EM_SETSEL, 0, -1);
|
|
SetFocus(hwndT);
|
|
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
|
|
fError = TRUE;
|
|
break;
|
|
|
|
case IDC_CHANGE_ADDR:
|
|
SetWindowText(hwndT, pszEmail);
|
|
SendMessage(hwndT, EM_SETMODIFY, TRUE, 0);
|
|
break;
|
|
|
|
case IDC_NEW_CERT:
|
|
psdi->fNoValidate = TRUE;
|
|
SendMessage(GetParent(hwnd), PSM_SETCURSELID, 0, (LPARAM)iddMailSvrProp_Security);
|
|
psdi->fNoValidate = FALSE;
|
|
|
|
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
|
|
fError = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
if(pszEmail)
|
|
MemFree(pszEmail);
|
|
}
|
|
|
|
if (cpi.pCert != NULL && fFree)
|
|
CertFreeCertificateContext(cpi.pCert);
|
|
if (cpi.pEncryptCert != NULL && fFree)
|
|
CertFreeCertificateContext(cpi.pEncryptCert);
|
|
if (cpi.hCertStore != NULL && fFree)
|
|
CertCloseStore(cpi.hCertStore, 0);
|
|
|
|
if (fError)
|
|
return(TRUE);
|
|
}
|
|
#ifdef DEBUG
|
|
}
|
|
#endif
|
|
|
|
// END validation
|
|
|
|
hwndT = GetDlgItem(hwnd, IDC_SERVERNAME_EDIT);
|
|
GetAccountName(hwndT, pAcct);
|
|
|
|
GetUserInformation(hwnd, pAcct, FALSE);
|
|
|
|
// Skip During Send and Receive (POP) --OR--
|
|
// Poll for Unread Count (IMAP)
|
|
if (SERVER_IMAP == psdi->sfType)
|
|
pAcct->SetPropDw(AP_IMAP_POLL, (DWORD) IsDlgButtonChecked (hwnd, IDC_RECVFULL_INCLUDE));
|
|
else if (SERVER_HTTPMAIL == psdi->sfType)
|
|
pAcct->SetPropDw(AP_HTTPMAIL_POLL, (DWORD) IsDlgButtonChecked (hwnd, IDC_RECVFULL_INCLUDE));
|
|
else
|
|
pAcct->SetPropDw(AP_POP3_SKIP, (DWORD)!IsDlgButtonChecked(hwnd, IDC_RECVFULL_INCLUDE));
|
|
|
|
PropSheet_UnChanged(GetParent(hwnd), hwnd);
|
|
dw = PAGE_GEN;
|
|
PropSheet_QuerySiblings(GetParent(hwnd), SM_SAVECHANGES, (LPARAM)&dw);
|
|
if (dw == -1)
|
|
{
|
|
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
|
|
return(TRUE);
|
|
}
|
|
break;
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
return (FALSE);
|
|
}
|
|
|
|
const static HELPMAP g_rgCtxMapMailSvr[] = {
|
|
{IDC_SMTP_EDIT, IDH_MAIL_SERV_OUTGOING},
|
|
{IDC_POP3_EDIT, IDH_MAIL_SERV_INCOMING},
|
|
{IDC_IN_MAIL_STATIC, IDH_MAIL_SERV_INCOMING},
|
|
{idcPOP_OR_IMAP, IDH_INETCOMM_MY_INCOMING_SERVER_IS},
|
|
{IDC_SERVER_STATIC, IDH_INETCOMM_MY_INCOMING_SERVER_IS},
|
|
{IDC_SERVER1_STATIC, IDH_INETCOMM_MY_INCOMING_SERVER_IS},
|
|
{IDC_LOGON_CHECK, IDH_INETCOMM_SERVER_REQ_LOGON},
|
|
{IDC_ACCTNAME_EDIT, IDH_MAIL_SERV_POP3_ACCT},
|
|
{IDC_ACCTNAME_STATIC, IDH_MAIL_SERV_POP3_ACCT},
|
|
{IDC_ACCTPASS_EDIT, IDH_MAIL_SERV_PWORD},
|
|
{IDC_ACCTPASS_STATIC, IDH_MAIL_SERV_PWORD},
|
|
{IDC_LOGONSSPI_CHECK, IDH_MAIL_LOGON_USING_SICILY},
|
|
{IDC_SMTP_SASL, IDH_MAIL_OUT_AUTH},
|
|
{IDC_SMTPLOGON, IDH_MAIL_OUT_SETTINGS},
|
|
{IDC_REMEMBER_PASSWORD, 503},
|
|
{IDC_STATIC0, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC1, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC2, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC3, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC4, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC5, IDH_INETCOMM_GROUPBOX},
|
|
{0, 0}};
|
|
|
|
INT_PTR CALLBACK MailServer_ServersDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
static SMTPAUTHINFO s_rAuth;
|
|
int idsError;
|
|
HWND hwndT;
|
|
ULONG cbSize;
|
|
NMHDR *pnmhdr;
|
|
TCHAR sz[CCHMAX_ACCT_PROP_SZ];
|
|
DWORD dw, dwPromptForPassword;
|
|
BOOL fEnable, fIMAP, fHTTPMail;
|
|
SERVER_TYPE sfType, sfTypeT;
|
|
LPMAILSERVERPROPSINFO pProps = NULL;
|
|
CAccount *pAcct = (CAccount *)GetWindowLongPtr(hwnd, DWLP_USER);
|
|
TCHAR szPreviousLoginName[CCHMAX_ACCT_PROP_SZ];
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
// Get the ServerParams and store them in our extra bytes
|
|
pAcct = (CAccount *)((PROPSHEETPAGE *)lParam)->lParam;
|
|
SetWindowLongPtr(hwnd, DWLP_USER, (LPARAM) pAcct);
|
|
|
|
// figure out what kind of server we are
|
|
PropSheet_QuerySiblings(GetParent(hwnd), MSM_GETSERVERTYPE, (LPARAM)&sfType);
|
|
|
|
GetServerProps(sfType, &pProps);
|
|
Assert(pProps);
|
|
|
|
fIMAP = (sfType == SERVER_IMAP);
|
|
fHTTPMail = (SERVER_HTTPMAIL == sfType);
|
|
|
|
// Init
|
|
ZeroMemory(&s_rAuth, sizeof(SMTPAUTHINFO));
|
|
|
|
if (!fHTTPMail)
|
|
{
|
|
// Smtp Auth Type
|
|
Assert(sizeof(s_rAuth.authtype) == sizeof(DWORD));
|
|
if (FAILED(pAcct->GetPropDw(AP_SMTP_USE_SICILY, (LPDWORD)&s_rAuth.authtype)))
|
|
s_rAuth.authtype = SMTP_AUTH_NONE;
|
|
|
|
// If smtp auth...
|
|
if (SMTP_AUTH_NONE != s_rAuth.authtype)
|
|
{
|
|
// Check the button
|
|
CheckDlgButton(hwnd, IDC_SMTP_SASL, BST_CHECKED);
|
|
|
|
if (SUCCEEDED(pAcct->GetPropSz(AP_SMTP_USERNAME, sz, ARRAYSIZE(sz))))
|
|
StrCpyN(s_rAuth.szUserName, sz, ARRAYSIZE(s_rAuth.szUserName));
|
|
|
|
if (SUCCEEDED(pAcct->GetPropDw(AP_SMTP_PROMPT_PASSWORD, &dw)))
|
|
s_rAuth.fPromptPassword = dw;
|
|
|
|
if (SUCCEEDED(pAcct->GetPropSz(AP_SMTP_PASSWORD, sz, ARRAYSIZE(sz))))
|
|
StrCpyN(s_rAuth.szPassword, sz, ARRAYSIZE(s_rAuth.szPassword));
|
|
}
|
|
else
|
|
EnableWindow(GetDlgItem(hwnd, IDC_SMTPLOGON), FALSE);
|
|
}
|
|
|
|
if (!!(pAcct->m_dwDlgFlags & ACCTDLG_NO_IMAP) && !fIMAP)
|
|
{
|
|
ShowWindow(GetDlgItem(hwnd, idcPOP_OR_IMAP), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hwnd, IDC_SERVER_STATIC), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hwnd, IDC_SERVER1_STATIC), SW_HIDE);
|
|
}
|
|
|
|
if (!fHTTPMail)
|
|
{
|
|
LoadString(g_hInstRes, fIMAP ? idsIMAP : idsPOP, sz, ARRAYSIZE(sz));
|
|
SetDlgItemText(hwnd, idcPOP_OR_IMAP, sz);
|
|
}
|
|
|
|
// Set incoming Server
|
|
InitAcctPropEdit(GetDlgItem(hwnd, IDC_POP3_EDIT), pAcct, pProps->server, CCHMAX_SERVER_NAME - 1);
|
|
|
|
if (!fHTTPMail)
|
|
{
|
|
if (fIMAP)
|
|
LoadString(g_hInstRes, idsIncomingMailIMAP, sz, ARRAYSIZE(sz));
|
|
else
|
|
LoadString(g_hInstRes, idsIncomingMailPOP, sz, ARRAYSIZE(sz));
|
|
SetWindowText(GetDlgItem(hwnd, IDC_IN_MAIL_STATIC), sz);
|
|
}
|
|
|
|
if (!fHTTPMail)
|
|
{
|
|
// Set Smtp Server
|
|
InitAcctPropEdit(GetDlgItem(hwnd, IDC_SMTP_EDIT), pAcct, AP_SMTP_SERVER, CCHMAX_SERVER_NAME - 1);
|
|
}
|
|
|
|
if (!fHTTPMail)
|
|
{
|
|
// If Saving password
|
|
if (SUCCEEDED(pAcct->GetPropDw(pProps->useSicily, &dw)) && dw)
|
|
CheckDlgButton(hwnd, IDC_LOGONSSPI_CHECK, BST_CHECKED);
|
|
}
|
|
|
|
if (SUCCEEDED(pAcct->GetPropSz(pProps->userName, sz, ARRAYSIZE(sz))))
|
|
SetDlgItemText(hwnd, IDC_ACCTNAME_EDIT, sz);
|
|
if (SUCCEEDED(pAcct->GetPropSz(pProps->password, sz, ARRAYSIZE(sz))))
|
|
SetDlgItemText(hwnd, IDC_ACCTPASS_EDIT, sz);
|
|
|
|
if (FAILED(pAcct->GetPropDw(pProps->promptPassword, &dwPromptForPassword)))
|
|
dwPromptForPassword = 0;
|
|
CheckDlgButton(hwnd, IDC_REMEMBER_PASSWORD, dwPromptForPassword ? BST_UNCHECKED : BST_CHECKED);
|
|
|
|
// Enable/Disable account windows
|
|
Server_EnableLogonWindows(hwnd, TRUE);
|
|
|
|
hwndT = GetDlgItem(hwnd, IDC_ACCTNAME_EDIT);
|
|
SetIntlFont(hwndT);
|
|
SendMessage(hwndT, EM_LIMITTEXT, CCHMAX_USERNAME - 1, 0L);
|
|
|
|
if (fHTTPMail)
|
|
{
|
|
GetWindowText(hwndT, szPreviousLoginName, CCHMAX_ACCT_PROP_SZ);
|
|
}
|
|
|
|
SendDlgItemMessage(hwnd, IDC_ACCTPASS_EDIT, EM_LIMITTEXT, CCHMAX_PASSWORD - 1, 0L);
|
|
|
|
if (SUCCEEDED(pAcct->GetPropDw(AP_SERVER_READ_ONLY, &dw)) && dw)
|
|
{
|
|
EnableWindow(GetDlgItem(hwnd, IDC_POP3_EDIT), FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_SMTP_EDIT), FALSE);
|
|
}
|
|
|
|
PropSheet_QuerySiblings(GetParent(hwnd), SM_INITIALIZED, PAGE_SERVER);
|
|
PropSheet_UnChanged(GetParent(hwnd), hwnd);
|
|
return (TRUE);
|
|
|
|
case WM_HELP:
|
|
case WM_CONTEXTMENU:
|
|
return(OnContextHelp(hwnd, uMsg, wParam, lParam, g_rgCtxMapMailSvr));
|
|
|
|
case WM_COMMAND:
|
|
switch(GET_WM_COMMAND_ID(wParam, lParam))
|
|
{
|
|
case IDC_LOGONSSPI_CHECK:
|
|
Server_EnableLogonWindows(hwnd, TRUE);
|
|
MarkPageDirty(hwnd, PAGE_SERVER);
|
|
break;
|
|
|
|
case IDC_REMEMBER_PASSWORD:
|
|
fEnable = IsDlgButtonChecked(hwnd, IDC_REMEMBER_PASSWORD);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ACCTPASS_EDIT), fEnable);
|
|
MarkPageDirty(hwnd, PAGE_SERVER);
|
|
break;
|
|
|
|
case IDC_SMTP_SASL:
|
|
MarkPageDirty(hwnd, PAGE_SERVER);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_SMTPLOGON), IsDlgButtonChecked(hwnd, IDC_SMTP_SASL));
|
|
if (!IsDlgButtonChecked(hwnd, IDC_SMTP_SASL) && SMTP_AUTH_NONE != s_rAuth.authtype)
|
|
{
|
|
s_rAuth.authtype = SMTP_AUTH_NONE;
|
|
s_rAuth.fDirty = TRUE;
|
|
}
|
|
else if (IsDlgButtonChecked(hwnd, IDC_SMTP_SASL) && SMTP_AUTH_NONE == s_rAuth.authtype)
|
|
{
|
|
s_rAuth.authtype = SMTP_AUTH_USE_POP3ORIMAP_SETTINGS;
|
|
s_rAuth.fDirty = TRUE;
|
|
}
|
|
break;
|
|
|
|
case IDC_SMTPLOGON:
|
|
if (IDOK == DialogBoxParam(g_hInstRes, MAKEINTRESOURCE(iddSmtpServerLogon), hwnd, SmtpLogonSettingsDlgProc, (LPARAM)&s_rAuth))
|
|
MarkPageDirty(hwnd, PAGE_SERVER);
|
|
break;
|
|
|
|
default:
|
|
if (GET_WM_COMMAND_CMD(wParam, lParam) == EN_CHANGE)
|
|
MarkPageDirty(hwnd, PAGE_SERVER);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case WM_NOTIFY:
|
|
pnmhdr = (NMHDR *)lParam;
|
|
switch (pnmhdr->code)
|
|
{
|
|
case PSN_APPLY:
|
|
// BEGIN validation
|
|
PropSheet_QuerySiblings(GetParent(hwnd), MSM_GETSERVERTYPE, (LPARAM)&sfType);
|
|
GetServerProps(sfType, &pProps);
|
|
Assert(pProps);
|
|
|
|
fHTTPMail = (SERVER_HTTPMAIL == sfType);
|
|
|
|
if (!fHTTPMail)
|
|
{
|
|
hwndT = GetDlgItem(hwnd, IDC_SMTP_EDIT);
|
|
if (!ValidateServerName(hwnd, hwndT, pAcct, AP_SMTP_SERVER, &idsError, pnmhdr->code == PSN_APPLY))
|
|
return(InvalidAcctProp(hwnd, hwndT, idsError, iddMailSvrProp_Servers));
|
|
}
|
|
|
|
// gregfrie review (handle httpmail)
|
|
hwndT = GetDlgItem(hwnd, IDC_POP3_EDIT);
|
|
if (!ValidateServerName(hwnd, hwndT, pAcct,
|
|
pProps->server, &idsError, pnmhdr->code == PSN_APPLY))
|
|
return(InvalidAcctProp(hwnd, hwndT, idsError, iddMailSvrProp_Servers));
|
|
|
|
if (!ValidateLogonSettings(hwnd, pAcct->m_dwDlgFlags, &hwndT, &idsError))
|
|
return(InvalidAcctProp(hwnd, hwndT, idsError, iddMailSvrProp_Servers));
|
|
|
|
if (fHTTPMail && !fWarnDomainName(hwnd, pAcct->m_dwDlgFlags, szPreviousLoginName))
|
|
{
|
|
//return (PSNRET_INVALID_NOCHANGEPAGE);
|
|
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
|
|
return(TRUE);
|
|
|
|
}
|
|
|
|
// END validation
|
|
|
|
if (!fHTTPMail)
|
|
{
|
|
// Save SMTP Auth Info
|
|
if (s_rAuth.fDirty)
|
|
{
|
|
// Save Authentication Type
|
|
pAcct->SetPropDw(AP_SMTP_USE_SICILY, s_rAuth.authtype);
|
|
|
|
// Clear user name and password
|
|
pAcct->SetProp(AP_SMTP_PROMPT_PASSWORD, NULL, 0);
|
|
pAcct->SetProp(AP_SMTP_PASSWORD, NULL, 0);
|
|
|
|
Assert(SMTP_AUTH_USE_SMTP_SETTINGS == s_rAuth.authtype ? !FIsEmptyA(s_rAuth.szUserName) : TRUE);
|
|
pAcct->SetPropSz(AP_SMTP_USERNAME, s_rAuth.szUserName);
|
|
|
|
pAcct->SetPropDw(AP_SMTP_PROMPT_PASSWORD, s_rAuth.fPromptPassword);
|
|
if (FALSE == s_rAuth.fPromptPassword)
|
|
pAcct->SetPropSz(AP_SMTP_PASSWORD, s_rAuth.szPassword);
|
|
}
|
|
}
|
|
|
|
if (!fHTTPMail)
|
|
{
|
|
hwndT = GetDlgItem(hwnd, IDC_SMTP_EDIT);
|
|
GetServerName(hwndT, pAcct, AP_SMTP_SERVER);
|
|
}
|
|
|
|
hwndT = GetDlgItem(hwnd, IDC_POP3_EDIT);
|
|
GetServerName(hwndT, pAcct, pProps->server);
|
|
|
|
// gregfrie review (httpmail)
|
|
GetLogonSettings(hwnd, pAcct, TRUE,
|
|
(sfType == SERVER_IMAP) ? SRV_IMAP : (sfType == SERVER_HTTPMAIL) ? SRV_HTTPMAIL : SRV_POP3);
|
|
|
|
PropSheet_UnChanged(GetParent(hwnd), hwnd);
|
|
dw = PAGE_SERVER;
|
|
PropSheet_QuerySiblings(GetParent(hwnd), SM_SAVECHANGES, (LPARAM)&dw);
|
|
if (dw == -1)
|
|
{
|
|
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
|
|
return(TRUE);
|
|
}
|
|
break;
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
return (FALSE);
|
|
}
|
|
|
|
void UpdateIncomingMailControls(HWND hwnd, SERVER_TYPE sfType, DWORD dwDlgFlags)
|
|
{
|
|
TCHAR sz[CCHMAX_STRINGRES];
|
|
int sw;
|
|
BOOL fIMAP;
|
|
|
|
Assert(sfType == SERVER_MAIL || sfType == SERVER_IMAP);
|
|
fIMAP = sfType == SERVER_IMAP;
|
|
|
|
LoadString(g_hInstRes, fIMAP ? idsIncomingMailIMAP : idsIncomingMailPOP, sz, ARRAYSIZE(sz));
|
|
SetWindowText(GetDlgItem(hwnd, IDC_IN_MAIL_STATIC), sz);
|
|
|
|
if (fIMAP)
|
|
{
|
|
ShowWindow(GetDlgItem(hwnd, IDC_STATIC6), SW_HIDE); // "Delivery" text
|
|
ShowWindow(GetDlgItem(hwnd, IDC_STATIC7), SW_HIDE); // Horizontal line
|
|
}
|
|
else
|
|
{
|
|
LoadString(g_hInstRes, idsDelivery, sz, ARRAYSIZE(sz));
|
|
SetWindowText(GetDlgItem(hwnd, IDC_STATIC6), sz);
|
|
}
|
|
|
|
ShowWindow(GetDlgItem(hwnd, IDC_LEAVE_CHECK), fIMAP ? SW_HIDE : SW_SHOW);
|
|
|
|
sw = (fIMAP || !!(dwDlgFlags & ACCTDLG_NO_REMOVEAFTER)) ? SW_HIDE : SW_SHOW;
|
|
ShowWindow(GetDlgItem(hwnd, IDC_REMOVE_CHECK), sw);
|
|
ShowWindow(GetDlgItem(hwnd, IDC_REMOVE_EDIT), sw);
|
|
ShowWindow(GetDlgItem(hwnd, IDC_REMOVE_SPIN), sw);
|
|
ShowWindow(GetDlgItem(hwnd, IDC_OPIE), sw);
|
|
|
|
ShowWindow(GetDlgItem(hwnd, IDC_REMOVEDELETE_CHECK), (fIMAP || !!(dwDlgFlags & ACCTDLG_NO_REMOVEDELETE)) ? SW_HIDE : SW_SHOW);
|
|
}
|
|
|
|
void EnableDeliveryControls(HWND hwnd)
|
|
{
|
|
BOOL fEnable;
|
|
|
|
fEnable = IsDlgButtonChecked(hwnd, IDC_LEAVE_CHECK);
|
|
|
|
EnableWindow(GetDlgItem(hwnd, IDC_OPIE), fEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_REMOVEDELETE_CHECK), fEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_REMOVE_CHECK), fEnable);
|
|
|
|
if (fEnable)
|
|
fEnable = IsDlgButtonChecked(hwnd, IDC_REMOVE_CHECK);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_REMOVE_EDIT), fEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_REMOVE_SPIN), fEnable);
|
|
}
|
|
|
|
void EnableUseDefaultButton(HWND hwnd, SERVER_TYPE sfType)
|
|
{
|
|
BOOL fSecure, fTrans, fEnable;
|
|
DWORD dw;
|
|
|
|
Assert(sfType == SERVER_MAIL || sfType == SERVER_IMAP);
|
|
|
|
fSecure = IsDlgButtonChecked(hwnd, IDC_SECURECONNECT_SMTP_BUTTON);
|
|
dw = GetDlgItemInt(hwnd, IDC_SMTP_PORT_EDIT, &fTrans, FALSE);
|
|
fEnable = (!fTrans || (fSecure ? (dw != DEF_SSMTPPORT) : (dw != DEF_SMTPPORT)));
|
|
|
|
if (!fEnable)
|
|
{
|
|
fSecure = IsDlgButtonChecked(hwnd, IDC_SECURECONNECT_POP3_BUTTON);
|
|
dw = GetDlgItemInt(hwnd, IDC_POP3_PORT_EDIT, &fTrans, FALSE);
|
|
if (sfType == SERVER_IMAP)
|
|
fEnable = (!fTrans || (fSecure ? (dw != DEF_SIMAPPORT) : (dw != DEF_IMAPPORT)));
|
|
else
|
|
fEnable = (!fTrans || (fSecure ? (dw != DEF_SPOP3PORT) : (dw != DEF_POP3PORT)));
|
|
}
|
|
|
|
EnableWindow(GetDlgItem(hwnd, IDC_USEDEFAULTS_BUTTON), fEnable);
|
|
}
|
|
|
|
const static HELPMAP g_rgCtxMapMailAdv[] = {
|
|
{IDC_SMTP_PORT_EDIT, IDH_MAIL_SERV_ADV_OUT_PORT},
|
|
{IDC_POP3_PORT_EDIT, IDH_MAIL_SERV_ADV_INC_PORT},
|
|
{IDC_IN_MAIL_STATIC, IDH_MAIL_SERV_ADV_INC_PORT},
|
|
{IDC_USEDEFAULTS_BUTTON, IDH_NEWS_SERV_ADV_USE_DEFAULTS},
|
|
{IDC_SECURECONNECT_SMTP_BUTTON, IDH_MAIL_ADV_REQ_SSL},
|
|
{IDC_SECURECONNECT_POP3_BUTTON, IDH_MAIL_ADV_REQ_SSL},
|
|
{IDC_TIMEOUT_SLIDER, IDH_MAIL_SERV_ADV_TIMEOUT},
|
|
{IDC_TIMEOUT_STATIC, IDH_MAIL_SERV_ADV_TIMEOUT},
|
|
{IDC_LEAVE_CHECK, IDH_MAIL_SERV_ADV_LEAVE_SERVER_COPY},
|
|
{IDC_REMOVE_CHECK, IDH_MAIL_SERV_ADV_REMOVE_AFTER5},
|
|
{IDC_REMOVE_EDIT, IDH_MAIL_SERV_ADV_REMOVE_AFTER5},
|
|
{IDC_REMOVE_SPIN, IDH_MAIL_SERV_ADV_REMOVE_AFTER5},
|
|
{IDC_OPIE, IDH_MAIL_SERV_ADV_REMOVE_AFTER5},
|
|
{IDC_REMOVEDELETE_CHECK, IDH_MAIL_SERV_ADV_REMOVE_WHEN_DELETED},
|
|
{IDC_SPLIT_CHECK, IDH_NEWSMAIL_SEND_ADVSET_BREAK_UP},
|
|
{IDC_SPLIT_EDIT, IDH_NEWSMAIL_SEND_ADVSET_BREAK_UP},
|
|
{IDC_SPLIT_SPIN, IDH_NEWSMAIL_SEND_ADVSET_BREAK_UP},
|
|
{IDC_SPLIT_STATIC, IDH_NEWSMAIL_SEND_ADVSET_BREAK_UP},
|
|
{IDC_STATIC0, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC1, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC2, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC3, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC4, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC5, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC6, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC7, IDH_INETCOMM_GROUPBOX},
|
|
{0, 0}};
|
|
|
|
INT_PTR CALLBACK MailServer_AdvancedDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
NMHDR *pnmhdr;
|
|
TCHAR sz[MAX_PATH];
|
|
DWORD dw, dwPortSmtp, dwPortIn, dwRemove, dwSplit;
|
|
WORD code, id;
|
|
SERVER_TYPE sfType;
|
|
HWND hwndT;
|
|
BOOL fTrans, fSecure, fEnable, flag, fIMAP;
|
|
CAccount *pAcct = (CAccount *)GetWindowLongPtr(hwnd, DWLP_USER);
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
// Get the ServerParams and store them in our extra bytes
|
|
pAcct = (CAccount *)((PROPSHEETPAGE *) lParam)->lParam;
|
|
SetWindowLongPtr(hwnd, DWLP_USER, (LPARAM) pAcct);
|
|
|
|
SendDlgItemMessage(hwnd, IDC_POP3_PORT_EDIT, EM_LIMITTEXT, PORT_CCHMAX, 0);
|
|
SendDlgItemMessage(hwnd, IDC_SMTP_PORT_EDIT, EM_LIMITTEXT, PORT_CCHMAX, 0);
|
|
|
|
// figure out what kind of server we are
|
|
PropSheet_QuerySiblings(GetParent(hwnd), MSM_GETSERVERTYPE, (LPARAM)&sfType);
|
|
|
|
Assert(sfType == SERVER_MAIL || sfType == SERVER_IMAP);
|
|
fIMAP = sfType == SERVER_IMAP;
|
|
|
|
UpdateIncomingMailControls(hwnd, sfType, pAcct->m_dwDlgFlags);
|
|
|
|
// incoming server Secure connect
|
|
if (FAILED(pAcct->GetPropDw(fIMAP ? AP_IMAP_SSL : AP_POP3_SSL, (LPDWORD)&fSecure)))
|
|
fSecure = FALSE; // default
|
|
CheckDlgButton(hwnd, IDC_SECURECONNECT_POP3_BUTTON, fSecure);
|
|
|
|
// incoming server Port
|
|
if (FAILED(pAcct->GetPropDw(fIMAP ? AP_IMAP_PORT : AP_POP3_PORT, &dw)))
|
|
{
|
|
// default
|
|
if (fSecure)
|
|
dw = fIMAP ? DEF_SIMAPPORT : DEF_SPOP3PORT;
|
|
else
|
|
dw = fIMAP ? DEF_IMAPPORT : DEF_POP3PORT;
|
|
}
|
|
SetDlgItemInt(hwnd, IDC_POP3_PORT_EDIT, dw, FALSE);
|
|
|
|
// SMTP Secure connect
|
|
if (FAILED(pAcct->GetPropDw(AP_SMTP_SSL, (LPDWORD) &fSecure)))
|
|
fSecure = FALSE; // default
|
|
CheckDlgButton(hwnd, IDC_SECURECONNECT_SMTP_BUTTON, fSecure);
|
|
|
|
// SMTP Port
|
|
if (FAILED(pAcct->GetPropDw(AP_SMTP_PORT, &dw)))
|
|
dw = fSecure ? DEF_SSMTPPORT : DEF_SMTPPORT; // default
|
|
SetDlgItemInt(hwnd, IDC_SMTP_PORT_EDIT, dw, FALSE);
|
|
|
|
EnableUseDefaultButton(hwnd, sfType);
|
|
|
|
// Server Timeout
|
|
dw = 0;
|
|
pAcct->GetPropDw(AP_SMTP_TIMEOUT, &dw);
|
|
InitTimeoutSlider(GetDlgItem(hwnd, IDC_TIMEOUT_SLIDER),
|
|
GetDlgItem(hwnd, IDC_TIMEOUT_STATIC), dw);
|
|
|
|
// Leave on Server
|
|
if (FAILED(pAcct->GetPropDw(AP_POP3_LEAVE_ON_SERVER, &dw)))
|
|
dw = FALSE; // default
|
|
CheckDlgButton(hwnd, IDC_LEAVE_CHECK, dw);
|
|
|
|
if (!!(pAcct->m_dwDlgFlags & ACCTDLG_NO_REMOVEAFTER))
|
|
{
|
|
ShowWindow(GetDlgItem(hwnd, IDC_REMOVE_CHECK), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hwnd, IDC_REMOVE_EDIT), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hwnd, IDC_REMOVE_SPIN), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hwnd, IDC_OPIE), SW_HIDE);
|
|
}
|
|
|
|
// Remove from Server after xxx days
|
|
dw = OPTION_OFF; // default
|
|
if (SUCCEEDED(pAcct->GetPropDw(AP_POP3_REMOVE_EXPIRED, (LPDWORD)&flag)) && flag)
|
|
pAcct->GetPropDw(AP_POP3_EXPIRE_DAYS, &dw);
|
|
InitCheckCounter(dw, hwnd, IDC_REMOVE_CHECK, IDC_REMOVE_EDIT, IDC_REMOVE_SPIN,
|
|
EXPIRE_MIN, EXPIRE_MAX, EXPIRE_DEFAULT);
|
|
|
|
if (!!(pAcct->m_dwDlgFlags & ACCTDLG_NO_REMOVEDELETE))
|
|
ShowWindow(GetDlgItem(hwnd, IDC_REMOVEDELETE_CHECK), SW_HIDE);
|
|
|
|
// Remove when deleted locally
|
|
if (FAILED(pAcct->GetPropDw(AP_POP3_REMOVE_DELETED, &dw)))
|
|
dw = FALSE; // default
|
|
CheckDlgButton(hwnd, IDC_REMOVEDELETE_CHECK, dw);
|
|
|
|
EnableDeliveryControls(hwnd);
|
|
|
|
if (!!(pAcct->m_dwDlgFlags & ACCTDLG_NO_BREAKMESSAGES))
|
|
{
|
|
ShowWindow(GetDlgItem(hwnd, IDC_SPLIT_GROUPBOX), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hwnd, IDC_SPLIT_CHECK), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hwnd, IDC_SPLIT_EDIT), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hwnd, IDC_SPLIT_SPIN), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hwnd, IDC_SPLIT_STATIC), SW_HIDE);
|
|
}
|
|
|
|
// Break Message Size
|
|
dw = OPTION_OFF; // default
|
|
if (SUCCEEDED(pAcct->GetPropDw(AP_SMTP_SPLIT_MESSAGES, (LPDWORD)&flag)) && flag)
|
|
pAcct->GetPropDw(AP_SMTP_SPLIT_SIZE, (LPDWORD)&dw);
|
|
InitCheckCounter(dw, hwnd, IDC_SPLIT_CHECK, IDC_SPLIT_EDIT, IDC_SPLIT_SPIN,
|
|
BREAKSIZE_MIN, BREAKSIZE_MAX, DEF_BREAKSIZE);
|
|
|
|
|
|
PropSheet_QuerySiblings(GetParent(hwnd), SM_INITIALIZED, PAGE_ADV);
|
|
PropSheet_UnChanged(GetParent(hwnd), hwnd);
|
|
return (TRUE);
|
|
|
|
case WM_HELP:
|
|
case WM_CONTEXTMENU:
|
|
return(OnContextHelp(hwnd, uMsg, wParam, lParam, g_rgCtxMapMailAdv));
|
|
|
|
case WM_HSCROLL:
|
|
// Update the text beside the slider
|
|
SetTimeoutString(GetDlgItem(hwnd, IDC_TIMEOUT_STATIC),
|
|
(UINT) (SendMessage((HWND) lParam, TBM_GETPOS, 0, 0)));
|
|
|
|
MarkPageDirty(hwnd, PAGE_ADV);
|
|
return (TRUE);
|
|
|
|
case WM_COMMAND:
|
|
// Any change to the edit controls would cause the "Apply" button
|
|
// to enable.
|
|
PropSheet_QuerySiblings(GetParent(hwnd), MSM_GETSERVERTYPE, (LPARAM)&sfType);
|
|
|
|
code = GET_WM_COMMAND_CMD(wParam, lParam);
|
|
id = GET_WM_COMMAND_ID(wParam, lParam);
|
|
|
|
|
|
switch (id)
|
|
{
|
|
case IDC_SMTP_PORT_EDIT:
|
|
case IDC_POP3_PORT_EDIT:
|
|
if (code == EN_CHANGE)
|
|
{
|
|
EnableUseDefaultButton(hwnd, sfType);
|
|
|
|
MarkPageDirty(hwnd, PAGE_ADV);
|
|
}
|
|
break;
|
|
|
|
case IDC_SECURECONNECT_POP3_BUTTON:
|
|
case IDC_SECURECONNECT_SMTP_BUTTON:
|
|
case IDC_USEDEFAULTS_BUTTON:
|
|
if (id != IDC_SECURECONNECT_POP3_BUTTON)
|
|
{
|
|
fSecure = IsDlgButtonChecked(hwnd, IDC_SECURECONNECT_SMTP_BUTTON);
|
|
SetDlgItemInt(hwnd, IDC_SMTP_PORT_EDIT, fSecure ? DEF_SSMTPPORT : DEF_SMTPPORT, FALSE);
|
|
}
|
|
|
|
if (id != IDC_SECURECONNECT_SMTP_BUTTON)
|
|
{
|
|
fSecure = IsDlgButtonChecked(hwnd, IDC_SECURECONNECT_POP3_BUTTON);
|
|
if (sfType == SERVER_MAIL)
|
|
dw = fSecure ? DEF_SPOP3PORT : DEF_POP3PORT;
|
|
else
|
|
dw = fSecure ? DEF_SIMAPPORT : DEF_IMAPPORT;
|
|
SetDlgItemInt(hwnd, IDC_POP3_PORT_EDIT, dw, FALSE);
|
|
}
|
|
|
|
EnableUseDefaultButton(hwnd, sfType);
|
|
|
|
MarkPageDirty(hwnd, PAGE_ADV);
|
|
break;
|
|
|
|
case IDC_LEAVE_CHECK:
|
|
case IDC_REMOVE_CHECK:
|
|
EnableDeliveryControls(hwnd);
|
|
// fall through...
|
|
|
|
case IDC_REMOVEDELETE_CHECK:
|
|
MarkPageDirty(hwnd, PAGE_ADV);
|
|
break;
|
|
|
|
case IDC_SPLIT_CHECK:
|
|
fEnable = IsDlgButtonChecked(hwnd, IDC_SPLIT_CHECK);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_SPLIT_EDIT), fEnable);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_SPLIT_SPIN), fEnable);
|
|
|
|
MarkPageDirty(hwnd, PAGE_ADV);
|
|
break;
|
|
|
|
case IDC_SPLIT_EDIT:
|
|
case IDC_REMOVE_EDIT:
|
|
if (code == EN_CHANGE)
|
|
MarkPageDirty(hwnd, PAGE_ADV);
|
|
break;
|
|
}
|
|
return (TRUE);
|
|
|
|
case WM_NOTIFY:
|
|
pnmhdr = (NMHDR *)lParam;
|
|
switch (pnmhdr->code)
|
|
{
|
|
case PSN_APPLY:
|
|
// BEGIN validation
|
|
|
|
// figure out what kind of server we are
|
|
PropSheet_QuerySiblings(GetParent(hwnd), MSM_GETSERVERTYPE, (LPARAM)&sfType);
|
|
|
|
Assert(sfType == SERVER_MAIL || sfType == SERVER_IMAP);
|
|
fIMAP = sfType == SERVER_IMAP;
|
|
|
|
dwPortSmtp = GetDlgItemInt(hwnd, IDC_SMTP_PORT_EDIT, &fTrans, FALSE);
|
|
if (!fTrans || dwPortSmtp == 0)
|
|
{
|
|
hwndT = GetDlgItem(hwnd, IDC_SMTP_PORT_EDIT);
|
|
return(InvalidAcctProp(hwnd, hwndT, idsErrPortNum, iddMailSvrProp_Advanced));
|
|
}
|
|
|
|
dwPortIn = GetDlgItemInt(hwnd, IDC_POP3_PORT_EDIT, &fTrans, FALSE);
|
|
if (!fTrans || dwPortIn == 0)
|
|
{
|
|
hwndT = GetDlgItem(hwnd, IDC_POP3_PORT_EDIT);
|
|
return(InvalidAcctProp(hwnd, hwndT, idsErrPortNum, iddMailSvrProp_Advanced));
|
|
}
|
|
|
|
dwRemove = 0;
|
|
if (!fIMAP)
|
|
{
|
|
if (IsDlgButtonChecked(hwnd, IDC_LEAVE_CHECK) &&
|
|
IsDlgButtonChecked(hwnd, IDC_REMOVE_CHECK))
|
|
{
|
|
dwRemove = GetDlgItemInt(hwnd, IDC_REMOVE_EDIT, &fTrans, FALSE);
|
|
if (!fTrans || dwRemove < EXPIRE_MIN || dwRemove > EXPIRE_MAX)
|
|
{
|
|
hwndT = GetDlgItem(hwnd, IDC_REMOVE_EDIT);
|
|
return(InvalidAcctProp(hwnd, hwndT, idsEnterRemoveFromServerDays, iddMailSvrProp_Advanced));
|
|
}
|
|
}
|
|
}
|
|
|
|
dwSplit = 0;
|
|
if (IsDlgButtonChecked(hwnd, IDC_SPLIT_CHECK))
|
|
{
|
|
dwSplit = GetDlgItemInt(hwnd, IDC_SPLIT_EDIT, &fTrans, FALSE);
|
|
if (!fTrans || dwSplit < BREAKSIZE_MIN || dwSplit > BREAKSIZE_MAX)
|
|
{
|
|
hwndT = GetDlgItem(hwnd, IDC_SPLIT_EDIT);
|
|
return(InvalidAcctProp(hwnd, hwndT, idsEnterBreakSize, iddMailSvrProp_Advanced));
|
|
}
|
|
}
|
|
|
|
// END validation
|
|
|
|
pAcct->SetPropDw(AP_SMTP_PORT, dwPortSmtp);
|
|
|
|
if (fIMAP)
|
|
{
|
|
HRESULT hrTemp;
|
|
|
|
hrTemp = pAcct->GetPropDw(AP_IMAP_PORT, &dw);
|
|
if (FAILED(hrTemp) || dw != dwPortIn)
|
|
{
|
|
pAcct-> SetPropDw(AP_IMAP_PORT, dwPortIn);
|
|
if (FAILED(pAcct->GetPropDw(AP_IMAP_DIRTY, &dw)))
|
|
dw = 0;
|
|
|
|
dw |= IMAP_FLDRLIST_DIRTY;
|
|
pAcct->SetPropDw(AP_IMAP_DIRTY, dw);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pAcct->SetPropDw(AP_POP3_PORT, dwPortIn);
|
|
dw = IsDlgButtonChecked(hwnd, IDC_LEAVE_CHECK);
|
|
pAcct->SetPropDw(AP_POP3_LEAVE_ON_SERVER, dw);
|
|
|
|
if (dw != 0)
|
|
{
|
|
dw = IsDlgButtonChecked(hwnd, IDC_REMOVE_CHECK);
|
|
pAcct->SetPropDw(AP_POP3_REMOVE_EXPIRED, dw);
|
|
|
|
if (dw != 0)
|
|
{
|
|
Assert(dwRemove != 0);
|
|
pAcct->SetPropDw(AP_POP3_EXPIRE_DAYS, dwRemove);
|
|
}
|
|
|
|
dw = IsDlgButtonChecked(hwnd, IDC_REMOVEDELETE_CHECK);
|
|
pAcct->SetPropDw(AP_POP3_REMOVE_DELETED, dw);
|
|
}
|
|
}
|
|
|
|
dw = IsDlgButtonChecked(hwnd, IDC_SECURECONNECT_POP3_BUTTON);
|
|
pAcct->SetPropDw(fIMAP ? AP_IMAP_SSL : AP_POP3_SSL, dw);
|
|
|
|
dw = GetTimeoutFromSlider(GetDlgItem(hwnd, IDC_TIMEOUT_SLIDER));
|
|
pAcct->SetPropDw(AP_SMTP_TIMEOUT, dw);
|
|
pAcct->SetPropDw(fIMAP ? AP_IMAP_TIMEOUT : AP_POP3_TIMEOUT, dw);
|
|
|
|
dw = IsDlgButtonChecked(hwnd, IDC_SECURECONNECT_SMTP_BUTTON);
|
|
pAcct->SetPropDw(AP_SMTP_SSL, dw);
|
|
|
|
dw = IsDlgButtonChecked(hwnd, IDC_SPLIT_CHECK);
|
|
pAcct->SetPropDw(AP_SMTP_SPLIT_MESSAGES, dw);
|
|
if (dw != 0)
|
|
{
|
|
Assert(dwSplit != 0);
|
|
pAcct->SetPropDw(AP_SMTP_SPLIT_SIZE, dwSplit);
|
|
}
|
|
|
|
PropSheet_UnChanged(GetParent(hwnd), hwnd);
|
|
dw = PAGE_ADV;
|
|
PropSheet_QuerySiblings(GetParent(hwnd), SM_SAVECHANGES, (LPARAM)&dw);
|
|
if (dw == -1)
|
|
{
|
|
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
|
|
return(TRUE);
|
|
}
|
|
break;
|
|
}
|
|
return (TRUE);
|
|
}
|
|
|
|
return (FALSE);
|
|
}
|
|
|
|
|
|
BOOL FIsDuplicateIMAPSpecialFldrs(LPSTR pszSentItems, LPSTR pszDrafts,
|
|
HWND hwnd, HWND *phwndOffender, int *piErrorStr)
|
|
{
|
|
Assert(NULL != phwndOffender);
|
|
Assert(NULL != piErrorStr);
|
|
|
|
// First compare both special folders to INBOX
|
|
if (0 == lstrcmpi(c_szInbox, pszSentItems))
|
|
{
|
|
*phwndOffender = GetDlgItem(hwnd, IDC_IMAPSENT_EDIT);
|
|
*piErrorStr = idsIMAPSpecialFldr_InboxDup;
|
|
return TRUE;
|
|
}
|
|
|
|
if (0 == lstrcmpi(c_szInbox, pszDrafts))
|
|
{
|
|
*phwndOffender = GetDlgItem(hwnd, IDC_IMAPDRAFT_EDIT);
|
|
*piErrorStr = idsIMAPSpecialFldr_InboxDup;
|
|
return TRUE;
|
|
}
|
|
|
|
// Now compare special folders to each other
|
|
if (0 == lstrcmpi(pszSentItems, pszDrafts))
|
|
{
|
|
*phwndOffender = GetDlgItem(hwnd, IDC_IMAPSENT_EDIT);
|
|
*piErrorStr = idsIMAPSpecialFldr_Duplicate;
|
|
return TRUE;
|
|
}
|
|
|
|
// If we reached this point, no problems found
|
|
*phwndOffender = NULL;
|
|
*piErrorStr = 0;
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL FContainsHierarchyChars(LPSTR pszFldrName)
|
|
{
|
|
BOOL fSkipByte = FALSE;
|
|
|
|
while ('\0' != *pszFldrName)
|
|
{
|
|
if (fSkipByte)
|
|
fSkipByte = FALSE;
|
|
else if (IsDBCSLeadByte(*pszFldrName))
|
|
fSkipByte = TRUE; // Skip next byte (trail byte)
|
|
else
|
|
{
|
|
if ('/' == *pszFldrName || '\\' == *pszFldrName || '.' == *pszFldrName)
|
|
return TRUE;
|
|
}
|
|
|
|
// Advance char ptr
|
|
pszFldrName += 1;
|
|
}
|
|
|
|
// If we reached this point, no hierarchy chars found
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
const static HELPMAP g_rgCtxMapIMAP[] = {
|
|
{IDC_ROOT_FOLDER_EDIT, IDH_IMAP_BASE_ROOT},
|
|
{IDC_IMAP_SVRSPECIALFLDRS, 760},
|
|
{IDC_IMAPSENT_EDIT, 765},
|
|
{IDC_IMAPSENT_STATIC, 765},
|
|
{IDC_IMAPDRAFT_EDIT, 770},
|
|
{IDC_IMAPDRAFT_STATIC, 770},
|
|
{IDC_IMAP_POLL_ALL_FOLDERS, 775},
|
|
{IDC_STATIC0, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC1, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC2, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC3, IDH_INETCOMM_GROUPBOX},
|
|
{0, 0}};
|
|
|
|
INT_PTR CALLBACK MailServer_IMAPDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
NMHDR *pnmhdr;
|
|
TCHAR sz[MAX_PATH];
|
|
DWORD dw, dw2;
|
|
HWND hwndT;
|
|
WORD code, id;
|
|
UINT uiLen;
|
|
CAccount *pAcct = (CAccount *)GetWindowLongPtr(hwnd, DWLP_USER);
|
|
HRESULT hrTemp;
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
// Get the ServerParams and store them in our extra bytes
|
|
pAcct = (CAccount *)((PROPSHEETPAGE *) lParam)->lParam;
|
|
SetWindowLongPtr(hwnd, DWLP_USER, (LPARAM) pAcct);
|
|
|
|
// Initialize edit controls
|
|
InitAcctPropEdit(GetDlgItem(hwnd, IDC_ROOT_FOLDER_EDIT), pAcct,
|
|
AP_IMAP_ROOT_FOLDER, CCHMAX_ROOT_FOLDER - 1);
|
|
|
|
if (FAILED(pAcct->GetPropDw(AP_IMAP_POLL_ALL_FOLDERS, &dw)))
|
|
dw = TRUE;
|
|
CheckDlgButton(hwnd, IDC_IMAP_POLL_ALL_FOLDERS, dw != 0);
|
|
|
|
// Initialize IMAP Special Folder Options IF we have the flag to do so
|
|
if (pAcct->m_dwDlgFlags & ACCTDLG_SHOWIMAPSPECIAL)
|
|
{
|
|
// Init special folder edit controls
|
|
InitAcctPropEdit(GetDlgItem(hwnd, IDC_IMAPSENT_EDIT), pAcct,
|
|
AP_IMAP_SENTITEMSFLDR, CCHMAX_ROOT_FOLDER - 1);
|
|
InitAcctPropEdit(GetDlgItem(hwnd, IDC_IMAPDRAFT_EDIT), pAcct,
|
|
AP_IMAP_DRAFTSFLDR, CCHMAX_ROOT_FOLDER - 1);
|
|
|
|
// IMAP server-side special folders
|
|
if (FAILED(pAcct->GetPropDw(AP_IMAP_SVRSPECIALFLDRS, &dw)))
|
|
dw = TRUE; // default
|
|
CheckDlgButton(hwnd, IDC_IMAP_SVRSPECIALFLDRS, dw);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_IMAPSENT_EDIT), dw);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_IMAPDRAFT_EDIT), dw);
|
|
}
|
|
else
|
|
{
|
|
// Hide all IMAP special folder options
|
|
ShowWindow(GetDlgItem(hwnd, IDC_IMAPSENT_EDIT), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hwnd, IDC_IMAPDRAFT_EDIT), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hwnd, IDC_IMAP_SVRSPECIALFLDRS), SW_HIDE);
|
|
|
|
ShowWindow(GetDlgItem(hwnd, IDC_STATIC2), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hwnd, IDC_STATIC3), SW_HIDE);
|
|
|
|
ShowWindow(GetDlgItem(hwnd, IDC_IMAPSENT_STATIC), SW_HIDE);
|
|
ShowWindow(GetDlgItem(hwnd, IDC_IMAPDRAFT_STATIC), SW_HIDE);
|
|
}
|
|
|
|
PropSheet_QuerySiblings(GetParent(hwnd), SM_INITIALIZED, PAGE_IMAP);
|
|
PropSheet_UnChanged(GetParent(hwnd), hwnd);
|
|
return (TRUE);
|
|
|
|
case WM_HELP:
|
|
case WM_CONTEXTMENU:
|
|
return(OnContextHelp(hwnd, uMsg, wParam, lParam, g_rgCtxMapIMAP));
|
|
|
|
case WM_COMMAND:
|
|
// Any change to the edit controls would cause the "Apply" button
|
|
// to enable.
|
|
code = GET_WM_COMMAND_CMD(wParam, lParam);
|
|
id = GET_WM_COMMAND_ID(wParam, lParam);
|
|
|
|
switch (id)
|
|
{
|
|
//case IDC_IMAP_LISTLSUB:
|
|
case IDC_IMAP_POLL_ALL_FOLDERS:
|
|
MarkPageDirty(hwnd, PAGE_IMAP);
|
|
break;
|
|
|
|
case IDC_IMAP_SVRSPECIALFLDRS:
|
|
dw = IsDlgButtonChecked(hwnd, IDC_IMAP_SVRSPECIALFLDRS);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_IMAPSENT_EDIT), dw);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_IMAPDRAFT_EDIT), dw);
|
|
MarkPageDirty(hwnd, PAGE_IMAP);
|
|
break;
|
|
|
|
case IDC_ROOT_FOLDER_EDIT:
|
|
case IDC_IMAPSENT_EDIT:
|
|
case IDC_IMAPDRAFT_EDIT:
|
|
if (code == EN_CHANGE)
|
|
MarkPageDirty(hwnd, PAGE_IMAP);
|
|
break;
|
|
}
|
|
return (TRUE);
|
|
|
|
case WM_NOTIFY:
|
|
pnmhdr = (NMHDR *)lParam;
|
|
switch (pnmhdr->code)
|
|
{
|
|
case PSN_APPLY:
|
|
// BEGIN validation
|
|
// Check IMAP special folder paths
|
|
if (BST_CHECKED == IsDlgButtonChecked(hwnd, IDC_IMAP_SVRSPECIALFLDRS))
|
|
{
|
|
TCHAR sz2[MAX_PATH];
|
|
int iErrorStr;
|
|
|
|
// Check for 0-length special folder paths
|
|
if (0 == GetDlgItemText(hwnd, IDC_IMAPSENT_EDIT, sz, ARRAYSIZE(sz)) ||
|
|
FIsEmpty(sz))
|
|
{
|
|
hwndT = GetDlgItem(hwnd, IDC_IMAPSENT_EDIT);
|
|
return(InvalidAcctProp(hwnd, hwndT, idsIMAPBlankSpecialFldrs, iddMailSvrProp_IMAP));
|
|
}
|
|
|
|
if (0 == GetDlgItemText(hwnd, IDC_IMAPDRAFT_EDIT, sz2, ARRAYSIZE(sz2)) ||
|
|
FIsEmpty(sz))
|
|
{
|
|
hwndT = GetDlgItem(hwnd, IDC_IMAPDRAFT_EDIT);
|
|
return(InvalidAcctProp(hwnd, hwndT, idsIMAPBlankSpecialFldrs, iddMailSvrProp_IMAP));
|
|
}
|
|
|
|
// Check for duplicate special folder paths: these are not allowed
|
|
// If we got to this point, sz and sz2 are filled with sent items path
|
|
if (FIsDuplicateIMAPSpecialFldrs(sz, sz2, hwnd, &hwndT, &iErrorStr))
|
|
return(InvalidAcctProp(hwnd, hwndT, iErrorStr, iddMailSvrProp_IMAP));
|
|
|
|
// Check for hierarchy characters in special folder names
|
|
if (FContainsHierarchyChars(sz))
|
|
{
|
|
hwndT = GetDlgItem(hwnd, IDC_IMAPSENT_EDIT);
|
|
return(InvalidAcctProp(hwnd, hwndT, idsIMAPNoHierarchyChars, iddMailSvrProp_IMAP));
|
|
}
|
|
|
|
if (FContainsHierarchyChars(sz2))
|
|
{
|
|
hwndT = GetDlgItem(hwnd, IDC_IMAPDRAFT_EDIT);
|
|
return(InvalidAcctProp(hwnd, hwndT, idsIMAPNoHierarchyChars, iddMailSvrProp_IMAP));
|
|
}
|
|
}
|
|
|
|
// END validation
|
|
|
|
// Save IMAP root folder path, if it changed
|
|
if (0 != SendMessage(GetDlgItem(hwnd, IDC_ROOT_FOLDER_EDIT),
|
|
EM_GETMODIFY, 0, 0))
|
|
{
|
|
dw = GetDlgItemText(hwnd, IDC_ROOT_FOLDER_EDIT, sz, ARRAYSIZE(sz));
|
|
// TODO: figure out if it is a valid folder
|
|
UlStripWhitespace(sz, TRUE, TRUE, &dw);
|
|
pAcct->SetPropSz(AP_IMAP_ROOT_FOLDER, sz);
|
|
SendMessage(GetDlgItem(hwnd, IDC_ROOT_FOLDER_EDIT), EM_SETMODIFY, 0, 0);
|
|
|
|
if (FAILED(pAcct->GetPropDw(AP_IMAP_DIRTY, &dw)))
|
|
dw = 0;
|
|
|
|
dw |= IMAP_FLDRLIST_DIRTY;
|
|
pAcct->SetPropDw(AP_IMAP_DIRTY, dw);
|
|
}
|
|
|
|
|
|
dw = IsDlgButtonChecked(hwnd, IDC_IMAP_POLL_ALL_FOLDERS);
|
|
pAcct->SetPropDw(AP_IMAP_POLL_ALL_FOLDERS, dw);
|
|
|
|
// Save special folders checkbox
|
|
dw = IsDlgButtonChecked(hwnd, IDC_IMAP_SVRSPECIALFLDRS);
|
|
hrTemp = pAcct->GetPropDw(AP_IMAP_SVRSPECIALFLDRS, &dw2);
|
|
if (FAILED(hrTemp) || dw2 != dw)
|
|
{
|
|
pAcct->SetPropDw(AP_IMAP_SVRSPECIALFLDRS, dw);
|
|
if (FAILED(pAcct->GetPropDw(AP_IMAP_DIRTY, &dw2)))
|
|
dw2 = 0;
|
|
|
|
dw2 |= (IMAP_SENTITEMS_DIRTY | IMAP_DRAFTS_DIRTY);
|
|
pAcct->SetPropDw(AP_IMAP_DIRTY, dw2);
|
|
}
|
|
|
|
if (dw != 0)
|
|
{
|
|
// Save IMAP Sent Items folder path, if it changed
|
|
if (0 != SendMessage(GetDlgItem(hwnd, IDC_IMAPSENT_EDIT),
|
|
EM_GETMODIFY, 0, 0))
|
|
{
|
|
uiLen = GetDlgItemText(hwnd, IDC_IMAPSENT_EDIT, sz, ARRAYSIZE(sz));
|
|
ImapRemoveTrailingHC(sz, uiLen);
|
|
// TODO: figure out if it is a valid folder
|
|
pAcct->SetPropSz(AP_IMAP_SENTITEMSFLDR, sz);
|
|
SendMessage(GetDlgItem(hwnd, IDC_IMAPSENT_EDIT), EM_SETMODIFY, 0, 0);
|
|
|
|
if (FAILED(pAcct->GetPropDw(AP_IMAP_DIRTY, &dw)))
|
|
dw = 0;
|
|
|
|
dw |= IMAP_SENTITEMS_DIRTY;
|
|
pAcct->SetPropDw(AP_IMAP_DIRTY, dw);
|
|
}
|
|
|
|
// Save IMAP Drafts folder path, if it changed
|
|
if (0 != SendMessage(GetDlgItem(hwnd, IDC_IMAPDRAFT_EDIT),
|
|
EM_GETMODIFY, 0, 0))
|
|
{
|
|
uiLen = GetDlgItemText(hwnd, IDC_IMAPDRAFT_EDIT, sz, ARRAYSIZE(sz));
|
|
ImapRemoveTrailingHC(sz, uiLen);
|
|
// TODO: figure out if it is a valid folder
|
|
pAcct->SetPropSz(AP_IMAP_DRAFTSFLDR, sz);
|
|
SendMessage(GetDlgItem(hwnd, IDC_IMAPDRAFT_EDIT), EM_SETMODIFY, 0, 0);
|
|
|
|
if (FAILED(pAcct->GetPropDw(AP_IMAP_DIRTY, &dw)))
|
|
dw = 0;
|
|
|
|
dw |= IMAP_DRAFTS_DIRTY;
|
|
pAcct->SetPropDw(AP_IMAP_DIRTY, dw);
|
|
}
|
|
}
|
|
|
|
PropSheet_UnChanged(GetParent(hwnd), hwnd);
|
|
dw = PAGE_IMAP;
|
|
PropSheet_QuerySiblings(GetParent(hwnd), SM_SAVECHANGES, (LPARAM)&dw);
|
|
if (dw == -1)
|
|
{
|
|
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
|
|
return(TRUE);
|
|
}
|
|
break;
|
|
}
|
|
return (TRUE);
|
|
}
|
|
|
|
return (FALSE);
|
|
} // MailServer_IMAPDlgProc
|
|
|
|
|
|
void ImapRemoveTrailingHC(LPSTR pszPath, UINT uiLen)
|
|
{
|
|
LPSTR pLastChar;
|
|
|
|
if (0 == uiLen)
|
|
return;
|
|
|
|
pLastChar = pszPath + uiLen - 1;
|
|
while (pLastChar >= pszPath && ('/' == *pLastChar || '\\' == *pLastChar || '.' == *pLastChar))
|
|
{
|
|
*pLastChar = '\0'; // Bye-bye, potential hierarchy char
|
|
pLastChar -= 1;
|
|
} // while
|
|
|
|
} // ImapRemoveTrailingHC
|
|
|
|
|
|
#ifdef DEAD
|
|
BOOL IsValidServerName(TCHAR *sz)
|
|
{
|
|
Assert(sz != NULL);
|
|
|
|
// bug 34513
|
|
if (FIsEmpty(sz))
|
|
return(FALSE);
|
|
|
|
// Bug #32532 - If the server name is the IP address, ie 157.54.44.183, then
|
|
// don't use this grammar to parse it.
|
|
if (-1 != inet_addr(sz))
|
|
return (TRUE);
|
|
|
|
while (*sz != 0)
|
|
{
|
|
if (!IsDBCSLeadByte(*sz))
|
|
{
|
|
if (*sz == _T(' '))
|
|
return(FALSE);
|
|
}
|
|
else
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
sz = CharNext(sz);
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
#endif // DEAD
|
|
|
|
/*
|
|
RFC 1034
|
|
<domain> ::= <subdomain> | " "
|
|
|
|
<subdomain> ::= <label> | <subdomain> "." <label>
|
|
|
|
<label> ::= <letter> [ [ <ldh-str> ] <let-dig> ]
|
|
|
|
<ldh-str> ::= <let-dig-hyp> | <let-dig-hyp> <ldh-str>
|
|
|
|
<let-dig-hyp> ::= <let-dig> | "-"
|
|
|
|
<let-dig> ::= <letter> | <digit>
|
|
|
|
<letter> ::= any one of the 52 alphabetic characters A through Z
|
|
in upper case and a through z in lower case
|
|
|
|
<digit> ::= any one of the ten digits 0 through 9
|
|
*/
|
|
|
|
#define ST_BOGUS -1
|
|
#define ST_LABEL 0
|
|
#define ST_DASH 1
|
|
#define ST_LD 2
|
|
|
|
#define ALPHABET 0
|
|
#define NUMERIC 1
|
|
#define DOT 2
|
|
#define DASH 3
|
|
|
|
static const int s_rgSvrState[4][3] =
|
|
{
|
|
// ST_LABEL ST_DASH ST_LD
|
|
// ALPHABET
|
|
{ST_LD, ST_LD, ST_LD},
|
|
// NUMERIC
|
|
{ST_LD, ST_LD, ST_LD},
|
|
// DOT
|
|
{ST_BOGUS, ST_BOGUS, ST_LABEL},
|
|
// DASH
|
|
{ST_BOGUS, ST_DASH, ST_DASH}
|
|
};
|
|
|
|
BOOL IsValidServerName(LPSTR sz)
|
|
{
|
|
int state, curr;
|
|
|
|
Assert(sz != NULL);
|
|
|
|
// bug 34513
|
|
if (FIsEmpty(sz))
|
|
return(FALSE);
|
|
|
|
// Bug #32532 - If the server name is the IP address, ie 157.54.44.183, then
|
|
// don't use this grammar to parse it.
|
|
if (-1 != inet_addr(sz))
|
|
return (TRUE);
|
|
|
|
state = ST_LABEL;
|
|
while (*sz != 0)
|
|
{
|
|
if (!IsDBCSLeadByte(*sz))
|
|
{
|
|
if (*sz == _T('.'))
|
|
curr = DOT;
|
|
else if (*sz == _T('-'))
|
|
curr = DASH;
|
|
else if ((*sz >= 'A' && *sz <= 'Z') || (*sz >= 'a' && *sz <= 'z'))
|
|
curr = ALPHABET;
|
|
else if (*sz >= '0' && *sz <= '9')
|
|
curr = NUMERIC;
|
|
else
|
|
return(FALSE);
|
|
|
|
state = s_rgSvrState[curr][state];
|
|
if (state == ST_BOGUS)
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
state = ST_BOGUS;
|
|
break;
|
|
}
|
|
|
|
sz = CharNext(sz);
|
|
}
|
|
|
|
return(state == ST_LD);
|
|
}
|
|
|
|
HRESULT ValidServerName(LPSTR szServer)
|
|
{
|
|
HRESULT hr;
|
|
int cbT;
|
|
|
|
cbT = lstrlen(szServer);
|
|
if (cbT == 0 || cbT >= CCHMAX_SERVER_NAME)
|
|
return(E_InvalidValue);
|
|
|
|
if (!IsValidServerName(szServer))
|
|
hr = S_NonStandardValue;
|
|
else
|
|
hr = S_OK;
|
|
|
|
return(hr);
|
|
}
|
|
|
|
IMNACCTAPI ValidEmailAddressParts(LPSTR lpAddress, LPSTR lpszAcct, DWORD cchSizeAcct, LPSTR lpszDomain, DWORD cchSizeDomain)
|
|
{
|
|
int cbT;
|
|
LPSTR szAddr = lpAddress;
|
|
// Step through the address looking for '@'. If there's an at sign in the middle
|
|
// of a string, this is close enough to being an internet address for me.
|
|
|
|
Assert(lpAddress != NULL);
|
|
|
|
cbT = lstrlen(lpAddress);
|
|
if (cbT == 0 || cbT >= CCHMAX_EMAIL_ADDRESS)
|
|
return(E_InvalidValue);
|
|
|
|
// Can't start with '@'
|
|
if (*lpAddress != '@')
|
|
{
|
|
while (*lpAddress)
|
|
{
|
|
// Internet addresses only allow pure ASCII. No high bits!
|
|
if (IsDBCSLeadByte(*lpAddress) || (*lpAddress & 0x80))
|
|
break;
|
|
|
|
if (*lpAddress == '@')
|
|
{
|
|
if (lpszAcct)
|
|
{
|
|
StrCpyN(lpszAcct, szAddr, cchSizeAcct);
|
|
lpszAcct[(lpAddress - szAddr)] = 0;
|
|
}
|
|
if (lpszDomain)
|
|
{
|
|
StrCpyN(lpszDomain, lpAddress +1, cchSizeDomain);
|
|
}
|
|
|
|
// Found the at sign. Is there anything following?
|
|
lpAddress++;
|
|
if (!IsValidServerName(lpAddress))
|
|
break;
|
|
else
|
|
return(S_OK);
|
|
}
|
|
|
|
lpAddress++;
|
|
}
|
|
}
|
|
|
|
return(S_NonStandardValue);
|
|
}
|
|
|
|
|
|
IMNACCTAPI ValidEmailAddress(LPSTR lpAddress)
|
|
{
|
|
int cbT;
|
|
|
|
// Step through the address looking for '@'. If there's an at sign in the middle
|
|
// of a string, this is close enough to being an internet address for me.
|
|
|
|
Assert(lpAddress != NULL);
|
|
|
|
cbT = lstrlen(lpAddress);
|
|
if (cbT == 0 || cbT >= CCHMAX_EMAIL_ADDRESS)
|
|
return(E_InvalidValue);
|
|
|
|
// Can't start with '@'
|
|
if (*lpAddress != '@')
|
|
{
|
|
while (*lpAddress)
|
|
{
|
|
// Internet addresses only allow pure ASCII. No high bits!
|
|
if (IsDBCSLeadByte(*lpAddress) || (*lpAddress & 0x80))
|
|
break;
|
|
|
|
if (*lpAddress == '@')
|
|
{
|
|
// Found the at sign. Is there anything following?
|
|
lpAddress++;
|
|
if (!IsValidServerName(lpAddress))
|
|
break;
|
|
else
|
|
return(S_OK);
|
|
}
|
|
|
|
lpAddress++;
|
|
}
|
|
}
|
|
|
|
return(S_NonStandardValue);
|
|
}
|
|
|
|
const static HELPMAP g_rgCtxMapLdapGen[] = {
|
|
{IDC_ACCOUNT_EDIT, IDH_WABLDAP_DIRSSERV_FRIENDLY_NAME},
|
|
{IDC_SERVER_EDIT, IDH_WABLDAP_DIRSSERV_NAME},
|
|
{IDC_LOGON_CHECK, IDH_INETCOMM_SERVER_REQ_LOGON},
|
|
{IDC_LOGONSSPI_CHECK, IDH_WABLDAP_DIRSSERV_AUTH_SICILY},
|
|
{IDC_ACCTNAME_EDIT, IDH_WABLDAP_DIRSSERV_AUTH_PASS_UNAME},
|
|
{IDC_ACCTNAME_STATIC, IDH_WABLDAP_DIRSSERV_AUTH_PASS_UNAME},
|
|
{IDC_ACCTPASS_EDIT, IDH_WABLDAP_DIRSSERV_AUTH_PASS_PASS},
|
|
{IDC_ACCTPASS_STATIC, IDH_WABLDAP_DIRSSERV_AUTH_PASS_PASS},
|
|
{IDC_RESOLVE_CHECK, IDH_WABLDAP_DIRSSERV_CHECK_AGAINST},
|
|
{IDC_STATIC0, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC1, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC2, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC3, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC4, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC5, IDH_INETCOMM_GROUPBOX},
|
|
{0, 0}};
|
|
|
|
INT_PTR CALLBACK DirServer_GeneralDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
BOOL fLogon;
|
|
int idsError;
|
|
ULONG cbSize;
|
|
HWND hwndT;
|
|
NMHDR *pnmhdr;
|
|
CAccount *pAcct;
|
|
TCHAR sz[CCHMAX_ACCT_PROP_SZ];
|
|
DWORD dw;
|
|
SVRDLGINFO *psdi;
|
|
|
|
pAcct = (CAccount *)GetWindowLongPtr(hwnd, DWLP_USER);
|
|
psdi = (SVRDLGINFO *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
// Get the ServerParams and store them in our extra bytes
|
|
pAcct = (CAccount *) ((PROPSHEETPAGE*) lParam)->lParam;
|
|
SetWindowLongPtr(hwnd, DWLP_USER, (LPARAM) pAcct);
|
|
|
|
Assert(psdi == NULL);
|
|
if (!MemAlloc((void **)&psdi, sizeof(SVRDLGINFO)))
|
|
return(-1);
|
|
ZeroMemory(psdi, sizeof(SVRDLGINFO));
|
|
psdi->sfType = SERVER_LDAP;
|
|
SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)psdi);
|
|
|
|
// Set Account Name
|
|
InitAcctPropEdit(GetDlgItem(hwnd, IDC_ACCOUNT_EDIT), pAcct, AP_ACCOUNT_NAME, CCHMAX_ACCOUNT_NAME - 1);
|
|
|
|
// set server name
|
|
InitAcctPropEdit(GetDlgItem(hwnd, IDC_SERVER_EDIT), pAcct, AP_LDAP_SERVER, CCHMAX_SERVER_NAME - 1);
|
|
|
|
if (FAILED(pAcct->GetPropDw(AP_LDAP_AUTHENTICATION, &dw)))
|
|
dw = LDAP_AUTH_ANONYMOUS;
|
|
if (dw != LDAP_AUTH_ANONYMOUS)
|
|
{
|
|
CheckDlgButton(hwnd, IDC_LOGON_CHECK, BST_CHECKED);
|
|
if (SUCCEEDED(pAcct->GetPropSz(AP_LDAP_USERNAME, sz, ARRAYSIZE(sz))))
|
|
SetDlgItemText(hwnd, IDC_ACCTNAME_EDIT, sz);
|
|
|
|
if (SUCCEEDED(pAcct->GetPropSz(AP_LDAP_PASSWORD, sz, ARRAYSIZE(sz))))
|
|
SetDlgItemText(hwnd, IDC_ACCTPASS_EDIT, sz);
|
|
|
|
if (dw != LDAP_AUTH_PASSWORD)
|
|
{
|
|
CheckDlgButton(hwnd, IDC_LOGONSSPI_CHECK, BST_CHECKED);
|
|
}
|
|
|
|
fLogon = TRUE;
|
|
}
|
|
else
|
|
fLogon = FALSE;
|
|
|
|
Server_EnableLogonWindows(hwnd, fLogon);
|
|
|
|
hwndT = GetDlgItem(hwnd, IDC_ACCTNAME_EDIT);
|
|
SetIntlFont(hwndT);
|
|
SendMessage(hwndT, EM_LIMITTEXT, CCHMAX_USERNAME - 1, 0L);
|
|
|
|
SendDlgItemMessage(hwnd, IDC_ACCTPASS_EDIT, EM_LIMITTEXT, CCHMAX_PASSWORD - 1, 0L);
|
|
|
|
if (SUCCEEDED(pAcct->GetPropDw(AP_LDAP_RESOLVE_FLAG, &dw)))
|
|
CheckDlgButton(hwnd, IDC_RESOLVE_CHECK, dw ? BST_CHECKED : BST_UNCHECKED);
|
|
|
|
if (SUCCEEDED(pAcct->GetPropDw(AP_SERVER_READ_ONLY, &dw)) && dw)
|
|
EnableWindow(GetDlgItem(hwnd, IDC_SERVER_EDIT), FALSE);
|
|
|
|
psdi->dwInit = (psdi->dwInit | PAGE_GEN);
|
|
PropSheet_UnChanged(GetParent(hwnd), hwnd);
|
|
return (TRUE);
|
|
|
|
case WM_HELP:
|
|
case WM_CONTEXTMENU:
|
|
return(OnContextHelp(hwnd, uMsg, wParam, lParam, g_rgCtxMapLdapGen));
|
|
|
|
case WM_DESTROY:
|
|
if (psdi != NULL)
|
|
MemFree(psdi);
|
|
break;
|
|
|
|
case PSM_QUERYSIBLINGS:
|
|
Assert(psdi != NULL);
|
|
Assert(pAcct != NULL);
|
|
return(HandleQuerySiblings(hwnd, psdi, pAcct, wParam, lParam));
|
|
|
|
case WM_COMMAND:
|
|
switch(LOWORD(wParam))
|
|
{
|
|
case IDC_LOGONSSPI_CHECK:
|
|
case IDC_LOGON_CHECK:
|
|
Server_EnableLogonWindows(hwnd, IsDlgButtonChecked(hwnd, IDC_LOGON_CHECK));
|
|
|
|
// fall through...
|
|
|
|
case IDC_RESOLVE_CHECK:
|
|
MarkPageDirty(hwnd, PAGE_GEN);
|
|
break;
|
|
|
|
default:
|
|
if (HIWORD(wParam) == EN_CHANGE)
|
|
{
|
|
if (LOWORD(wParam) == IDC_ACCOUNT_EDIT)
|
|
UpdateAcctTitle(hwnd, IDC_ACCOUNT_EDIT, ACCT_DIR_SERV);
|
|
MarkPageDirty(hwnd, PAGE_GEN);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case WM_NOTIFY:
|
|
pnmhdr = (NMHDR *)lParam;
|
|
switch (pnmhdr->code)
|
|
{
|
|
case PSN_APPLY:
|
|
// BEGIN validation
|
|
|
|
hwndT = GetDlgItem(hwnd, IDC_ACCOUNT_EDIT);
|
|
if (!ValidateAccountName(hwnd, hwndT, pAcct, &idsError))
|
|
return(InvalidAcctProp(hwnd, hwndT, idsError, iddDirServProp_General));
|
|
|
|
hwndT = GetDlgItem(hwnd, IDC_SERVER_EDIT);
|
|
if (!ValidateServerName(hwnd, hwndT, pAcct, AP_LDAP_SERVER, &idsError, pnmhdr->code == PSN_APPLY))
|
|
return(InvalidAcctProp(hwnd, hwndT, idsError, iddDirServProp_General));
|
|
|
|
if (IsDlgButtonChecked(hwnd, IDC_LOGON_CHECK) &&
|
|
!ValidateLogonSettings(hwnd, pAcct->m_dwDlgFlags, &hwndT, &idsError))
|
|
return(InvalidAcctProp(hwnd, hwndT, idsError, iddDirServProp_General));
|
|
|
|
// END validation
|
|
|
|
hwndT = GetDlgItem(hwnd, IDC_ACCOUNT_EDIT);
|
|
GetAccountName(hwndT, pAcct);
|
|
|
|
hwndT = GetDlgItem(hwnd, IDC_SERVER_EDIT);
|
|
GetServerName(hwndT, pAcct, AP_LDAP_SERVER);
|
|
|
|
GetLogonSettings(hwnd, pAcct, IsDlgButtonChecked(hwnd, IDC_LOGON_CHECK), SRV_LDAP);
|
|
|
|
pAcct->SetPropDw(AP_LDAP_RESOLVE_FLAG, (DWORD)!!IsDlgButtonChecked(hwnd, IDC_RESOLVE_CHECK));
|
|
|
|
PropSheet_UnChanged(GetParent(hwnd), hwnd);
|
|
dw = PAGE_GEN;
|
|
PropSheet_QuerySiblings(GetParent(hwnd), SM_SAVECHANGES, (LPARAM)&dw);
|
|
if (dw == -1)
|
|
{
|
|
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
|
|
return(TRUE);
|
|
}
|
|
break;
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
return (FALSE);
|
|
}
|
|
|
|
const static HELPMAP g_rgCtxMapLdapAdv[] = {
|
|
{IDC_LDAP_PORT_EDIT, IDH_LDAP_PORT_NUMBER},
|
|
{IDC_USEDEFAULTS_BUTTON, IDH_NEWS_SERV_ADV_USE_DEFAULTS},
|
|
{IDC_TIMEOUT_SLIDER, IDH_WABLDAP_SEARCH_TIMEOUT},
|
|
{IDC_MATCHES_EDIT, IDH_WABLDAP_SEARCH_LIMIT},
|
|
{IDC_SEARCHBASE_EDIT, IDH_LDAP_SEARCH_BASE},
|
|
{IDC_SECURECONNECT_BUTTON, IDH_MAIL_ADV_REQ_SSL},
|
|
{IDC_SIMPLESEARCH_BUTTON, IDH_WABLDAP_USE_SIMPLE_SEARCH},
|
|
{IDC_STATIC0, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC1, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC2, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC3, IDH_INETCOMM_GROUPBOX},
|
|
{0, 0}};
|
|
|
|
INT_PTR CALLBACK DirServer_AdvancedDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
NMHDR *pnmhdr;
|
|
TCHAR sz[CCHMAX_ACCT_PROP_SZ];
|
|
DWORD dw, dwPort, dwMatches;
|
|
WORD code, id;
|
|
SERVER_TYPE sfType;
|
|
HWND hwndT;
|
|
BOOL fTrans, fSecure, fEnable, flag, fIMAP, fSimple;
|
|
IImnAccount *pAcct = (IImnAccount *)GetWindowLongPtr(hwnd, DWLP_USER);
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
// Get the ServerParams and store them in our extra bytes
|
|
pAcct = (IImnAccount*) ((PROPSHEETPAGE*) lParam)->lParam;
|
|
SetWindowLongPtr(hwnd, DWLP_USER, (LPARAM) pAcct);
|
|
|
|
// Load the controls with what information we have
|
|
if (SUCCEEDED(pAcct->GetPropDw(AP_LDAP_PORT, &dw)))
|
|
SetDlgItemInt(hwnd, IDC_LDAP_PORT_EDIT, dw, FALSE);
|
|
SendDlgItemMessage(hwnd, IDC_LDAP_PORT_EDIT, EM_LIMITTEXT, PORT_CCHMAX, 0);
|
|
if (SUCCEEDED(pAcct->GetPropDw(AP_LDAP_SIMPLE_SEARCH, (LPDWORD)&fSimple)) && fSimple)
|
|
CheckDlgButton(hwnd, IDC_SIMPLESEARCH_BUTTON, TRUE);
|
|
if (SUCCEEDED(pAcct->GetPropDw(AP_LDAP_SSL, (LPDWORD)&fSecure)) && fSecure)
|
|
{
|
|
EnableWindow(GetDlgItem(hwnd, IDC_USEDEFAULTS_BUTTON), dw != DEF_SLDAPPORT);
|
|
CheckDlgButton(hwnd, IDC_SECURECONNECT_BUTTON, TRUE);
|
|
}
|
|
else
|
|
{
|
|
EnableWindow(GetDlgItem(hwnd, IDC_USEDEFAULTS_BUTTON), dw != DEF_LDAPPORT);
|
|
}
|
|
|
|
if (FAILED(pAcct->GetPropDw(AP_LDAP_SEARCH_RETURN, (LPDWORD)&dw)))
|
|
dw = MATCHES_DEFAULT;
|
|
if (dw < MATCHES_MIN)
|
|
dw = MATCHES_MIN;
|
|
else if (dw > MATCHES_MAX)
|
|
dw = MATCHES_MAX;
|
|
InitCheckCounter(dw, hwnd, NULL, IDC_MATCHES_EDIT, IDC_MATCHES_SPIN,
|
|
MATCHES_MIN, MATCHES_MAX, MATCHES_DEFAULT);
|
|
|
|
// Server Timeout
|
|
dw = 0;
|
|
pAcct->GetPropDw(AP_LDAP_TIMEOUT, &dw);
|
|
InitTimeoutSlider(GetDlgItem(hwnd, IDC_TIMEOUT_SLIDER),
|
|
GetDlgItem(hwnd, IDC_TIMEOUT_STATIC), dw);
|
|
|
|
InitAcctPropEdit(GetDlgItem(hwnd, IDC_SEARCHBASE_EDIT), pAcct,
|
|
AP_LDAP_SEARCH_BASE, CCHMAX_SEARCH_BASE - 1);
|
|
|
|
PropSheet_QuerySiblings(GetParent(hwnd), SM_INITIALIZED, PAGE_ADV);
|
|
PropSheet_UnChanged(GetParent(hwnd), hwnd);
|
|
return (TRUE);
|
|
|
|
case WM_HELP:
|
|
case WM_CONTEXTMENU:
|
|
return(OnContextHelp(hwnd, uMsg, wParam, lParam, g_rgCtxMapLdapAdv));
|
|
|
|
case WM_HSCROLL:
|
|
// Update the text beside the slider
|
|
SetTimeoutString(GetDlgItem(hwnd, IDC_TIMEOUT_STATIC),
|
|
(UINT) SendMessage((HWND) lParam, TBM_GETPOS, 0, 0));
|
|
|
|
MarkPageDirty(hwnd, PAGE_ADV);
|
|
return (TRUE);
|
|
|
|
case WM_COMMAND:
|
|
code = HIWORD(wParam);
|
|
id = LOWORD(wParam);
|
|
fSecure = IsDlgButtonChecked(hwnd, IDC_SECURECONNECT_BUTTON);
|
|
fSimple = IsDlgButtonChecked(hwnd, IDC_SIMPLESEARCH_BUTTON);
|
|
|
|
switch (id)
|
|
{
|
|
case IDC_MATCHES_EDIT:
|
|
case IDC_SEARCHBASE_EDIT:
|
|
if (code == EN_CHANGE)
|
|
MarkPageDirty(hwnd, PAGE_ADV);
|
|
break;
|
|
|
|
case IDC_LDAP_PORT_EDIT:
|
|
if (code == EN_CHANGE)
|
|
{
|
|
dw = GetDlgItemInt(hwnd, IDC_LDAP_PORT_EDIT, &fTrans, FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_USEDEFAULTS_BUTTON),
|
|
!fTrans || (fSecure ? (dw != DEF_SLDAPPORT) : (dw != DEF_LDAPPORT)));
|
|
|
|
MarkPageDirty(hwnd, PAGE_ADV);
|
|
}
|
|
break;
|
|
|
|
case IDC_SIMPLESEARCH_BUTTON:
|
|
case IDC_SECURECONNECT_BUTTON:
|
|
case IDC_USEDEFAULTS_BUTTON:
|
|
// Reset the settings on this page to the default values.
|
|
SetDlgItemInt(hwnd, IDC_LDAP_PORT_EDIT, fSecure ? DEF_SLDAPPORT : DEF_LDAPPORT, FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_USEDEFAULTS_BUTTON), FALSE);
|
|
|
|
MarkPageDirty(hwnd, PAGE_ADV);
|
|
|
|
SetFocus(GetDlgItem(hwnd, IDC_LDAP_PORT_EDIT));
|
|
break;
|
|
}
|
|
return (TRUE);
|
|
|
|
case WM_NOTIFY:
|
|
pnmhdr = (NMHDR *)lParam;
|
|
switch (pnmhdr->code)
|
|
{
|
|
case PSN_APPLY:
|
|
// BEGIN validation
|
|
|
|
dwPort = GetDlgItemInt(hwnd, IDC_LDAP_PORT_EDIT, &fTrans, FALSE);
|
|
if (!fTrans || dwPort == 0)
|
|
{
|
|
hwndT = GetDlgItem(hwnd, IDC_LDAP_PORT_EDIT);
|
|
return(InvalidAcctProp(hwnd, hwndT, idsErrPortNum, iddDirServProp_Advanced));
|
|
}
|
|
|
|
dwMatches = GetDlgItemInt(hwnd, IDC_MATCHES_EDIT, &fTrans, FALSE);
|
|
if (!fTrans || dwMatches < MATCHES_MIN || dwMatches > MATCHES_MAX)
|
|
{
|
|
hwndT = GetDlgItem(hwnd, IDC_MATCHES_EDIT);
|
|
return(InvalidAcctProp(hwnd, hwndT, idsErrMatches, iddDirServProp_Advanced));
|
|
}
|
|
|
|
// END validation
|
|
|
|
pAcct->SetPropDw(AP_LDAP_PORT, dwPort);
|
|
pAcct->SetPropDw(AP_LDAP_SEARCH_RETURN, dwMatches);
|
|
|
|
dw = IsDlgButtonChecked(hwnd, IDC_SECURECONNECT_BUTTON);
|
|
pAcct->SetPropDw(AP_LDAP_SSL, dw);
|
|
|
|
dw = IsDlgButtonChecked(hwnd, IDC_SIMPLESEARCH_BUTTON);
|
|
pAcct->SetPropDw(AP_LDAP_SIMPLE_SEARCH, dw);
|
|
|
|
dw = GetTimeoutFromSlider(GetDlgItem(hwnd, IDC_TIMEOUT_SLIDER));
|
|
pAcct->SetPropDw(AP_LDAP_TIMEOUT, dw);
|
|
|
|
dw = GetWindowText(GetDlgItem(hwnd, IDC_SEARCHBASE_EDIT), sz, ARRAYSIZE(sz));
|
|
UlStripWhitespace(sz, TRUE, TRUE, &dw);
|
|
if (dw == 0)
|
|
pAcct->SetProp(AP_LDAP_SEARCH_BASE, NULL, 0);
|
|
else
|
|
pAcct->SetPropSz(AP_LDAP_SEARCH_BASE, sz);
|
|
|
|
PropSheet_UnChanged(GetParent(hwnd), hwnd);
|
|
dw = PAGE_ADV;
|
|
PropSheet_QuerySiblings(GetParent(hwnd), SM_SAVECHANGES, (LPARAM)&dw);
|
|
if (dw == -1)
|
|
{
|
|
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
|
|
return(TRUE);
|
|
}
|
|
break;
|
|
}
|
|
return (TRUE);
|
|
}
|
|
|
|
return (FALSE);
|
|
}
|
|
|
|
// BEGIN bug 21535
|
|
|
|
// Used for modifying propsheet template
|
|
const TCHAR c_szComctl[] = TEXT("comctl32.dll");
|
|
#define DLG_PROPSHEET 1006 // Bad hack...assumes comctl's res id
|
|
|
|
typedef struct
|
|
{
|
|
int inumLang;
|
|
WORD wLang;
|
|
} ENUMLANGDATA;
|
|
|
|
//
|
|
// EnumResLangProc
|
|
//
|
|
// purpose: a callback function for EnumResourceLanguages().
|
|
// look into the type passed in and if it is RT_DIALOG
|
|
// copy the lang of the first resource to our buffer
|
|
// this also counts # of lang if more than one of them
|
|
// are passed in
|
|
//
|
|
// IN: lparam: ENUMLANGDATA - defined at the top of this file
|
|
//
|
|
BOOL CALLBACK EnumResLangProc(HINSTANCE hinst, LPCTSTR lpszType, LPCTSTR lpszName, WORD wIdLang, LPARAM lparam)
|
|
{
|
|
ENUMLANGDATA *pel = (ENUMLANGDATA *)lparam;
|
|
|
|
Assert(pel);
|
|
|
|
if (lpszType == RT_DIALOG)
|
|
{
|
|
if (pel->inumLang == 0)
|
|
pel->wLang = wIdLang;
|
|
|
|
pel->inumLang++;
|
|
}
|
|
return TRUE; // continue until we get all langs...
|
|
}
|
|
|
|
//
|
|
// GetDialogLang
|
|
//
|
|
// purpose: fill out the ENUMLANGDATA (see top of this file) with the
|
|
// # of available langs in the module passed in, and the langid
|
|
// of what system enumerates first. i.e, the langid eq. to what
|
|
// the module localized if the module is localized in single
|
|
// language
|
|
//
|
|
// IN: hinstCpl - this is supposed to be a instance handle of inetcpl.
|
|
// pel - a pointer to the buffer we fill out
|
|
//
|
|
// RESULT: TRUE - everything cool, continue with adjusting property sheet
|
|
// FALSE - somethings wrong, abort adjusting property sheet.
|
|
//
|
|
BOOL GetDialogLang(HMODULE hinstCpl, ENUMLANGDATA *pel)
|
|
{
|
|
Assert(pel);
|
|
|
|
// Get the possible languages the template localized in.
|
|
EnumResourceLanguages(hinstCpl, RT_DIALOG, MAKEINTRESOURCE(iddMailSvrProp_General), (ENUMRESLANGPROC)EnumResLangProc, (LPARAM)pel);
|
|
|
|
return TRUE;
|
|
}
|
|
//
|
|
// PropSheetProc
|
|
//
|
|
// purpose: the callback function to modify resource template
|
|
// in order to make DLG_PROPSHEET's lang mathed with ours.
|
|
// there could be a general way but for now this is
|
|
// an ugly hack from inetcpl.
|
|
//
|
|
//
|
|
int CALLBACK PropSheetProc (HWND hwndDlg, UINT uMsg, LPARAM lParam)
|
|
{
|
|
LPVOID pTemplate = (LPVOID)lParam;
|
|
LPVOID pTmpInLang;
|
|
ENUMLANGDATA el = {0,0};
|
|
HINSTANCE hComctl;
|
|
HRSRC hrsrc;
|
|
HGLOBAL hgmem;
|
|
DWORD cbNewTmp;
|
|
|
|
// Comm ctrl gives us a chance to recreate resource by this msg.
|
|
if (uMsg==PSCB_PRECREATE && pTemplate)
|
|
{
|
|
// enumrate any possible language used in this cpl for dialogs
|
|
if (!GetDialogLang(g_hInstRes, &el))
|
|
return 0; // failed to get resouce name
|
|
|
|
if (el.inumLang > 1)
|
|
{
|
|
// we've got multi-language templates
|
|
// let comctl load the one that matches our thread langid.
|
|
return 0;
|
|
}
|
|
if (GetSystemDefaultLangID() != el.wLang)
|
|
{
|
|
// Get comctl32's module handle
|
|
hComctl = GetModuleHandle(c_szComctl);
|
|
if (hComctl)
|
|
{
|
|
// this is a horrible hack because we assume DLG_PROPSHEET
|
|
hrsrc = FindResourceEx(hComctl, RT_DIALOG, MAKEINTRESOURCE(DLG_PROPSHEET), el.wLang);
|
|
if (hrsrc)
|
|
{
|
|
if (hgmem = LoadResource(hComctl, hrsrc))
|
|
{
|
|
pTmpInLang = LockResource(hgmem);
|
|
}
|
|
if (pTmpInLang)
|
|
{
|
|
cbNewTmp = SizeofResource(hComctl, hrsrc);
|
|
CopyMemory(pTemplate, pTmpInLang, cbNewTmp);
|
|
}
|
|
if (hgmem && pTmpInLang)
|
|
{
|
|
UnlockResource(hgmem);
|
|
return 1; // everything went ok.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// END bug 21535
|
|
|
|
const static HELPMAP g_rgCtxMapSmtpAuth[] = {
|
|
{IDC_USEMAILSETTINGS, IDH_MAIL_OUT_SERV_SAME},
|
|
{IDC_ACCTNAME_STATIC, IDH_MAIL_SERV_POP3_ACCT},
|
|
{IDC_ACCTNAME_EDIT, IDH_MAIL_SERV_POP3_ACCT},
|
|
{IDC_ACCTPASS_STATIC, IDH_MAIL_SERV_PWORD},
|
|
{IDC_ACCTPASS_EDIT, IDH_MAIL_SERV_PWORD},
|
|
{IDC_LOGONSSPI_CHECK, IDH_MAIL_LOGON_USING_SICILY},
|
|
{IDC_REMEMBER_PASSWORD, 503},
|
|
{IDC_STATIC0, IDH_INETCOMM_GROUPBOX},
|
|
{IDC_STATIC1, IDH_INETCOMM_GROUPBOX},
|
|
{0, 0}};
|
|
|
|
INT_PTR CALLBACK SmtpLogonSettingsDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
LPSMTPAUTHINFO pInfo=(LPSMTPAUTHINFO)GetWndThisPtr(hwnd);
|
|
CHAR szUserName[CCHMAX_USERNAME];
|
|
CHAR szPassword[CCHMAX_PASSWORD];
|
|
BOOL fPromptPassword, fEnable;
|
|
DWORD cbSize;
|
|
SMTPAUTHTYPE authtype;
|
|
|
|
switch(uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
// Get pInfo
|
|
pInfo = (LPSMTPAUTHINFO)lParam;
|
|
Assert(pInfo && pInfo->authtype != SMTP_AUTH_NONE);
|
|
|
|
// SMTP_AUTH_SICILY
|
|
if (SMTP_AUTH_SICILY == pInfo->authtype)
|
|
{
|
|
CheckDlgButton(hwnd, IDC_SPECIFYSETTINGS, BST_CHECKED);
|
|
CheckDlgButton(hwnd, IDC_LOGONSSPI_CHECK, BST_CHECKED);
|
|
SetDlgItemText(hwnd, IDC_ACCTNAME_EDIT, pInfo->szUserName);
|
|
SetDlgItemText(hwnd, IDC_ACCTPASS_EDIT, pInfo->szPassword);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ACCTPASS_EDIT), !pInfo->fPromptPassword);
|
|
}
|
|
|
|
// SMTP_AUTH_USE_POP3ORIMAP_SETTINGS
|
|
else if (SMTP_AUTH_USE_POP3ORIMAP_SETTINGS == pInfo->authtype)
|
|
{
|
|
// Check Logon Using Radio
|
|
CheckDlgButton(hwnd, IDC_USEMAILSETTINGS, BST_CHECKED);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_LOGONSSPI_CHECK), FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ACCTNAME_EDIT), FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ACCTPASS_EDIT), FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_REMEMBER_PASSWORD), FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ACCTNAME_STATIC), FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ACCTPASS_STATIC), FALSE);
|
|
}
|
|
|
|
// SMTP_AUTH_USE_SMTP_SETTINGS
|
|
else if (SMTP_AUTH_USE_SMTP_SETTINGS == pInfo->authtype)
|
|
{
|
|
CheckDlgButton(hwnd, IDC_SPECIFYSETTINGS, BST_CHECKED);
|
|
SetDlgItemText(hwnd, IDC_ACCTNAME_EDIT, pInfo->szUserName);
|
|
SetDlgItemText(hwnd, IDC_ACCTPASS_EDIT, pInfo->szPassword);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ACCTPASS_EDIT), !pInfo->fPromptPassword);
|
|
}
|
|
else
|
|
Assert(FALSE);
|
|
|
|
CheckDlgButton(hwnd, IDC_REMEMBER_PASSWORD, FALSE == pInfo->fPromptPassword);
|
|
|
|
SetWndThisPtr(hwnd, pInfo);
|
|
break;
|
|
|
|
case WM_HELP:
|
|
case WM_CONTEXTMENU:
|
|
return(OnContextHelp(hwnd, uMsg, wParam, lParam, g_rgCtxMapSmtpAuth));
|
|
|
|
case WM_COMMAND:
|
|
switch(GET_WM_COMMAND_ID(wParam,lParam))
|
|
{
|
|
case IDC_LOGONSSPI_CHECK:
|
|
case IDC_SPECIFYSETTINGS:
|
|
case IDC_USEMAILSETTINGS:
|
|
if (IsDlgButtonChecked(hwnd, IDC_SPECIFYSETTINGS))
|
|
{
|
|
fPromptPassword = (FALSE == IsDlgButtonChecked(hwnd, IDC_REMEMBER_PASSWORD));
|
|
EnableWindow(GetDlgItem(hwnd, IDC_LOGONSSPI_CHECK), TRUE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ACCTNAME_EDIT), TRUE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ACCTPASS_EDIT), (FALSE == fPromptPassword));
|
|
EnableWindow(GetDlgItem(hwnd, IDC_REMEMBER_PASSWORD), TRUE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ACCTNAME_STATIC), TRUE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ACCTPASS_STATIC), TRUE);
|
|
}
|
|
else if (IsDlgButtonChecked(hwnd, IDC_USEMAILSETTINGS))
|
|
{
|
|
EnableWindow(GetDlgItem(hwnd, IDC_LOGONSSPI_CHECK), FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ACCTNAME_EDIT), FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ACCTPASS_EDIT), FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_REMEMBER_PASSWORD), FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ACCTNAME_STATIC), FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ACCTPASS_STATIC), FALSE);
|
|
}
|
|
break;
|
|
|
|
case IDC_REMEMBER_PASSWORD:
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ACCTPASS_EDIT),
|
|
IsDlgButtonChecked(hwnd, IDC_REMEMBER_PASSWORD));
|
|
break;
|
|
|
|
case IDCANCEL:
|
|
EndDialog(hwnd, IDCANCEL);
|
|
return 1;
|
|
|
|
case IDOK:
|
|
// SMTP_AUTH_USE_POP3ORIMAP_SETTINGS
|
|
if (IsDlgButtonChecked(hwnd, IDC_USEMAILSETTINGS))
|
|
{
|
|
// No Change
|
|
if (SMTP_AUTH_USE_POP3ORIMAP_SETTINGS != pInfo->authtype)
|
|
{
|
|
pInfo->authtype = SMTP_AUTH_USE_POP3ORIMAP_SETTINGS;
|
|
pInfo->fDirty = TRUE;
|
|
EndDialog(hwnd, IDOK);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
// Otherwise, use specified settings
|
|
else
|
|
{
|
|
// Get User Name and Password
|
|
GetDlgItemText(hwnd, IDC_ACCTNAME_EDIT, szUserName, ARRAYSIZE(szUserName));
|
|
|
|
// Cleanup szUserName
|
|
cbSize = lstrlen(szUserName);
|
|
UlStripWhitespace(szUserName, TRUE, TRUE, &cbSize);
|
|
if (cbSize == 0)
|
|
{
|
|
// Error
|
|
AcctMessageBox(hwnd, MAKEINTRESOURCE(idsAccountManager), MAKEINTRESOURCE(idsEnterAcctName), 0, MB_ICONEXCLAMATION | MB_OK);
|
|
SetFocus(GetDlgItem(hwnd, IDC_ACCTNAME_EDIT));
|
|
return 1;
|
|
}
|
|
|
|
// SMTP_AUTH_SICILY
|
|
if (IsDlgButtonChecked(hwnd, IDC_LOGONSSPI_CHECK))
|
|
authtype = SMTP_AUTH_SICILY;
|
|
else
|
|
authtype = SMTP_AUTH_USE_SMTP_SETTINGS;
|
|
|
|
// Get the Password
|
|
GetDlgItemText(hwnd, IDC_ACCTPASS_EDIT, szPassword, ARRAYSIZE(szPassword));
|
|
fPromptPassword = (FALSE == IsDlgButtonChecked(hwnd, IDC_REMEMBER_PASSWORD));
|
|
|
|
// No Change ?
|
|
if (authtype != pInfo->authtype ||
|
|
lstrcmpi(pInfo->szUserName, szUserName) != 0 ||
|
|
fPromptPassword != pInfo->fPromptPassword ||
|
|
lstrcmpi(pInfo->szPassword, szPassword) != 0)
|
|
{
|
|
pInfo->authtype = authtype;
|
|
StrCpyN(pInfo->szUserName, szUserName, ARRAYSIZE(pInfo->szUserName));
|
|
StrCpyN(pInfo->szPassword, szPassword, ARRAYSIZE(pInfo->szPassword));
|
|
pInfo->fPromptPassword = fPromptPassword;
|
|
pInfo->fDirty = TRUE;
|
|
}
|
|
}
|
|
|
|
EndDialog(hwnd, IDOK);
|
|
return 1;
|
|
}
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
HRESULT EscapeSpaces(LPCSTR psz, LPSTR pszOut, DWORD *pcch)
|
|
{
|
|
LPCSTR pch;
|
|
LPSTR pchOut;
|
|
DWORD cch, cchOut;
|
|
|
|
pchOut = pszOut;
|
|
cch = *pcch;
|
|
cchOut = 0;
|
|
|
|
for (pch = psz; *pch; pch++)
|
|
{
|
|
if (*pch == ' ')
|
|
{
|
|
cchOut += 3;
|
|
if (cchOut > cch)
|
|
return(E_FAIL);
|
|
*pchOut++ = '%';
|
|
*pchOut++ = '2';
|
|
*pchOut++ = '0';
|
|
}
|
|
else
|
|
{
|
|
cchOut++;
|
|
if (cchOut > cch)
|
|
return(E_FAIL);
|
|
*pchOut++ = *pch;
|
|
}
|
|
}
|
|
|
|
cchOut++;
|
|
if (cchOut > cch)
|
|
return(E_FAIL);
|
|
|
|
*pchOut = 0;
|
|
*pcch = cchOut;
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
void GetDigitalID(HWND hwnd)
|
|
{
|
|
HRESULT hr;
|
|
TCHAR szName[CCHMAX_DISPLAY_NAME];
|
|
TCHAR szEmail[CCHMAX_EMAIL_ADDRESS];
|
|
TCHAR szTemp[INTERNET_MAX_URL_LENGTH];
|
|
TCHAR szURL[INTERNET_MAX_URL_LENGTH];
|
|
DWORD cchOut = ARRAYSIZE(szURL);
|
|
|
|
PropSheet_QuerySiblings(GetParent(hwnd), MSM_GETDISPLAYNAME, (LPARAM)szName);
|
|
PropSheet_QuerySiblings(GetParent(hwnd), MSM_GETEMAILADDRESS, (LPARAM)szEmail);
|
|
|
|
LoadString(g_hInstRes, idsGetCertURL, szURL, ARRAYSIZE(szURL));
|
|
wnsprintf(szTemp, ARRAYSIZE(szTemp), szURL, szName, szEmail);
|
|
|
|
// NOTE: we shellexec iexplore.exe here NOT the default handler for http://
|
|
// links. We have to make sure we launch this link with IE even if
|
|
// netscape is the browser. see georgeh for explanation of why.
|
|
if (SUCCEEDED(EscapeSpaces(szTemp, szURL, &cchOut)))
|
|
ShellExecuteA(NULL, c_szOpen, c_szIexplore, szURL, NULL, SW_SHOWNORMAL);
|
|
}
|
|
|
|
DWORD DwGenerateTrustedChain(
|
|
HWND hwnd,
|
|
DWORD dwFlags,
|
|
PCCERT_CONTEXT pcCertToTest,
|
|
DWORD dwToIgnore,
|
|
BOOL fFullSearch,
|
|
DWORD * pcChain,
|
|
PCCERT_CONTEXT ** prgChain)
|
|
{
|
|
DWORD dwErr = 0;
|
|
GUID guidAction = CERT_CERTIFICATE_ACTION_VERIFY;
|
|
CERT_VERIFY_CERTIFICATE_TRUST trust = {0};
|
|
WINTRUST_BLOB_INFO blob = {0};
|
|
WINTRUST_DATA data = {0};
|
|
IMimeBody * pBody;
|
|
PROPVARIANT var;
|
|
HCERTSTORE rgCAs[3] = {0};
|
|
HCERTSTORE *pCAs = NULL;
|
|
HCERTSTORE hMsg = NULL;
|
|
|
|
Assert(pcCertToTest);
|
|
|
|
data.cbStruct = sizeof(WINTRUST_DATA);
|
|
data.pPolicyCallbackData = NULL;
|
|
data.pSIPClientData = NULL;
|
|
data.dwUIChoice = WTD_UI_NONE;
|
|
data.fdwRevocationChecks = WTD_REVOKE_NONE;
|
|
data.dwUnionChoice = WTD_CHOICE_BLOB;
|
|
data.pBlob = &blob;
|
|
|
|
blob.cbStruct = sizeof(WINTRUST_BLOB_INFO);
|
|
blob.pcwszDisplayName = NULL;
|
|
blob.cbMemObject = sizeof(trust);
|
|
blob.pbMemObject = (LPBYTE)&trust;
|
|
|
|
trust.cbSize = sizeof(trust);
|
|
trust.pccert = pcCertToTest;
|
|
trust.dwFlags = (fFullSearch ? CERT_TRUST_DO_FULL_SEARCH : 0);
|
|
trust.pdwErrors = &dwErr;
|
|
trust.pszUsageOid = szOID_PKIX_KP_EMAIL_PROTECTION;
|
|
trust.pcChain = pcChain;
|
|
trust.prgChain = prgChain;
|
|
|
|
trust.dwFlags |= dwFlags;
|
|
|
|
//cvct.prgdwErrors
|
|
trust.dwIgnoreErr = dwToIgnore;
|
|
if (pCAs)
|
|
{
|
|
trust.dwFlags |= CERT_TRUST_ADD_CERT_STORES;
|
|
trust.rghstoreCAs = pCAs;
|
|
trust.cStores = 3;
|
|
}
|
|
|
|
LONG lr = WinVerifyTrust(hwnd, &guidAction, (void*)&data);
|
|
|
|
if(((LRESULT) lr) == CERT_E_REVOKED)
|
|
dwErr = CERT_VALIDITY_CERTIFICATE_REVOKED;
|
|
|
|
else if(((LRESULT) lr) == CERT_E_REVOCATION_FAILURE)
|
|
{
|
|
Assert(FALSE);
|
|
dwErr = CERT_VALIDITY_NO_CRL_FOUND;
|
|
}
|
|
else if (0 > lr) // WinVerifyTrust(hwnd, &guidAction, (void*)&data))
|
|
dwErr = CERT_VALIDITY_NO_TRUST_DATA;
|
|
|
|
if (dwErr)
|
|
DOUTL(DOUTL_CRYPT, "Trust provider returned 0x%.8lx", dwErr);
|
|
|
|
// Filter these out since the trust provider isn't.
|
|
dwErr &= ~dwToIgnore;
|
|
|
|
CertCloseStore(rgCAs[0], 0);
|
|
CertCloseStore(rgCAs[1], 0);
|
|
CertCloseStore(rgCAs[2], 0);
|
|
|
|
return dwErr;
|
|
}
|
|
|