archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
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.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Tree: daad8a087a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'daad8a087a'
${ noResults }
windows-xp/Source/XPSP1/NT/inetsrv/iis/svcs/smtp/server/main.cxx

799 lines
19 KiB
Raw Blame History

/**********************************************************************/
/** Microsoft Windows NT **/
/** Copyright(c) Microsoft Corp., 1993 **/
/**********************************************************************/
/*
main.cxx
This module contains the main startup code for the SMTP Service.
FILE HISTORY:
KeithMo 07-Mar-1993 Created.
JohnL ????
MuraliK 11-July-1995 Used Ipc() functions from Inetsvcs.dll
*/
#define INCL_INETSRV_INCS
#include "smtpinc.h"
#include "inetsvcs.h"
#include <metacach.hxx>
#include <dbgutil.h>
// ATL Header files
#define _ATL_NO_DEBUG_CRT
#define _ASSERTE _ASSERT
#define _WINDLL
#include "atlbase.h"
extern CComModule _Module;
#include "atlcom.h"
#undef _WINDLL
#ifdef _ATL_STATIC_REGISTRY
#include <statreg.h>
#include <statreg.cpp>
#endif
#include <atlimpl.cpp>
//
// RPC related includes
//
extern "C" {
#include <inetinfo.h>
#include <smtpsvc.h>
};
#include <smtpinet.h>
extern DWORD g_cMaxConnectionObjs;
BOOL
InitializeSmtpServiceRpc(
IN LPCSTR pszServiceName,
IN RPC_IF_HANDLE hRpcInterface
);
BOOL CleanupSmtpServiceRpc(
VOID
);
//
// Private constants.
//
BOOL fAnySecureFilters = FALSE;
//
// for PDC hack
//
#define VIRTUAL_ROOTS_KEY_A "Virtual Roots"
#define HTTP_EXT_MAPS "Script Map"
#define SMTP_MODULE_NAME "smtpsvc"
//
// Global startup named event
//
DWORD GlobalInitializeStatus = 0;
BOOL g_ServiceBooted = FALSE;
//
// Private globals.
//
#define INITIALIZE_IPC 0x00000001
#define INITIALIZE_SOCKETS 0x00000002
#define INITIALIZE_ACCESS 0x00000004
#define INITIALIZE_SERVICE 0x00000008
#define INITIALIZE_CONNECTIONS 0x00000010
#define INITIALIZE_DISCOVERY 0x00000020
#define INITIALIZE_RPC 0x00000040
#define INITIALIZE_GLOBALS 0x00000080
#define INITIALIZE_COMMON_DLLS 0x00000100
#define INITIALIZE_ROUTE_SORT 0x00000200
#define INITIALIZE_FIO 0x00000400
DEFINE_TSVC_INFO_INTERFACE();
DECLARE_DEBUG_PRINTS_OBJECT();
#ifndef _NO_TRACING_
#include <initguid.h>
DEFINE_GUID(IisSmtpServerGuid,
0x784d8907, 0xaa8c, 0x11d2, 0x92, 0x5e, 0x00, 0xc0, 0x4f, 0x72, 0xd9, 0x0e);
#else
DECLARE_DEBUG_VARIABLE();
#endif
//
// The following critical section synchronizes execution in ServiceEntry().
// This is necessary because the NT Service Controller may reissue a service
// start notification immediately after we have set our status to stopped.
// This can lead to an unpleasant race condition in ServiceEntry() as one
// thread cleans up global state as another thread is initializing it.
//
CRITICAL_SECTION g_csServiceEntryLock;
//
// Private prototypes.
//
extern VOID SmtpOnConnect( IN SOCKET sNew,
IN SOCKADDR_IN * psockaddr, //Should be SOCKADDR *
IN PVOID pEndpointContext,
IN PVOID pAtqEndpointObject );
extern VOID
SmtpOnConnectEx(
VOID * patqContext,
DWORD cbWritten,
DWORD err,
OVERLAPPED * lpo
);
VOID
SmtpCompletion(
PVOID pvContext,
DWORD cbWritten,
DWORD dwCompletionStatus,
OVERLAPPED * lpo
);
APIERR InitializeService( LPVOID pContext );
APIERR TerminateService( LPVOID pContext );
VOID TerminateInstances( PSMTP_IIS_SERVICE pService);
/************************************************************
* Symbolic Constants
************************************************************/
static TCHAR szTcpipPath[] = TEXT("System\\CurrentControlSet\\Services\\Tcpip\\Parameters");
/************************************************************
* ATL Module
************************************************************/
CComModule _Module;
BEGIN_OBJECT_MAP(ObjectMap)
END_OBJECT_MAP()
#if 0
/************************************************************
* ATL Module
************************************************************/
CComModule _Module;
BEGIN_OBJECT_MAP(ObjectMap)
END_OBJECT_MAP()
#endif
//+---------------------------------------------------------------------------
//
// Function:
//
// DllEntryPoint
//
// Synopsis:
// Arguments:
// Returns:
// See Win32 SDK
//
// History:
//
// Richard Kamicar (rkamicar) 5 January 1996
//
// Notes:
//
// If we find we need this per service, we can move it out of here..
//
//----------------------------------------------------------------------------
BOOL WINAPI
DllEntryPoint(HINSTANCE hInst, DWORD dwReason, LPVOID lpvContext)
{
switch (dwReason)
{
case DLL_PROCESS_ATTACH:
#ifndef _NO_TRACING_
CREATE_DEBUG_PRINT_OBJECT( SMTP_MODULE_NAME, IisSmtpServerGuid);
#else
CREATE_DEBUG_PRINT_OBJECT( SMTP_MODULE_NAME);
SET_DEBUG_FLAGS( 0);
#endif
//
// To help performance, cancel thread attach and detach notifications
//
_Module.Init(ObjectMap, hInst);
DisableThreadLibraryCalls((HMODULE) hInst);
InitializeCriticalSection( &g_csServiceEntryLock );
break;
case DLL_PROCESS_DETACH:
// Shutdown ATL
_Module.Term();
#ifdef _NO_TRACING_
DBG_CLOSE_LOG_FILE();
#endif
DELETE_DEBUG_PRINT_OBJECT();
DeleteCriticalSection( &g_csServiceEntryLock );
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
break;
}
return TRUE;
}
BOOL WINAPI DllMain (HANDLE hInst, ULONG dwReason, LPVOID lpvReserve)
{
return DllEntryPoint((HINSTANCE) hInst, dwReason, lpvReserve);
}
//
// Public functions.
//
VOID
ServiceEntry(
DWORD cArgs,
LPSTR pArgs[],
PTCPSVCS_GLOBAL_DATA pGlobalData // unused
)
/*++
Routine:
This is the "real" entrypoint for the service. When
the Service Controller dispatcher is requested to
start a service, it creates a thread that will begin
executing this routine.
Arguments:
cArgs - Number of command line arguments to this service.
pArgs - Pointers to the command line arguments.
Returns:
None. Does not return until service is stopped.
--*/
{
APIERR err = NO_ERROR;
BOOL fInitSvcObject = FALSE;
EnterCriticalSection( &g_csServiceEntryLock );
if ( !InitCommonDlls() )
{
DBGPRINTF(( DBG_CONTEXT,
"[ServiceEntry] InitCommonDlls failed! Bailing\n" ));
err = GetLastError();
LeaveCriticalSection( &g_csServiceEntryLock );
goto notify_scm;
}
InitAsyncTrace();
GlobalInitializeStatus |= INITIALIZE_COMMON_DLLS;
if (!InitializeCache()) goto exit;
GlobalInitializeStatus |= INITIALIZE_FIO;
//
// Initialize Globals
//
err = InitializeGlobals();
if ( err != NO_ERROR )
{
goto exit;
}
GlobalInitializeStatus |= INITIALIZE_GLOBALS;
// Initialize the service status structure.
//
g_pInetSvc = new SMTP_IIS_SERVICE(
SMTP_SERVICE_NAME_A,
SMTP_MODULE_NAME,
SMTP_PARAMETERS_KEY,
INET_SMTP_SVC_ID,
INET_SMTP_SVCLOC_ID,
TRUE,
0,
SmtpOnConnect,
SmtpOnConnectEx,
SmtpCompletion
);
//
// If we couldn't allocate memory for the service info struct, then the
// machine is really hosed.
//
if( ( g_pInetSvc != NULL ) && g_pInetSvc->IsActive() )
{
err = ((SMTP_IIS_SERVICE *)g_pInetSvc)->LoadAdvancedQueueingDll();
if( err != NO_ERROR )
goto exit;
fInitSvcObject = TRUE;
err = g_pInetSvc->StartServiceOperation(
SERVICE_CTRL_HANDLER(),
InitializeService,
TerminateService
);
if ( err )
{
//
// The event has already been logged
//
DBGPRINTF(( DBG_CONTEXT,
"SMTP ServiceEntry: StartServiceOperation returned %d\n",
err ));
}
}
else if (g_pInetSvc == NULL)
{
err = ERROR_NOT_ENOUGH_MEMORY;
}
else
{
err = g_pInetSvc->QueryCurrentServiceError();
}
exit:
if ( g_pInetSvc != NULL )
{
g_pInetSvc->CloseService( );
}
TerminateGlobals( );
if( GlobalInitializeStatus & INITIALIZE_FIO)
{
TerminateCache();
}
if( GlobalInitializeStatus & INITIALIZE_COMMON_DLLS)
{
TerminateCommonDlls();
}
TermAsyncTrace();
LeaveCriticalSection( &g_csServiceEntryLock );
notify_scm:
//
// We need to tell the Service Control Manager that the service
// is stopped if we haven't called g_pInetSvc->StartServiceOperation.
// 1) InitCommonDlls fails, or
// 2) InitializeGlobals failed, or
// 3) new operator failed, or
// 4) SMTP_IIS_SERVICE constructor couldn't initialize properly
//
if ( !fInitSvcObject ) {
SERVICE_STATUS_HANDLE hsvcStatus;
SERVICE_STATUS svcStatus;
hsvcStatus = RegisterServiceCtrlHandler( SMTP_SERVICE_NAME,
SERVICE_CTRL_HANDLER() );
if ( hsvcStatus != NULL_SERVICE_STATUS_HANDLE ) {
svcStatus.dwServiceType = SERVICE_WIN32_SHARE_PROCESS;
svcStatus.dwCurrentState = SERVICE_STOPPED;
svcStatus.dwWin32ExitCode = err;
svcStatus.dwServiceSpecificExitCode = err;
svcStatus.dwControlsAccepted = 0;
svcStatus.dwCheckPoint = 0;
svcStatus.dwWaitHint = 0;
SetServiceStatus( hsvcStatus, (LPSERVICE_STATUS) &svcStatus );
}
}
} // ServiceEntry
//
// Private functions.
//
APIERR
InitializeService(
LPVOID pContext
)
/*++
Routine:
This function initializes the various SMTP Service components.
Arguments:
lpContext - Pointer to the service object
Returns:
NO_ERROR if successful, otherwise a Win32
status code.
--*/
{
APIERR err;
DWORD dwErr = NO_ERROR;
PSMTP_IIS_SERVICE psi = (PSMTP_IIS_SERVICE)pContext;
MB mb( (IMDCOM*) psi->QueryMDObject() );
STR TempString;
char szTcpipName[MAX_PATH + 1];
BOOL bUpdatedDomain;
BOOL bUpdatedFQDN;
HRESULT hr;
g_IsShuttingDown = FALSE;
TraceFunctEnter("InitializeService");
DBGPRINTF(( DBG_CONTEXT,
"initializing Smtp service\n" ));
SetLastError(NO_ERROR);
psi->StartHintFunction();
hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
if (FAILED(hr))
{
DBGPRINTF(( DBG_CONTEXT,
"Cannot CoInitialize, error %lu\n",
hr ));
FatalTrace(0,"Cannot CoInitialize, error %d",hr);
// TraceFunctLeave();
// return hr;
}
g_ProductType = 5;
psi->StartHintFunction();
//g_ProductType = 0;
if ( !mb.Open( "/LM/SMTPSVC/",
METADATA_PERMISSION_READ | METADATA_PERMISSION_WRITE ))
{
DBGPRINTF(( DBG_CONTEXT,
"InitializeService: Cannot open path %s, error %lu\n",
"/LM/SMTPSVC/", GetLastError() ));
g_pInetSvc->ShutdownService( );
TraceFunctLeave();
return ERROR_SERVICE_DISABLED;
}
g_ServiceBooted = TRUE;
//
// Initialize the Default Domain, Fully Qualified Domain Name (FQDN) settings.
// The service will use the default TCP/IP settings in the control panel for these
// values if the user has never modified the settings.
//
DWORD tmp;
if (!mb.GetDword("", MD_UPDATED_DEFAULT_DOMAIN, IIS_MD_UT_SERVER, &tmp))
{
bUpdatedDomain = FALSE;
}
else
{
bUpdatedDomain = !!tmp;
}
if (!mb.GetDword("", MD_UPDATED_FQDN, IIS_MD_UT_SERVER, &tmp))
{
bUpdatedFQDN = FALSE;
}
else
{
bUpdatedFQDN = !!tmp;
}
psi->StartHintFunction();
szTcpipName[0] = '\0';
lstrcpyn(szTcpipName, g_ComputerName, MAX_PATH);
//
// will need to check against TCP/IP settings
//
HKEY hkeyTcpipParam = NULL;
DWORD SizeOfBuffer = 0;
DWORD cbOffset;
DWORD dwType;
DWORD err2;
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, szTcpipPath, 0, KEY_QUERY_VALUE, &hkeyTcpipParam) == ERROR_SUCCESS)
{
SizeOfBuffer = MAX_PATH;
err2 = RegQueryValueEx(hkeyTcpipParam, "Hostname", 0, &dwType, (LPBYTE)szTcpipName, &SizeOfBuffer);
if (err2 != ERROR_SUCCESS || SizeOfBuffer <= 1 || dwType != REG_SZ)
{
lstrcpyn(szTcpipName, g_ComputerName, MAX_PATH);
}
else
{
cbOffset = SizeOfBuffer - 1;
szTcpipName[cbOffset] = '.';
SizeOfBuffer = MAX_PATH - (cbOffset);
err2 = RegQueryValueEx(hkeyTcpipParam, "Domain", 0, &dwType, (LPBYTE)szTcpipName + cbOffset + 1, &SizeOfBuffer);
if (err2 != ERROR_SUCCESS || SizeOfBuffer <= 1 || dwType != REG_SZ)
{
szTcpipName[cbOffset] = '\0';
}
}
_VERIFY(RegCloseKey(hkeyTcpipParam) == ERROR_SUCCESS);
}
((SMTP_IIS_SERVICE *) g_pInetSvc)->SetTcpipName(szTcpipName);
if (!bUpdatedDomain)
{
TempString.Reset();
if(! mb.GetStr("", MD_DEFAULT_DOMAIN_VALUE, IIS_MD_UT_SERVER, &TempString) ||
TempString.IsEmpty())
{
mb.SetString("", MD_DEFAULT_DOMAIN_VALUE, IIS_MD_UT_SERVER, szTcpipName);
}
else
{
if (lstrcmpi(szTcpipName,TempString.QueryStr()))
//
// no match, update
//
{
mb.SetString("", MD_DEFAULT_DOMAIN_VALUE, IIS_MD_UT_SERVER, szTcpipName);
}
}
}
if (!bUpdatedFQDN)
{
TempString.Reset();
if(! mb.GetStr("", MD_FQDN_VALUE, IIS_MD_UT_SERVER, &TempString) ||
TempString.IsEmpty())
{
mb.SetString("", MD_FQDN_VALUE, IIS_MD_UT_SERVER, szTcpipName);
}
else
{
if (lstrcmpi(szTcpipName,TempString.QueryStr()))
//
// no match, update
//
{
mb.SetString("", MD_FQDN_VALUE, IIS_MD_UT_SERVER, szTcpipName);
}
}
}
if (!mb.GetDword("", MD_MAX_MAIL_OBJECTS, IIS_MD_UT_SERVER, &g_cMaxConnectionObjs))
{
g_cMaxConnectionObjs = 5000;
}
mb.Close();
psi->StartHintFunction();
//
// Initialize various components. The ordering of the
// components is somewhat limited. Globals should be
// initialized first, then the event logger. After
// the event logger is initialized, the other components
// may be initialized in any order with one exception.
// InitializeSockets must be the last initialization
// routine called. It kicks off the main socket connection
// thread.
//
if( err = psi->InitializeDiscovery( ))
{
DBGPRINTF(( DBG_CONTEXT,
"psi->InitializeDiscovery failed, error %lu\n",
err ));
FatalTrace(0,"psi->InitializeDiscovery failed %d\n",err);
TraceFunctLeave();
return err;
}
GlobalInitializeStatus |= INITIALIZE_DISCOVERY;
if( err = psi->InitializeSockets( ) )
{
DBGPRINTF(( DBG_CONTEXT,
"cannot initialize service, error %lu\n",
err ));
FatalTrace(0,"psi->InitializeSockets failed %d\n",err);
TraceFunctLeave();
return err;
}
GlobalInitializeStatus |= INITIALIZE_SOCKETS;
psi->StartHintFunction();
if(!InitializeSmtpServiceRpc(SMTP_SERVICE_NAME, smtp_ServerIfHandle))
{
err = GetLastError();
DBGPRINTF(( DBG_CONTEXT,
"cannot initialize RPC service, error %lu\n",
err ));
FatalTrace(0,"InitializeSmtpServiceRpc failed %d\n",err);
TraceFunctLeave();
return err;
}
GlobalInitializeStatus |= INITIALIZE_RPC;
//
// Reset any Service Principal Names (for Kerberos) that may have been
// registered
//
if (psi->ResetServicePrincipalNames()) {
DebugTrace(
0,
"Unable to reset Kerberos Principal Names %lu, will try later",
GetLastError());
}
//
// Read and activate all the instances configured
//
InitializeInstances( psi );
//
// Success!
//
DBGPRINTF(( DBG_CONTEXT, "SMTP Service initialized\n" ));
TraceFunctLeave();
return NO_ERROR;
} // InitializeService
APIERR TerminateService(IN LPVOID pContext)
/*++
Routine:
This function cleans up the various SMTP Service components.
Arguments:
pContext - Pointer to the service object
Returns:
NO_ERROR if successful, otherwise a Win32
status code.
--*/
{
PSMTP_IIS_SERVICE psi = (PSMTP_IIS_SERVICE)pContext;
DWORD err;
TraceFunctEnter("TerminateService");
if(!g_ServiceBooted)
{
ErrorTrace(NULL, "Smtp service not started, returning");
return NO_ERROR;
}
g_ServiceBooted = FALSE ;
g_IsShuttingDown = TRUE;
DBG_ASSERT( pContext == g_pInetSvc);
DBGPRINTF(( DBG_CONTEXT,
" SMTP terminating service\n" ));
//
// Components should be terminated in reverse
// initialization order.
//
//get an exclusive lock on the server.
//this will wait until all RPCs have
//exited out of the server and then
//return
psi->AcquireServiceExclusiveLock();
psi->ReleaseServiceExclusiveLock();
TerminateInstances(psi);
g_pInetSvc->ShutdownService( );
if( GlobalInitializeStatus & INITIALIZE_DISCOVERY)
{
if ( (err = psi->TerminateDiscovery()) != NO_ERROR)
{
DBGPRINTF(( DBG_CONTEXT, "TerminateDiscovery() failed. Error = %u\n",
err));
}
}
if( GlobalInitializeStatus & INITIALIZE_SOCKETS)
{
psi->CleanupSockets( );
}
TsFlushMetaCache(METACACHE_SMTP_SERVER_ID,TRUE);
if( GlobalInitializeStatus & INITIALIZE_RPC)
{
CleanupSmtpServiceRpc();
}
CoFreeUnusedLibraries();
CoUninitialize();
DBGPRINTF(( DBG_CONTEXT,"service terminated\n" ));
TraceFunctLeave();
return NO_ERROR;
} // TerminateService