1414 lines
45 KiB
C++
1414 lines
45 KiB
C++
/*++
|
|
|
|
Copyright (c) 1996 Microsoft Corporation
|
|
|
|
Module Name :
|
|
|
|
smtpinst.hxx
|
|
|
|
Abstract:
|
|
|
|
This file contains type definitions for multiple instance
|
|
support.
|
|
|
|
Author:
|
|
|
|
Johnson Apacible (JohnsonA) Jun-04-1996
|
|
|
|
Revision History:
|
|
|
|
Rohan Phillips (RohanP) Feb-05-1997 - modified for SMTP
|
|
David Howell (Dhowell) May - 1997 - added Etrn Logic
|
|
Nimish Khanolkar(NimishK) Jan - 1998 - modified for CAPI store cert
|
|
--*/
|
|
|
|
#ifndef _SMTPINST_H_
|
|
#define _SMTPINST_H_
|
|
|
|
#include <iiscert.hxx>
|
|
#include <iisctl.hxx>
|
|
#include <capiutil.hxx>
|
|
#include <certnotf.hxx>
|
|
#include <sslinfo.hxx>
|
|
|
|
|
|
#include "dirnot.hxx"
|
|
#include "conn.hxx"
|
|
#include "shash.hxx"
|
|
#include <asynccon.hxx>
|
|
#include "asyncmx.hxx"
|
|
#include <cdns.h>
|
|
#include "smtpdns.hxx"
|
|
#include <mapctxt.h>
|
|
#include <smtpevent.h>
|
|
#include "cpropbag.h"
|
|
#include "seomgr.h"
|
|
|
|
//
|
|
// Service name to use for KERBEROS Authentication service names
|
|
//
|
|
|
|
#define SMTP_SERVICE_PRINCIPAL_PREFIX "SMTP"
|
|
|
|
interface IEventRouter;
|
|
interface IEventManager;
|
|
|
|
class SMTP_ENDPOINT;
|
|
class FILTER_LIST;
|
|
class INSTANCE_INFO_LIST;
|
|
|
|
//
|
|
// Maximum IP address stored for the instance, 20 seems to be a commonly
|
|
// used value both for DNS and remoteq
|
|
//
|
|
|
|
#define _MAX_HOSTENT_IP_ADDRESSES 20
|
|
|
|
//
|
|
// Callback function to use when SSL key info changes
|
|
//
|
|
|
|
extern SERVICE_MAPPING_CONTEXT g_SmtpSMC;
|
|
|
|
typedef BOOL (*PFN_SF_NOTIFY)(DWORD dwNotificationCode, PVOID pvInstance);
|
|
extern PFN_SF_NOTIFY g_pSslKeysNotify;
|
|
|
|
#define CERT_STATUS_UNKNOWN 0
|
|
#define CERT_STATUS_VALID 1
|
|
#define CERT_STATUS_INVALID 2
|
|
|
|
|
|
//
|
|
// This is the SMTP version of the IIS_SERVER
|
|
//
|
|
|
|
static const CHAR *szConnectResponseDefault = "";
|
|
|
|
typedef struct _SMTP_VROOT_ENTRY {
|
|
char szVRoot[MAX_PATH];
|
|
LIST_ENTRY list;
|
|
} SMTP_VROOT_ENTRY, *PSMTP_VROOT_ENTRY;
|
|
|
|
class SMTP_IIS_SERVICE : public IIS_SERVICE {
|
|
|
|
public:
|
|
|
|
//
|
|
// Virtuals
|
|
//
|
|
|
|
virtual BOOL AddInstanceInfo(
|
|
IN DWORD dwInstance,
|
|
IN BOOL fMigrateRoots
|
|
);
|
|
|
|
virtual DWORD DisconnectUsersByInstance(
|
|
IN IIS_SERVER_INSTANCE * pInstance
|
|
);
|
|
|
|
virtual VOID SMTP_IIS_SERVICE::MDChangeNotify(
|
|
MD_CHANGE_OBJECT * pcoChangeList
|
|
);
|
|
|
|
virtual DWORD GetServiceConfigInfoSize(IN DWORD dwLevel);
|
|
|
|
void AcquireServiceShareLock(void)
|
|
{
|
|
m_Lock.ShareLock();
|
|
}
|
|
|
|
void ReleaseServiceShareLock(void)
|
|
{
|
|
m_Lock.ShareUnlock();
|
|
}
|
|
|
|
void AcquireServiceExclusiveLock(void)
|
|
{
|
|
m_Lock.ExclusiveLock();
|
|
}
|
|
|
|
void ReleaseServiceExclusiveLock(void)
|
|
{
|
|
m_Lock.ExclusiveUnlock();
|
|
}
|
|
|
|
void StartHintFunction(void);
|
|
|
|
SMTP_IIS_SERVICE(
|
|
IN LPCTSTR lpszServiceName,
|
|
IN LPCSTR lpszModuleName,
|
|
IN LPCSTR lpszRegParamKey,
|
|
IN DWORD dwServiceId,
|
|
IN ULONGLONG SvcLocId,
|
|
IN BOOL MultipleInstanceSupport,
|
|
IN DWORD cbAcceptExRecvBuffer,
|
|
IN ATQ_CONNECT_CALLBACK pfnConnect,
|
|
IN ATQ_COMPLETION pfnConnectEx,
|
|
IN ATQ_COMPLETION pfnIoCompletion
|
|
);
|
|
|
|
PLIST_ENTRY GetInfoList() {return &m_InstanceInfoList;}
|
|
char * QueryTcpipName() {return m_szTcpipName;}
|
|
void SetTcpipName(char * str) {lstrcpyn(m_szTcpipName, str, MAX_PATH);}
|
|
void DecSystemRoutingThreads(void) {InterlockedDecrement(&m_cCurrentSystemRoutingThreads);}
|
|
BOOL IncSystemRoutingThreads(void)
|
|
{
|
|
DWORD NewValue;
|
|
|
|
NewValue = InterlockedIncrement(&m_cCurrentSystemRoutingThreads);
|
|
if (NewValue > m_cMaxSystemRoutingThreads) {
|
|
InterlockedDecrement(&m_cCurrentSystemRoutingThreads);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL AggregateStatistics(
|
|
IN PCHAR pDestination,
|
|
IN PCHAR pSource
|
|
);
|
|
|
|
BOOL ResetServicePrincipalNames()
|
|
{
|
|
m_Lock.ExclusiveLock();
|
|
|
|
if (!m_fHaveResetPrincipalNames)
|
|
m_fHaveResetPrincipalNames =
|
|
CSecurityCtx::ResetServicePrincipalNames(SMTP_SERVICE_PRINCIPAL_PREFIX);
|
|
|
|
m_Lock.ExclusiveUnlock();
|
|
|
|
return (m_fHaveResetPrincipalNames);
|
|
|
|
}
|
|
|
|
APIERR LoadAdvancedQueueingDll();
|
|
|
|
protected:
|
|
|
|
virtual ~SMTP_IIS_SERVICE();
|
|
|
|
CShareLockNH m_Lock;
|
|
|
|
private:
|
|
|
|
DWORD m_OldMaxPoolThreadValue;
|
|
LONG m_cCurrentSystemRoutingThreads;
|
|
DWORD m_cMaxSystemRoutingThreads;
|
|
DWORD m_dwStartHint;
|
|
|
|
//
|
|
// List containing some useful info including id and
|
|
// ptr to statistics for each Instance.
|
|
//
|
|
|
|
LIST_ENTRY m_InstanceInfoList;
|
|
char m_szTcpipName[MAX_PATH + 1];
|
|
|
|
BOOL m_fHaveResetPrincipalNames;
|
|
BOOL m_fCreatingInstance; //An instance is just being created in the
|
|
//metabase... we shouldn't start it.
|
|
};
|
|
|
|
typedef SMTP_IIS_SERVICE *PSMTP_IIS_SERVICE;
|
|
|
|
|
|
|
|
|
|
typedef struct SMTP_INSTANCE_LIST_ENTRY {
|
|
DWORD dwInstanceId;
|
|
LPSMTP_SERVER_STATISTICS pSmtpServerStatsObj;
|
|
LIST_ENTRY ListEntry;
|
|
} SMTP_INSTANCE_LIST_ENTRY, *PSMTP_INSTANCE_LIST_ENTRY;
|
|
|
|
#define PROVIDER_PACKAGES_SIG_VALID 'GKPP'
|
|
#define PROVIDER_PACKAGES_SIG_INVALID 'GKP~'
|
|
|
|
class CProviderPackagesInfo
|
|
{
|
|
private:
|
|
DWORD m_dwSig;
|
|
LONG m_cRefs;
|
|
PAUTH_BLOCK m_ProviderPackages;
|
|
char m_ProviderNames[MAX_PATH + 1];
|
|
DWORD m_cProviderPackages;
|
|
|
|
public:
|
|
CProviderPackagesInfo()
|
|
{
|
|
m_cRefs = 1; // Already AddRef'ed
|
|
m_ProviderPackages = NULL;
|
|
m_cProviderPackages = 0;
|
|
m_ProviderNames[0] = '\0';
|
|
m_dwSig = PROVIDER_PACKAGES_SIG_VALID;
|
|
}
|
|
|
|
~CProviderPackagesInfo()
|
|
{
|
|
m_dwSig = PROVIDER_PACKAGES_SIG_INVALID;
|
|
LocalFree(m_ProviderPackages);
|
|
m_ProviderPackages = NULL;
|
|
m_cProviderPackages = 0;
|
|
}
|
|
|
|
void AddRef() { InterlockedIncrement(&m_cRefs); }
|
|
|
|
void Release()
|
|
{
|
|
if(!InterlockedDecrement(&m_cRefs))
|
|
delete this;
|
|
}
|
|
|
|
DWORD GetProviderPackagesCount(void) { return m_cProviderPackages; }
|
|
|
|
void SetProviderPackagesCount(DWORD cProviderPackages)
|
|
{ m_cProviderPackages = cProviderPackages; }
|
|
|
|
BOOL SetProviderPackages();
|
|
PAUTH_BLOCK GetProviderPackages(void) { return m_ProviderPackages; }
|
|
|
|
LPSTR GetProviderNames(void) { return m_ProviderNames; }
|
|
};
|
|
|
|
|
|
//
|
|
// This is the SMTP version of the instance. Will contain all the
|
|
// SMTP specific operations.
|
|
//
|
|
|
|
class SMTP_SERVER_INSTANCE : public IIS_SERVER_INSTANCE {
|
|
|
|
friend DWORD EnumAllDomains(VOID *ptr);
|
|
|
|
private:
|
|
|
|
//
|
|
// signature
|
|
//
|
|
|
|
DWORD m_signature;
|
|
|
|
//
|
|
// Should we use host name?
|
|
//
|
|
|
|
DWORD m_dwUseHostName;
|
|
|
|
|
|
DWORD m_SmtpInitializeStatus;
|
|
|
|
// Constants, defaults, mins, maxs, etc.
|
|
//
|
|
// Connections related data
|
|
//
|
|
// m_cMaxConnections: max connections permitted by config
|
|
// m_cCurrentConnections: count of currently connected users
|
|
// m_cMaxCurrentConnections: max connections seen in this session
|
|
// Always m_cCurrentConnections
|
|
// <= m_cMaxCurrentConnections
|
|
// <= m_cMaxConnections;
|
|
//
|
|
// DWORD m_cMaxConnections;
|
|
// replaced by TSVC_INFO::QueryMaxConnections()
|
|
|
|
DWORD m_cCurrentConnections;
|
|
DWORD m_cCurrentOutConnections;
|
|
DWORD m_cMaxCurrentConnections;
|
|
DWORD m_cMaxOutConnections;
|
|
DWORD m_cMaxOutConnectionsPerDomain;
|
|
DWORD m_dwNextInboundClientId;
|
|
DWORD m_dwNextOutboundClientId;
|
|
DWORD m_dwStopHint;
|
|
|
|
// Connection protocol settings
|
|
DWORD m_cMaxRemoteTimeOut;
|
|
DWORD m_cMaxErrors;
|
|
|
|
// Size information
|
|
DWORD m_cbMaxMsgSize;
|
|
DWORD m_cbMaxMsgSizeBeforeClose;
|
|
DWORD m_cMaxRcpts;
|
|
|
|
// DNS lookup
|
|
DWORD m_dwNameResolution;
|
|
// DWORD m_fEnableReverseLookup;
|
|
// BOOL m_fDisconnectOnRDNSFail;
|
|
DWORD m_RDNSOptions;
|
|
|
|
// +3 for enclosing [] and NULL termination
|
|
CHAR m_szPostDnsSmarthost[IP_ADDRESS_STRING_LENGTH+3];
|
|
|
|
// CPool info
|
|
DWORD m_cMaxAddressObjects;
|
|
DWORD m_cMaxMailObjects;
|
|
|
|
// Mail loop settings
|
|
DWORD m_cMaxHopCount;
|
|
|
|
// Delivery settings
|
|
DWORD m_fShouldDelete;
|
|
DWORD m_fRelayForAuthUsers;
|
|
DWORD m_fShouldPickupMail;
|
|
DWORD m_cMaxRoutingThreads;
|
|
DWORD m_cMaxRemoteQThreads;
|
|
DWORD m_cMaxLocalQThreads;
|
|
LONG m_cCurrentRoutingThreads;
|
|
DWORD m_cMaxDirBuffers;
|
|
DWORD m_cMaxDirChangeIoSize;
|
|
DWORD m_cMaxDirPendingIos;
|
|
|
|
DWORD m_cRetryAttempts;
|
|
DWORD m_cRetryMinutes;
|
|
|
|
DWORD m_cRemoteRetryAttempts;
|
|
DWORD m_cRemoteRetryMinutes;
|
|
|
|
// Raid 174038
|
|
DWORD m_fDisablePickupDotStuff;
|
|
|
|
//Comma separated string of at most 4 numbers
|
|
DWORD m_cbProgressiveRetryMinutes;
|
|
char m_szProgressiveRetryMinutes[MAX_PATH + 1];
|
|
|
|
|
|
// Pipelining info
|
|
DWORD m_fShouldPipelineOut;
|
|
DWORD m_fShouldPipelineIn;
|
|
|
|
|
|
// Advertise Verify and Expand
|
|
DWORD m_fAllowVerify;
|
|
DWORD m_fAllowExpand;
|
|
// Advertise DSN
|
|
DWORD m_fDSN;
|
|
//////
|
|
|
|
//Flags that determine what commands anre supported at inbound and
|
|
//under what circumstances
|
|
DWORD m_InboundCmdOptions;
|
|
DWORD m_OutboundCmdOptions;
|
|
BOOL m_fAddNoHdrs;
|
|
|
|
// Smart host settings
|
|
DWORD m_fSmartHostType;
|
|
|
|
DWORD m_fFlushMailFiles;
|
|
|
|
//remote port to connect to
|
|
DWORD m_RemoteSmtpPort;
|
|
DWORD m_RemoteSmtpSecurePort;
|
|
|
|
// Msgs to Admin
|
|
DWORD m_fSendNDRToAdmin;
|
|
DWORD m_fSendBadToAdmin;
|
|
|
|
// Domain information
|
|
DWORD m_fDefaultDomainExists;
|
|
|
|
//number of connection objects
|
|
//allocated per instance
|
|
|
|
LONG m_cNumConnInObjsAlloced;
|
|
LONG m_cNumConnOutObjsAlloced;
|
|
LONG m_cNumCBufferObjsAlloced;
|
|
LONG m_cNumAsyncObjsAlloced;
|
|
LONG m_cNumAsyncDnsObjsAlloced;
|
|
|
|
// Sizes, etc.
|
|
DWORD m_cchConnectResponse;
|
|
DWORD m_cchMailQueueDir;
|
|
DWORD m_cchMailPickupDir;
|
|
DWORD m_cchMailDropDir;
|
|
DWORD m_cchMyHostName;
|
|
|
|
//Msg batching
|
|
DWORD m_fBatchMsgs;
|
|
DWORD m_cMaxBatchLimit;
|
|
|
|
//logging flags
|
|
DWORD m_CmdLogFlags;
|
|
|
|
//auth stuff
|
|
DWORD m_dwAuth;
|
|
BOOL m_dwDeniedIpAction;
|
|
DWORD m_dwMaxLogonFailures;
|
|
DWORD m_DefaultRouteAction;
|
|
|
|
DWORD m_ConnectTimeout;
|
|
DWORD m_MailFromTimeout;
|
|
DWORD m_RcptToTimeout;
|
|
DWORD m_DataTimeout;
|
|
DWORD m_AuthTimeout;
|
|
DWORD m_SaslTimeout;
|
|
DWORD m_BdatTimeout;
|
|
DWORD m_HeloTimeout;
|
|
DWORD m_RSetTimeout;
|
|
DWORD m_TurnTimeout;
|
|
DWORD m_QuitTimeout;
|
|
|
|
//
|
|
// TRUE to use host name to build redirection indication
|
|
//
|
|
|
|
BOOL m_fUseHostName;
|
|
BOOL m_dwDnsFlags;
|
|
BOOL m_fHaveRegisteredPrincipalNames;
|
|
|
|
//
|
|
// Are there any secure filters loaded?
|
|
//
|
|
|
|
BOOL m_fAnySecureFilters;
|
|
|
|
//retry queue variables
|
|
BOOL m_fIgnoreTime;
|
|
BOOL m_fStartRetry;
|
|
|
|
//Require SSL / 128Bit SSL on client connections
|
|
BOOL m_fRequiresSSL;
|
|
BOOL m_fRequires128Bits;
|
|
BOOL m_fRequiresCertVerifySubject;
|
|
BOOL m_fRequiresCertVerifyIssuer;
|
|
DWORD m_CertStatus;
|
|
|
|
// Server certificate object
|
|
IIS_SSL_INFO *m_pSSLInfo;
|
|
|
|
//Require SASL on client connections
|
|
BOOL m_fRequiresSASL;
|
|
|
|
//use to limit remote connections
|
|
BOOL m_fLimitRemoteConnections;
|
|
|
|
BOOL m_fShutdownCalled;
|
|
BOOL m_InstBooted;
|
|
BOOL m_fStoreDrvStartEventCalled;
|
|
BOOL m_fStoreDrvPrepShutDownEventCalled;
|
|
|
|
|
|
BOOL m_fScheduledConnection;
|
|
BOOL m_fIsRoutingTable;
|
|
|
|
BOOL m_fIsRelayEnabled;
|
|
|
|
BOOL m_fHelloNoDomain;
|
|
|
|
BOOL m_fMailFromNoHello;
|
|
BOOL m_fNagleIn;
|
|
BOOL m_fNagleOut;
|
|
|
|
//Internet address/domain validation
|
|
BOOL m_fHelloNoValidate;
|
|
BOOL m_fMailNoValidate;
|
|
BOOL m_fRcptNoValidate;
|
|
BOOL m_fEtrnNoValidate;
|
|
BOOL m_fPickupNoValidate;
|
|
|
|
HANDLE m_QStopEvent;
|
|
HANDLE m_hEnumBuildQ;
|
|
|
|
//The server bindings
|
|
MULTISZ m_ServerBindings;
|
|
|
|
TCP_AUTHENT_INFO m_TcpAuthentInfo ;
|
|
|
|
//
|
|
// SDK: SEO Configuration
|
|
//
|
|
CSMTPSeoMgr m_CSMTPSeoMgr;
|
|
|
|
//
|
|
// used to store instance info that we wish to make accessible via
|
|
// a global linked list
|
|
//
|
|
|
|
PSMTP_INSTANCE_LIST_ENTRY m_pSmtpInfo;
|
|
|
|
//
|
|
// used to store statistics for SMTP instance
|
|
//
|
|
|
|
LPSMTP_SERVER_STATISTICS m_pSmtpStats;
|
|
|
|
TIME_ZONE_INFORMATION m_tzInfo;
|
|
PERSIST_QUEUE * m_RemoteQ;
|
|
|
|
BOOL m_IsShuttingDown;
|
|
BOOL m_QIsShuttingDown;
|
|
BOOL m_RetryQIsShuttingDown;
|
|
char m_AdminName[MAX_INTERNET_NAME + 1];
|
|
char m_BadMailName[MAX_INTERNET_NAME + 1];
|
|
|
|
//routing thread counter
|
|
LONG m_cProcessClientThreads;
|
|
|
|
BOOL m_fShouldStartAcceptingConnections;
|
|
BOOL m_IsFileSystemNtfs;
|
|
|
|
//Directory pickup
|
|
SMTP_DIRNOT * SmtpDir;
|
|
HANDLE DirPickupThreadHandle;
|
|
HANDLE StopHandle;
|
|
|
|
// Enum Domain Thread Handle
|
|
HANDLE m_hEnumDomainThreadHandle;
|
|
BOOL m_fEnumThreadStarted;
|
|
|
|
ADDRESS_CHECK m_acCheck;
|
|
|
|
//masquerade
|
|
DWORD m_fMasquerade;
|
|
CHAR m_szMasqueradeName [AB_MAX_DOMAIN + 1];
|
|
|
|
//Turn Table
|
|
CTURN_ACCESS_TABLE m_TurnAccessList;
|
|
|
|
// support the Etrn @ extension. (on by default)
|
|
BOOL m_fAllowEtrnSubDomains;
|
|
|
|
//directory stuff
|
|
CHAR m_szMailQueueDir[MAX_PATH + 1];
|
|
CHAR m_szMailPickupDir[MAX_PATH + 1];
|
|
CHAR m_szMailDropDir[MAX_PATH + 1];
|
|
CHAR m_szBadMailDir[MAX_PATH + 1];
|
|
CHAR m_szMyDomain[MAX_PATH + 1];
|
|
CHAR m_szDefaultDomain[MAX_PATH + 1];
|
|
CHAR m_szFQDomainName[MAX_PATH + 1];
|
|
CHAR m_szConnectResponse[RESPONSE_BUFF_SIZE];
|
|
CHAR m_szSmartHostName[MAX_PATH + 1];
|
|
CHAR m_szDefaultLogonDomain[MAX_SERVER_NAME_LEN + 1]; // for clear-text auth
|
|
CHAR m_DefaultRemoteUserName[MAX_INTERNET_NAME + 1];
|
|
CHAR m_DefaultRemotePassword[MAX_PATH + 1];
|
|
|
|
|
|
LIST_ENTRY m_ConnectionsList; // list of all connections
|
|
LIST_ENTRY m_OutConnectionsList; // list of all connections
|
|
LIST_ENTRY m_leVRoots; // list of vroots (used by admin)
|
|
LIST_ENTRY m_AsynConnectList; // list of all Async connections
|
|
LIST_ENTRY m_AsyncDnsList; // list of all Async Dnsconnections
|
|
CRITICAL_SECTION m_csLock; // used for updating this object
|
|
CRITICAL_SECTION m_critBoot; // used to synchronize start/stop
|
|
CRITICAL_SECTION m_csAsyncDns; // used for updating async dns list
|
|
CRITICAL_SECTION m_csAsyncConnect; // used for updating async connect list
|
|
|
|
//
|
|
// We use m_fInitAsyncCS to track whether the 2 previous critsecs (m_csAsyncDns
|
|
// and m_csAsyncConnect) were intialized properly before deinitializing them
|
|
// and vice versa. This is in an effort to track any bugs or erroneous assumptions
|
|
// we make about the underlying IIS code which controls initializing and deinitializing
|
|
// these variables (as part or initializing and deinitializing SMTP_SERVER_INSTANCE).
|
|
//
|
|
|
|
BOOL m_fInitAsyncCS;
|
|
|
|
CShareLockNH m_OutLock;
|
|
CShareLockNH m_GenLock;
|
|
|
|
METADATA_REF_HANDLER m_rfAccessCheck;
|
|
METADATA_REF_HANDLER m_RelayAccessCheck;
|
|
|
|
//
|
|
// Instance-specific cleartext auth package name
|
|
//
|
|
char m_szCleartextAuthPackage[MAX_PATH + 1];
|
|
char m_szMembershipBroker[MAX_PATH + 1];
|
|
DWORD m_cbCleartextAuthPackage;
|
|
CProviderPackagesInfo *m_pProviderPackagesInfo;
|
|
|
|
BOOL SetProviderPackages();
|
|
|
|
// Save the pointer of change object
|
|
MD_CHANGE_OBJECT *m_pChangeObject;
|
|
|
|
BOOL m_fDefaultInRt;
|
|
|
|
IAdvQueue *m_IAQ;
|
|
PVOID m_pvAQInstanceContext;
|
|
IAdvQueueConfig *m_pIAdvQueueConfig;
|
|
IConnectionManager *m_ICM;
|
|
|
|
BOOL fInitializedStoreDriver;
|
|
BOOL fInitializedAQ;
|
|
|
|
ISMTPServer *m_ComSmtpServer;
|
|
|
|
// Protocol Events IServer
|
|
CMailMsgLoggingPropertyBag m_InstancePropertyBag;
|
|
|
|
// eventlog level
|
|
DWORD m_dwEventlogLevel;
|
|
|
|
|
|
//
|
|
// We maintain separate lists of DNS servers to be used for alternate
|
|
// networks. These lists are returned by the DNS sink when the DNS sink
|
|
// event is fired. Once a list is added it cannot be removed, although
|
|
// the servers in the list can be modified.
|
|
//
|
|
|
|
// Simple class to wrap GUID + DNS list
|
|
class DNS_SERVER_LIST
|
|
{
|
|
public:
|
|
DWORD m_dwSig;
|
|
GUID m_guid;
|
|
CTcpRegIpList m_TcpRegIpList;
|
|
|
|
#define DNS_SERVER_LIST_VALID 'VLSD'
|
|
#define DNS_SERVER_LIST_INVALID 'iLSD'
|
|
|
|
DNS_SERVER_LIST() { m_dwSig = DNS_SERVER_LIST_VALID; }
|
|
~DNS_SERVER_LIST() { m_dwSig = DNS_SERVER_LIST_INVALID; }
|
|
};
|
|
|
|
|
|
#define MAX_DNS_SERVER_LISTS 5
|
|
|
|
DWORD m_cServerList;
|
|
DNS_SERVER_LIST *m_rgpServerList[MAX_DNS_SERVER_LISTS];
|
|
CShareLockNH m_slServerList;
|
|
|
|
public:
|
|
|
|
SMTP_SERVER_INSTANCE(
|
|
IN PSMTP_IIS_SERVICE pService,
|
|
IN DWORD dwInstanceId,
|
|
IN USHORT Port,
|
|
IN LPCSTR lpszRegParamKey,
|
|
IN LPWSTR lpwszAnonPasswordSecretName,
|
|
IN LPWSTR lpwszVirtualRootsSecretName,
|
|
IN BOOL fMigrateRoots = FALSE
|
|
);
|
|
|
|
virtual ~SMTP_SERVER_INSTANCE( );
|
|
|
|
virtual DWORD StopInstance(void);
|
|
|
|
virtual DWORD StartInstance(void);
|
|
|
|
virtual DWORD PauseInstance(void);
|
|
|
|
METADATA_REF_HANDLER* QueryMetaDataRefHandler() { return &m_rfAccessCheck;}
|
|
METADATA_REF_HANDLER* QueryRelayMetaDataRefHandler() { return &m_RelayAccessCheck;}
|
|
void ResetRelayIpSecList(void)
|
|
{
|
|
m_RelayAccessCheck.Reset( (IMDCOM*)g_pInetSvc->QueryMDObject() );
|
|
}
|
|
|
|
void SetRelayIpSecList(LPVOID pV, DWORD dwS, DWORD dwR )
|
|
{
|
|
if(m_RelayAccessCheck.GetPtr()) //can't leak memory
|
|
{
|
|
delete [] m_RelayAccessCheck.GetPtr();
|
|
m_RelayAccessCheck.Set(NULL, 0, 0);
|
|
}
|
|
m_RelayAccessCheck.Set(pV, dwS, dwR);
|
|
}
|
|
|
|
// added by andreik
|
|
IEventRouter * GetRouter() { return m_CSMTPSeoMgr.GetRouter(); }
|
|
//
|
|
// Protocol events
|
|
//
|
|
HRESULT HrSetWellKnownIServerProps();
|
|
|
|
IUnknown *GetInstancePropertyBag() { return ((IUnknown *)(IMailMsgLoggingPropertyBag *)(&m_InstancePropertyBag));}
|
|
|
|
//
|
|
// read smtp parameters
|
|
//
|
|
|
|
void GetServerBindings(void);
|
|
|
|
BOOL IsShuttingDown(void){return m_IsShuttingDown || g_IsShuttingDown;}
|
|
BOOL QIsShuttingDown(void){return m_QIsShuttingDown;}
|
|
BOOL IsRetryQShuttingDown(void) {return m_RetryQIsShuttingDown;}
|
|
|
|
//
|
|
// SSP security check
|
|
//
|
|
|
|
BOOL CheckSSPPackage(IN LPCSTR pszAuthString);
|
|
|
|
//
|
|
// Server-side SSL object
|
|
//
|
|
IIS_SSL_INFO* QueryAndReferenceSSLInfoObj();
|
|
static VOID ResetSSLInfo( LPVOID pvParam );
|
|
void LogCertStatus(void);
|
|
void LogCTLStatus(void);
|
|
|
|
BOOL InitQueues(void);
|
|
|
|
BOOL IsFileSystemNtfs(void){ return m_IsFileSystemNtfs;}
|
|
|
|
void SetShutdownFlag(void) {m_fShutdownCalled = TRUE;}
|
|
|
|
SMTP_DIRNOT * QueryDirnotObj() { return SmtpDir;}
|
|
|
|
PERSIST_QUEUE * QueryRemoteQObj() { return m_RemoteQ;}
|
|
|
|
char * QueryAdminName(void) {return m_AdminName;}
|
|
char * QueryBadMailName (void) {return m_BadMailName;}
|
|
|
|
void SetAcceptConnBool(void) {m_fShouldStartAcceptingConnections = TRUE;}
|
|
BOOL GetAcceptConnBool(void) { return m_fShouldStartAcceptingConnections; }
|
|
|
|
|
|
//
|
|
// Keep track of Statistics counters for this instance
|
|
//
|
|
|
|
LPSMTP_SERVER_STATISTICS QueryStatsObj() { return m_pSmtpStats;}
|
|
|
|
ADDRESS_CHECK* QueryAccessCheck() { return &m_acCheck;}
|
|
|
|
//
|
|
// VIRTUALS for service specific params/RPC admin
|
|
//
|
|
|
|
virtual BOOL SetServiceConfig(IN PCHAR pConfig );
|
|
virtual BOOL GetServiceConfig(IN OUT PCHAR pConfig,IN DWORD dwLevel);
|
|
virtual BOOL GetStatistics( IN DWORD dwLevel, OUT PCHAR *pBuffer);
|
|
virtual BOOL ClearStatistics( );
|
|
virtual BOOL DisconnectUser( IN DWORD dwIdUser );
|
|
virtual BOOL EnumerateUsers( OUT PCHAR* pBuffer, OUT PDWORD nRead );
|
|
virtual VOID MDChangeNotify( MD_CHANGE_OBJECT * pco );
|
|
DWORD QueryEncCaps(void);
|
|
|
|
BOOL InitFromRegistry(void);
|
|
void StopHint();
|
|
void SetStopHint(DWORD StopHint) {m_dwStopHint = StopHint;}
|
|
CAddr * AppendLocalDomain (CAddr * OldAddress);
|
|
//Using 821 addr validation
|
|
BOOL AppendLocalDomain (char * Address);
|
|
BOOL MoveToBadMail ( IMailMsgProperties *pIMsg, BOOL fUseIMsg, char * MailFile, char * FilePath);
|
|
|
|
VOID LockConfig( VOID) {EnterCriticalSection( &m_csLock);}
|
|
VOID UnLockConfig( VOID) {LeaveCriticalSection( &m_csLock);}
|
|
|
|
//these are excluse locks
|
|
VOID ExclusiveLockGenCrit( VOID) {m_GenLock.ExclusiveLock();}
|
|
VOID ExclusiveUnLockGenCrit( VOID) {m_GenLock.ExclusiveUnlock();}
|
|
|
|
//these are shared locks
|
|
VOID LockGenCrit( VOID) {m_GenLock.ShareLock();}
|
|
VOID UnLockGenCrit( VOID) {m_GenLock.ShareUnlock();}
|
|
|
|
|
|
DWORD GetMaxConnectionsPerDomain(void) const {return m_cMaxOutConnectionsPerDomain;}
|
|
DWORD GetCurrentConnectionsCount(void) const {return m_cCurrentConnections;}
|
|
PLIST_ENTRY GetConnectionList(void) {return &m_ConnectionsList;}
|
|
DWORD GetMaxCurrentConnectionsCount(void) const {return m_cMaxCurrentConnections;}
|
|
DWORD GetMaxRcpts(void) const { return m_cMaxRcpts;}
|
|
CLIENT_CONNECTION * CreateNewConnection( IN CLIENT_CONN_PARAMS * pParams);
|
|
VOID DisconnectAllConnections( VOID);
|
|
VOID RemoveConnection( IN OUT CLIENT_CONNECTION * pcc);
|
|
|
|
BOOL InsertNewOutboundConnection( IN OUT CLIENT_CONNECTION * pcc, BOOL ByPassLimitCheck = FALSE);
|
|
VOID RemoveOutboundConnection( IN OUT CLIENT_CONNECTION * pConn);
|
|
VOID DisconnectAllOutboundConnections( VOID);
|
|
|
|
BOOL WriteRegParams(SMTP_CONFIG_INFO *pconfig);
|
|
// Changed by KeithLau on 7/15/96 to remove the fInit flag
|
|
BOOL ReadRegParams(FIELD_CONTROL fc, BOOL fRebuild, BOOL fShowEvents = TRUE);
|
|
// Added by KeithLau on 7/15/96
|
|
BOOL ReadStartupRegParams(VOID);
|
|
BOOL RemoveRegParams(const char * DomainName);
|
|
|
|
DWORD GetDnsFlags(void) const {return m_dwDnsFlags;}
|
|
|
|
BOOL AllowVerify(DWORD dwConnectionStatus) const{
|
|
if (m_InboundCmdOptions & SMTP_I_SUPPORT_VRFY)
|
|
return TRUE;
|
|
else if ((m_InboundCmdOptions & SMTP_I_SUPPORT_VRFY_ON_SSL) && (dwConnectionStatus & SMTP_IS_SSL_CONNECTION))
|
|
return TRUE;
|
|
else if ((m_InboundCmdOptions & SMTP_I_SUPPORT_VRFY_ON_AUTH) && (dwConnectionStatus & SMTP_IS_AUTH_CONNECTION))
|
|
return TRUE;
|
|
else return FALSE;
|
|
}
|
|
BOOL AllowExpand(DWORD dwConnectionStatus) const {
|
|
if (m_InboundCmdOptions & SMTP_I_SUPPORT_EXPN)
|
|
return TRUE;
|
|
else if ((m_InboundCmdOptions & SMTP_I_SUPPORT_EXPN_ON_SSL) && (dwConnectionStatus & SMTP_IS_SSL_CONNECTION))
|
|
return TRUE;
|
|
else if ((m_InboundCmdOptions & SMTP_I_SUPPORT_EXPN_ON_AUTH) && (dwConnectionStatus & SMTP_IS_AUTH_CONNECTION))
|
|
return TRUE;
|
|
else return FALSE;
|
|
}
|
|
BOOL AllowLogin(DWORD dwConnectionStatus) const {
|
|
if (!(m_dwAuth & INET_INFO_AUTH_CLEARTEXT))
|
|
return FALSE;
|
|
else if ((m_InboundCmdOptions & SMTP_I_SUPPORT_LOGIN) && !(m_InboundCmdOptions & SMTP_I_SUPPORT_LOGIN_ON_SSL))
|
|
return TRUE;
|
|
else if ((m_InboundCmdOptions & SMTP_I_SUPPORT_LOGIN_ON_SSL) && (dwConnectionStatus & SMTP_IS_SSL_CONNECTION))
|
|
return TRUE;
|
|
else return FALSE;
|
|
}
|
|
BOOL AllowEightBitMime() const {return (m_InboundCmdOptions & SMTP_I_SUPPORT_8BITMIME);}
|
|
BOOL AllowDSN() const { return (m_InboundCmdOptions & SMTP_I_SUPPORT_DSN);}
|
|
BOOL AllowBinaryMime() const {return (m_InboundCmdOptions & SMTP_I_SUPPORT_BMIME);}
|
|
BOOL AllowChunking() const {return (m_InboundCmdOptions & SMTP_I_SUPPORT_CHUNK);}
|
|
BOOL AllowETRN() const {return (m_InboundCmdOptions & SMTP_I_SUPPORT_ETRN);}
|
|
BOOL AllowTURN() const {return (m_InboundCmdOptions & SMTP_I_SUPPORT_TURN);}
|
|
BOOL AllowAuth() const {return (m_InboundCmdOptions & SMTP_I_SUPPORT_AUTH);}
|
|
BOOL AllowEnhancedCodes() const {return (m_InboundCmdOptions & SMTP_I_SUPPORT_ECODES);}
|
|
|
|
/*
|
|
BOOL AllowSSL() const {
|
|
|
|
CEncryptCtx EncryptCtx(FASLE);
|
|
|
|
if(m_CertStatus == CERT_STATUS_UNKNOWN)
|
|
{
|
|
if (!EncryptCtx.CheckServerCert(
|
|
(LPSTR) QueryLocalHostName(),
|
|
(LPSTR) QueryLocalPortName(),
|
|
(LPVOID) this,
|
|
QueryInstanceId()))
|
|
{
|
|
m_CertStatus = CERT_STATUS_INVALID;
|
|
}
|
|
else
|
|
{
|
|
m_CertStatus = CERT_STATUS_VALID;
|
|
}
|
|
}
|
|
|
|
if(m_CertStatus == CERT_STATUS_INVALID)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
*/
|
|
|
|
BOOL AllowOutboundDSN() const {return (m_OutboundCmdOptions & SMTP_0_SUPPORT_DSN);}
|
|
BOOL AllowOutboundBMIME() const {return (m_OutboundCmdOptions & SMTP_0_SUPPORT_BMIME);}
|
|
BOOL ShouldChunkOut() const {return (m_OutboundCmdOptions & SMTP_0_FORCE_CHUNK);}
|
|
|
|
BOOL ShouldPipeLineIn(void) const { return m_fShouldPipelineIn;}
|
|
BOOL ShouldPipeLineOut(void) const { return m_fShouldPipelineOut;}
|
|
BOOL ShouldDelete(void) const { return m_fShouldDelete;}
|
|
BOOL ShouldParseHdrs(void) const { return (!m_fAddNoHdrs);}
|
|
DWORD GetMaxHopCount(void) const { return m_cMaxHopCount;}
|
|
DWORD GetMaxAddrObjects(void) const { return m_cMaxAddressObjects;}
|
|
DWORD GetMaxMailObjects(void) const { return m_cMaxMailObjects;}
|
|
DWORD GetMaxOutConnections(void) const {return m_cMaxOutConnections;}
|
|
DWORD GetRetryAttempts(void) const {return m_cRetryAttempts;}
|
|
DWORD GetRetryMinutes(void) const {return m_cRetryMinutes;}
|
|
|
|
DWORD GetRemoteSmtpPort(void) const {return m_RemoteSmtpPort;}
|
|
DWORD GetRemoteSmtpSecurePort(void) const {return m_RemoteSmtpSecurePort;}
|
|
DWORD GetRemoteRetryAttempts(void) const {return m_cRemoteRetryAttempts;}
|
|
DWORD GetRemoteRetryMinutes(void) const {return m_cRemoteRetryMinutes;}
|
|
|
|
DWORD GetMaxErrors(void) const {return m_cMaxErrors;}
|
|
DWORD GetRemoteTimeOut(void) const {return m_cMaxRemoteTimeOut;}
|
|
DWORD GetMaxMsgSize(void) const {return m_cbMaxMsgSize;}
|
|
DWORD GetMailBagLimit(void) const {return m_cMaxBatchLimit;}
|
|
DWORD GetMaxMsgSizeBeforeClose(void) const {return m_cbMaxMsgSizeBeforeClose;}
|
|
DWORD GetConnectTimeout(void) const {return m_ConnectTimeout;}
|
|
DWORD GetMailFromTimeout (void) const {return m_MailFromTimeout;}
|
|
DWORD GetRcptToTimeout (void) const {return m_RcptToTimeout;}
|
|
DWORD GetDataTimeout (void) const {return m_DataTimeout;}
|
|
DWORD GetAuthTimeout (void) const {return m_AuthTimeout;}
|
|
DWORD GetSaslTimeout (void) const {return m_SaslTimeout;}
|
|
DWORD GetBdatTimeout (void) const {return m_BdatTimeout;}
|
|
DWORD GetHeloTimeout (void) const {return m_HeloTimeout;}
|
|
DWORD GetRSetTimeout (void) const {return m_RSetTimeout;}
|
|
DWORD GetTurnTimeout (void) const {return m_TurnTimeout;}
|
|
DWORD GetQuitTimeout (void) const {return m_QuitTimeout;}
|
|
|
|
|
|
void DecRoutingThreads(void) {InterlockedDecrement(&m_cCurrentRoutingThreads);}
|
|
BOOL IncRoutingThreads(void)
|
|
{
|
|
DWORD NewValue;
|
|
|
|
NewValue = InterlockedIncrement(&m_cCurrentRoutingThreads);
|
|
if (NewValue > m_cMaxRoutingThreads)
|
|
{
|
|
InterlockedDecrement(&m_cCurrentRoutingThreads);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
DWORD GetNumDirBuffers(void) const {return m_cMaxDirBuffers;}
|
|
DWORD GetDirBufferSize(void) const {return m_cMaxDirChangeIoSize;}
|
|
DWORD GetMaxPendingDirIos(void) const {return m_cMaxDirPendingIos;}
|
|
|
|
CHAR * GetBadMailDir(void) const {return (CHAR *) m_szBadMailDir;}
|
|
CHAR * GetMailQueueDir(void) const {return (CHAR *)m_szMailQueueDir;}
|
|
CHAR * GetMailPickupDir(void) const {return (CHAR *)m_szMailPickupDir;}
|
|
BOOL GetMailDropDir(char * OutputDropDir)
|
|
{
|
|
BOOL fRet = TRUE;
|
|
|
|
m_GenLock.ShareLock();
|
|
|
|
if (m_szMailDropDir[0] != '\0')
|
|
lstrcpy(OutputDropDir,m_szMailDropDir);
|
|
else
|
|
fRet = FALSE;
|
|
|
|
m_GenLock.ShareUnlock();
|
|
|
|
if (!fRet)
|
|
SetLastError(ERROR_DIRECTORY);
|
|
|
|
return fRet;
|
|
}
|
|
|
|
DWORD GetNameResolution(void) const {return m_dwNameResolution;}
|
|
DWORD GetMaxRemoteQThreads(void) const {return m_cMaxRemoteQThreads;}
|
|
DWORD GetMaxLocalQThreads(void) const {return m_cMaxLocalQThreads;}
|
|
DWORD GetMailQueueDirLength(void) const {return m_cchMailQueueDir;}
|
|
DWORD GetMailPickupDirLength(void) const {return m_cchMailPickupDir;}
|
|
DWORD GetMailDropDirLength(void) const {return m_cchMailDropDir;}
|
|
CHAR * GetConnectResponse(void) const {return (char *) m_szConnectResponse;}
|
|
DWORD GetConnRespSize(void) const {return m_cchConnectResponse;}
|
|
|
|
BOOL IsReverseLookupEnabled(void) const {return (m_RDNSOptions & SMTP_I_HELOEHLO_RDNS);}
|
|
BOOL fDisconnectOnRDNSFail(void) const {return (m_RDNSOptions & SMTP_I_HELOEHLO_RDNS_DISCONNECT);}
|
|
BOOL IsRDNSEnabledForMAIL(void) const {return (m_RDNSOptions & SMTP_I_MAILFROM_RDNS);}
|
|
void VerifyFQDNWithBindings(void);
|
|
|
|
BOOL UseGetHostByName(void) const {return (m_dwNameResolution == RESOLUTION_GETHOSTBYNAME);}
|
|
BOOL GetSendNDRToAdmin(void) const {return m_fSendNDRToAdmin;}
|
|
BOOL GetSendBadToAdmin(void) const {return m_fSendBadToAdmin;}
|
|
BOOL RelayForAuthUsers(void) const {return m_fRelayForAuthUsers;}
|
|
BOOL ShouldMasquerade(void) const {return m_fMasquerade;}
|
|
BOOL ShouldAcceptNoDomain (void) const {return m_fHelloNoDomain;}
|
|
BOOL AllowMailFromNoHello (void) const {return m_fMailFromNoHello;}
|
|
BOOL IsInboundNagleOn(void) const {return m_fNagleIn;}
|
|
BOOL IsOutBoundNagleOn(void) const {return m_fNagleOut;}
|
|
|
|
BOOL ShouldValidateHeloDomain(void){return !m_fHelloNoValidate;}
|
|
|
|
CAddr * MasqueradeDomain (CAddr * OldAddress);
|
|
BOOL MasqueradeDomain (char * Address, char * DomainPtr);
|
|
|
|
|
|
// Removed by KeithLau on 7/23/96
|
|
// BOOL ShouldRetry(void) const {return m_fShouldRetry;}
|
|
|
|
// Changed by keithlau per rohanp
|
|
BOOL BadMailExists(void) const {return (m_szBadMailDir[0] == '\0')?FALSE:TRUE;}
|
|
BOOL FlushMailFiles(void) const {return m_fFlushMailFiles;}
|
|
|
|
BOOL BatchMsgs(void) const {return m_fBatchMsgs;}
|
|
BOOL ShouldPickupMail(void) const {return m_fShouldPickupMail;}
|
|
BOOL AlwaysUseSmartHost(void) const {return (m_fSmartHostType == smarthostAlways);}
|
|
BOOL UseSmartHostAfterFail(void) const {return (m_fSmartHostType == smarthostAfterFail);}
|
|
DWORD GetSmartHostType(void) const {return m_fSmartHostType;}
|
|
BOOL GetSmartHost(char *SmartHostBuffer)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
|
|
m_GenLock.ShareLock();
|
|
|
|
if (m_szSmartHostName[0] != '\0') {
|
|
lstrcpy(SmartHostBuffer, m_szSmartHostName);
|
|
fRet = TRUE;
|
|
}
|
|
|
|
m_GenLock.ShareUnlock();
|
|
return fRet;
|
|
}
|
|
|
|
BOOL GetPostDnsSmartHost(CHAR* pchSmartHostBuffer, DWORD cbSmartHostBuffer)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
|
|
if(m_szPostDnsSmarthost[0] == '\0')
|
|
return FALSE;
|
|
|
|
if(cbSmartHostBuffer < sizeof(m_szPostDnsSmarthost))
|
|
return FALSE;
|
|
|
|
m_GenLock.ShareLock();
|
|
|
|
if(m_szPostDnsSmarthost[0] != '\0') {
|
|
lstrcpy(pchSmartHostBuffer, m_szPostDnsSmarthost);
|
|
fRet = TRUE;
|
|
}
|
|
|
|
m_GenLock.ShareUnlock();
|
|
return fRet;
|
|
}
|
|
|
|
BOOL GetDefaultUserName(char *UserNameBuff)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
|
|
m_GenLock.ShareLock();
|
|
|
|
if (m_DefaultRemoteUserName[0] != '\0') {
|
|
lstrcpy(UserNameBuff, m_DefaultRemoteUserName);
|
|
fRet = TRUE;
|
|
}
|
|
|
|
m_GenLock.ShareUnlock();
|
|
return fRet;
|
|
}
|
|
|
|
BOOL GetDefaultPassword(char *PasswordBuff)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
|
|
m_GenLock.ShareLock();
|
|
|
|
if (m_DefaultRemotePassword[0] != '\0') {
|
|
lstrcpy(PasswordBuff, m_DefaultRemotePassword);
|
|
fRet = TRUE;
|
|
}
|
|
|
|
m_GenLock.ShareUnlock();
|
|
return fRet;
|
|
}
|
|
|
|
CHAR * GetFQDomainName(void) const {return (char *) m_szFQDomainName;}
|
|
CHAR * GetDefaultDomain(void) const {return (char *)m_szDefaultDomain;}
|
|
BOOL FDefaultDomainExists(void) const {return m_fDefaultDomainExists;}
|
|
|
|
|
|
DWORD GetCmdLogFlags(VOID) const { return m_CmdLogFlags;}
|
|
DWORD GetDefaultRouteAction(VOID) const { return m_DefaultRouteAction;}
|
|
|
|
void FreeVRootList(PLIST_ENTRY pleHead);
|
|
BOOL FindBestVRoot(LPSTR szVRoot);
|
|
|
|
BOOL IsAddressMine(DWORD IpAddress, DWORD ConnectedPort = 25);
|
|
|
|
//directory pickup
|
|
void SetDirnotStopHandle (HANDLE SHandle) {StopHandle = SHandle;}
|
|
HANDLE GetDirnotStopHandle(void) const {return StopHandle;}
|
|
BOOL InitDirectoryNotification(void);
|
|
void DestroyDirectoryNotification(void);
|
|
|
|
//
|
|
// TCP authent info
|
|
//
|
|
|
|
PTCP_AUTHENT_INFO QueryAuthentInfo()
|
|
{ return &m_TcpAuthentInfo;}
|
|
|
|
LONG GetProcessClientThreads(void) const {return m_cProcessClientThreads;}
|
|
void IncProcessClientThreads (void) {InterlockedIncrement(&m_cProcessClientThreads);}
|
|
void DecProcessClientThreads (void) {InterlockedDecrement(&m_cProcessClientThreads);}
|
|
|
|
LONG GetConnInAllocCount(void) const {return m_cNumConnInObjsAlloced;}
|
|
void IncConnInObjs (void) {InterlockedIncrement(&m_cNumConnInObjsAlloced);}
|
|
void DecConnInObjs (void) {InterlockedDecrement(&m_cNumConnInObjsAlloced);}
|
|
|
|
LONG GetCBufferAllocCount(void) const {return m_cNumCBufferObjsAlloced;}
|
|
void IncCBufferObjs (void) {InterlockedIncrement(&m_cNumCBufferObjsAlloced);}
|
|
void DecCBufferObjs (void) {InterlockedDecrement(&m_cNumCBufferObjsAlloced);}
|
|
|
|
LONG GetConnOutAllocCount(void) const {return m_cNumConnOutObjsAlloced;}
|
|
void IncConnOutObjs (void) {InterlockedIncrement(&m_cNumConnOutObjsAlloced);}
|
|
void DecConnOutObjs (void) {InterlockedDecrement(&m_cNumConnOutObjsAlloced);}
|
|
|
|
LONG GetAsyncMxOutAllocCount(void) const {return m_cNumAsyncObjsAlloced;}
|
|
void IncAsyncMxOutObjs (void) {InterlockedIncrement(&m_cNumAsyncObjsAlloced);}
|
|
void DecAsyncMxOutObjs (void) {InterlockedDecrement(&m_cNumAsyncObjsAlloced);}
|
|
|
|
LONG GetAsyncDnsAllocCount(void) const {return m_cNumAsyncDnsObjsAlloced;}
|
|
void IncAsyncDnsObjs (void) {InterlockedIncrement(&m_cNumAsyncDnsObjsAlloced);}
|
|
void DecAsyncDnsObjs (void) {InterlockedDecrement(&m_cNumAsyncDnsObjsAlloced);}
|
|
|
|
// Allow Etrn Subdomains (the @ extension to Etrn)
|
|
BOOL AllowEtrnSubDomains() { return m_fAllowEtrnSubDomains;}
|
|
|
|
// Domain Info
|
|
|
|
HRESULT HrGetDomainInfoFlags(
|
|
IN LPSTR szDomainName,
|
|
OUT DWORD *pdwDomainInfoFlags);
|
|
|
|
BOOL IsALocalDomain(char * szDomainName)
|
|
{
|
|
BOOL fFound = FALSE;
|
|
HRESULT hr = S_OK;
|
|
DWORD dwDomainInfoFlags;
|
|
|
|
hr = HrGetDomainInfoFlags(szDomainName, &dwDomainInfoFlags);
|
|
if (SUCCEEDED(hr)) {
|
|
if ( (dwDomainInfoFlags & DOMAIN_INFO_LOCAL_MAILBOX) ||
|
|
(dwDomainInfoFlags & DOMAIN_INFO_ALIAS) ||
|
|
(dwDomainInfoFlags & DOMAIN_INFO_LOCAL_DROP)) {
|
|
fFound = TRUE;
|
|
}
|
|
}
|
|
|
|
return fFound;
|
|
}
|
|
|
|
BOOL IsADefaultOrAliasDropDomain(char * szDomainName)
|
|
{
|
|
BOOL fFound = FALSE;
|
|
HRESULT hr = S_OK;
|
|
DWORD dwDomainInfoFlags;
|
|
|
|
//If there is no default drop directory, then this domain cannot
|
|
//be a default/alias drop domain
|
|
if ('\0' == m_szMailDropDir[0])
|
|
return FALSE;
|
|
|
|
hr = HrGetDomainInfoFlags(szDomainName, &dwDomainInfoFlags);
|
|
if (SUCCEEDED(hr)) {
|
|
if ( (dwDomainInfoFlags & DOMAIN_INFO_LOCAL_DROP) ||
|
|
(dwDomainInfoFlags & DOMAIN_INFO_ALIAS)) {
|
|
fFound = TRUE;
|
|
}
|
|
}
|
|
|
|
return fFound;
|
|
}
|
|
|
|
BOOL IsUserInTurnTable(const char * UserName, MULTISZ * pmsz)
|
|
{
|
|
BOOL Found = FALSE;
|
|
CTurnData * pEntry = NULL;
|
|
|
|
pEntry = (CTurnData *) m_TurnAccessList.FindHashData(UserName, TRUE, pmsz);
|
|
if(pEntry)
|
|
{
|
|
pEntry->DecRefCount();
|
|
Found = TRUE;
|
|
}
|
|
|
|
return Found;
|
|
}
|
|
|
|
BOOL Stop(void);
|
|
|
|
|
|
BOOL IsRelayEnabled (void) const {return m_fIsRelayEnabled;}
|
|
HANDLE GetQStopEvent (void) {return m_QStopEvent;}
|
|
BOOL InitiateStartup(void);
|
|
void InitiateShutDown(void);
|
|
void InitializeClassVariables(void);
|
|
|
|
BOOL RequiresSSL(void) const {return m_fRequiresSSL;}
|
|
BOOL Requires128Bits(void) const {return m_fRequires128Bits;}
|
|
BOOL RequiresSSLCertVerifySubject(void) const {return m_fRequiresCertVerifySubject; }
|
|
BOOL RequiresSSLCertVerifyIssuer(void) const {return m_fRequiresCertVerifyIssuer; }
|
|
|
|
BOOL CompareIpAddress(DWORD IpAddress);
|
|
BOOL ReadIpSecList(void);
|
|
void SetRouteDomainParameters(MB &mb,
|
|
char *szDomainName,
|
|
char *szRoutePath,
|
|
char szActionType [MAX_PATH + 1],
|
|
char szUserName [MAX_INTERNET_NAME + 1],
|
|
char szEtrnDomain [MAX_INTERNET_NAME + 1],
|
|
char szPassword [MAX_PATH + 1],
|
|
char szTargetName [MAX_PATH + 1],
|
|
DomainInfo *pLocalDomainInfo);
|
|
BOOL AddDomainEntry(MB& CurrentMetabase, char * DomainName);
|
|
BOOL DeleteDomainEntry(const char * DomainName);
|
|
BOOL GetRouteDomains(MB& CurrentMetabase, char * DomainName, BOOL fRebuild);
|
|
|
|
// Instance-specific cleartext authentication informaiton
|
|
LPSTR GetCleartextAuthPackage(void) { return m_szCleartextAuthPackage; }
|
|
LPSTR GetMembershipBroker(void) { return m_szMembershipBroker;}
|
|
|
|
CProviderPackagesInfo *GetAddRefdProviderPackagesInfo(void)
|
|
{
|
|
if(m_pProviderPackagesInfo)
|
|
m_pProviderPackagesInfo->AddRef();
|
|
|
|
return m_pProviderPackagesInfo;
|
|
}
|
|
|
|
DWORD QueryAuthentication(void) { return m_dwAuth; }
|
|
DWORD GetDeniedIpAction() { return m_dwDeniedIpAction; }
|
|
BOOL RequiresSASL(void) const {return m_fRequiresSASL;}
|
|
LPCSTR GetDefaultLogonDomain(void) const { return (LPCSTR) m_szDefaultLogonDomain; }
|
|
DWORD GetMaxLogonFailures(void) const {return m_dwMaxLogonFailures;}
|
|
BOOL IsScheduledConnection(void) const {return m_fScheduledConnection;}
|
|
BOOL IsRoutingTable (void) const {return m_fIsRoutingTable;}
|
|
void BuildTurnTable(MULTISZ& msz, char * szDomainName);
|
|
BOOL ReadRouteDomainIpSecList(MB& mb);
|
|
|
|
BOOL IsDefaultInRt(void) {return m_fDefaultInRt;}
|
|
|
|
IAdvQueue * GetAdvQueuePtr(void) {return m_IAQ;}
|
|
IConnectionManager * GetConnManPtr(void) {return m_ICM;}
|
|
BOOL StartAdvancedQueueing(void);
|
|
BOOL StopQDrivers(void);
|
|
BOOL InsertAsyncObject( IN OUT CAsyncMx *pcc);
|
|
VOID RemoveAsyncObject( IN OUT CAsyncMx *pcc);
|
|
VOID DisconnectAllAsyncConnections( VOID);
|
|
|
|
BOOL InsertAsyncDnsObject( IN OUT CAsyncSmtpDns *pcc);
|
|
VOID RemoveAsyncDnsObject( IN OUT CAsyncSmtpDns *pcc);
|
|
VOID DisconnectAllAsyncDnsConnections( VOID);
|
|
|
|
BOOL RegisterServicePrincipalNames(BOOL fLock);
|
|
|
|
PSMTP_INSTANCE_LIST_ENTRY GetSmtpInstanceInfo(void);
|
|
|
|
BOOL AllocNewMessage(SMTP_ALLOC_PARAMS * Params);
|
|
|
|
BOOL InsertIntoQueue(IMailMsgProperties * pImsg)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
MSG_TRACK_INFO msgTrackInfo;
|
|
ZeroMemory( &msgTrackInfo, sizeof( msgTrackInfo ) );
|
|
msgTrackInfo.dwEventId = MTE_SUBMIT_MESSAGE_TO_AQ;
|
|
WriteLog( &msgTrackInfo, pImsg, NULL, NULL );
|
|
|
|
hr = m_IAQ->SubmitMessage(pImsg);
|
|
|
|
if(!FAILED(hr))
|
|
{
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
BOOL SubmitFailedMessage(IMailMsgProperties * pImsg, DWORD dwFailedDesc, HRESULT hrFailureCode)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
hr = m_IAQ->HandleFailedMessage(pImsg, TRUE, NULL, dwFailedDesc, hrFailureCode);
|
|
|
|
if(!FAILED(hr))
|
|
{
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
HRESULT InsertIntoAdvQueue(IMailMsgProperties * pImsg)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
MSG_TRACK_INFO msgTrackInfo;
|
|
ZeroMemory( &msgTrackInfo, sizeof( msgTrackInfo ) );
|
|
msgTrackInfo.dwEventId = MTE_SUBMIT_MESSAGE_TO_AQ;
|
|
WriteLog( &msgTrackInfo, pImsg, NULL, NULL );
|
|
|
|
hr = m_IAQ->SubmitMessage(pImsg);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
const char * GetInstancePath(void) const {return QueryMDPath();}
|
|
HRESULT TriggerLocalDelivery(IMailMsgProperties *pMsg, DWORD dwRecipientCount, DWORD * pdwRecipIndexes, IMailMsgNotify *pNotify);
|
|
HRESULT TriggerDirectoryDrop(IMailMsgProperties *pMsg,
|
|
DWORD dwRecipientCount,
|
|
DWORD * pdwRecipIndexes,
|
|
LPCSTR DropDirectory);
|
|
|
|
HRESULT TriggerDnsResolverEvent( LPSTR HostName,
|
|
LPSTR MyFQDNName,
|
|
DWORD dwVirtualServerId,
|
|
DNS_SERVER_INFO **ppDnsServerInfo,
|
|
IDnsResolverRecord **ppIDnsResolverRecord );
|
|
|
|
HRESULT TriggerMaxMsgSizeEvent( IUnknown *pIUnknown, IMailMsgProperties *pIMsg, BOOL *pfShouldImposeLimit );
|
|
|
|
HRESULT TriggerStoreServerEvent(DWORD EventType);
|
|
|
|
HRESULT TriggerServerEvent(DWORD dwEventType, PVOID pvContext);
|
|
|
|
void SinkSmtpServerStartHintFunc(void);
|
|
void SinkSmtpServerStopHintFunc(void);
|
|
|
|
HRESULT SinkReadMetabaseDword(DWORD MetabaseId, DWORD * dwValue);
|
|
|
|
void WriteLog( LPMSG_TRACK_INFO pMsgTrackInfo,
|
|
IMailMsgProperties *pMsgProps,
|
|
LPEVENT_LOG_INFO pEventLogInfo,
|
|
LPSTR pszProtocolLog );
|
|
|
|
HRESULT TriggerLogEvent(
|
|
IN DWORD idMessage,
|
|
IN WORD idCategory,
|
|
IN WORD cSubstrings,
|
|
IN LPCSTR *rgszSubstrings,
|
|
IN WORD wType,
|
|
IN DWORD errCode,
|
|
IN WORD iDebugLevel,
|
|
IN LPCSTR szKey,
|
|
IN DWORD dwOptions,
|
|
IN DWORD iMessageString,
|
|
IN HMODULE hModule);
|
|
|
|
HRESULT ResetLogEvent(
|
|
IN DWORD idMessage,
|
|
IN LPCSTR szKey);
|
|
|
|
HRESULT HrTriggerGetAuxDomainInfoFlagsEvent(
|
|
IN LPCSTR pszDomainName,
|
|
OUT DWORD *pdwDomainInfoFlags);
|
|
|
|
HRESULT SinkReadMetabaseString(DWORD MetabaseId, char * Buffer, DWORD * BufferSize, BOOL fSecure);
|
|
|
|
HRESULT SinkReadMetabaseData(DWORD MetabaseId, BYTE *Buffer, DWORD * BufferSize);
|
|
|
|
BOOL GetCatInfo(MB& mb, AQConfigInfo& AQConfig);
|
|
IAdvQueueConfig * QueryAqConfigPtr (void) { return m_pIAdvQueueConfig;}
|
|
|
|
BOOL IsDropDirQuotaCheckingEnabled()
|
|
{
|
|
return ((GetDefaultRouteAction() & SMTP_DISABLE_DROP_QUOTA) ? FALSE : TRUE);
|
|
}
|
|
|
|
BOOL IsDropDirQuotaExceeded();
|
|
|
|
// Raid 174038
|
|
BOOL DisablePickupDotStuff(void) const {return m_fDisablePickupDotStuff;}
|
|
|
|
CTcpRegIpList *UpdateDnsServerInfo(DNS_SERVER_INFO *pDnsServerInfo);
|
|
CTcpRegIpList *GetDnsServerInfo(GUID *pGuid);
|
|
};
|
|
|
|
typedef SMTP_SERVER_INSTANCE *PSMTP_SERVER_INSTANCE;
|
|
|
|
|
|
//
|
|
// signatures
|
|
//
|
|
|
|
#define SMTP_INSTANCE_SIGNATURE 'uSMT'
|
|
#define SMTP_INSTANCE_SIGNATURE_FREE 'fSMT'
|
|
|
|
|
|
|
|
//
|
|
// externs
|
|
//
|
|
|
|
DWORD
|
|
InitializeInstances(
|
|
PSMTP_IIS_SERVICE pService
|
|
);
|
|
|
|
|
|
DWORD
|
|
ActivateSmtpEndpoints(
|
|
VOID
|
|
);
|
|
|
|
#endif // _SMTPINST_H_
|
|
|
|
|
|
|