开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Email服务器 > 查看源码
MainWin.cpp
资源名称：xmail-1.22.rar　[点击查看]
上传用户：woshihumen
上传日期：2013-07-18
资源大小：484k
文件大小：13k
源码类别：

Email服务器

开发平台：

Visual C++

MainWin.cpp：源码内容
  1. /*
  2.  *  XMail by Davide Libenzi ( Intranet and Internet mail server )
  3.  *  Copyright (C) 1999,..,2004  Davide Libenzi
  4.  *
  5.  *  This program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2 of the License, or
  8.  *  (at your option) any later version.
  9.  *
  10.  *  This program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  *  GNU General Public License for more details.
  14.  *
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with this program; if not, write to the Free Software
  17.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  *
  19.  *  Davide Libenzi <davidel@xmailserver.org>
  20.  *
  21.  */
  23. #include "SysInclude.h"
  24. #include "SysDep.h"
  25. #include "SvrDefines.h"
  26. #include "SList.h"
  27. #include "ShBlocks.h"
  28. #include "UsrUtils.h"
  29. #include "SvrUtils.h"
  30. #include "MessQueue.h"
  31. #include "SMAILUtils.h"
  32. #include "QueueUtils.h"
  33. #include "AppDefines.h"
  34. #include "MailSvr.h"
  36. ///////////////////////////////////////////////////////////////////////////////
  37. //  Comment this statement if You want a normal startup ( not as a service )
  38. ///////////////////////////////////////////////////////////////////////////////
  39. #define SERVICE
  41. #define NULFILE         "nul"
  43. #ifndef SERVICE
  44. ///////////////////////////////////////////////////////////////////////////////
  45. //  Normal startup
  46. ///////////////////////////////////////////////////////////////////////////////
  48. int main(int iArgCount, char *pszArgs[])
  49. {
  51. return (SvrMain(iArgCount, pszArgs));
  53. }
  55. #else // #ifndef SERVICE
  57. ///////////////////////////////////////////////////////////////////////////////
  58. //  Service startup
  59. ///////////////////////////////////////////////////////////////////////////////
  61. #define SZDEPENDENCIES              _T("Tcpip")
  62. #define SERVER_START_WAIT           8000
  63. #define SERVER_STOP_WAIT            4000
  65. static int MnSetupStdHandles(void);
  66. static VOID WINAPI ServiceCtrl(DWORD dwCtrlCode);
  67. static VOID WINAPI ServiceMain(DWORD dwArgc, LPTSTR lpszArgv[]);
  68. static BOOL CmdInstallService(DWORD dwStartType);
  69. static BOOL CmdRemoveService(void);
  70. static int CmdDebugService(int argc, TCHAR * argv[]);
  71. static BOOL ReportStatusToSCMgr(DWORD dwCurrentState, DWORD dwWin32ExitCode, DWORD dwWaitHint);
  72. static LPTSTR GetLastErrorText(LPTSTR lpszBuf, DWORD dwSize);
  73. static VOID AddToMessageLog(LPCTSTR lpszMsg);
  74. static int GetServiceNameFromModule(LPCTSTR pszModule, LPTSTR pszName, int iSize);
  76. static SERVICE_STATUS ssStatus;
  77. static SERVICE_STATUS_HANDLE sshStatusHandle = NULL;
  78. static DWORD dwErr = 0;
  79. static BOOL bDebug = FALSE;
  80. static TCHAR szErr[2048] = _T("");
  81. static TCHAR szServicePath[MAX_PATH] = _T("");
  82. static TCHAR szServiceName[128] = _T("");
  83. static TCHAR szServiceDispName[256] = _T("");
  85. static int MnSetupStdHandles(void)
  86. {
  88. HANDLE hInFile = CreateFile(NULFILE, GENERIC_READ | GENERIC_WRITE,
  89.     FILE_SHARE_READ | FILE_SHARE_WRITE,
  90.     NULL, OPEN_EXISTING, 0, NULL);
  92. if (hInFile == INVALID_HANDLE_VALUE) {
  93. AddToMessageLog(_T("CreateFile"));
  94. return (-1);
  95. }
  97. HANDLE hOutFile = CreateFile(NULFILE, GENERIC_READ | GENERIC_WRITE,
  98.      FILE_SHARE_READ | FILE_SHARE_WRITE,
  99.      NULL, OPEN_EXISTING, 0, NULL);
  101. if (hOutFile == INVALID_HANDLE_VALUE) {
  102. AddToMessageLog(_T("CreateFile"));
  103. CloseHandle(hInFile);
  104. return (-1);
  105. }
  107. HANDLE hErrFile = CreateFile(NULFILE, GENERIC_READ | GENERIC_WRITE,
  108.      FILE_SHARE_READ | FILE_SHARE_WRITE,
  109.      NULL, OPEN_EXISTING, 0, NULL);
  111. if (hErrFile == INVALID_HANDLE_VALUE) {
  112. AddToMessageLog(_T("CreateFile"));
  113. CloseHandle(hOutFile);
  114. CloseHandle(hInFile);
  115. return (-1);
  116. }
  118. if (!SetStdHandle(STD_INPUT_HANDLE, hInFile) || !SetStdHandle(STD_OUTPUT_HANDLE, hOutFile)
  119.     || !SetStdHandle(STD_ERROR_HANDLE, hErrFile)) {
  120. AddToMessageLog(_T("SetStdHandle"));
  121. CloseHandle(hErrFile);
  122. CloseHandle(hOutFile);
  123. CloseHandle(hInFile);
  124. return (-1);
  125. }
  127. return (0);
  129. }
  131. int _tmain(int argc, TCHAR * argv[])
  132. {
  134. if (GetModuleFileName(NULL, szServicePath, CountOf(szServicePath)) == 0) {
  135. _tprintf(_T("Unable to get module name - %sn"),
  136.  GetLastErrorText(szErr, CountOf(szErr)));
  137. return (1);
  138. }
  139. GetServiceNameFromModule(szServicePath, szServiceName, CountOf(szServiceName));
  140. _stprintf(szServiceDispName, _T("%s Server"), szServiceName);
  142. SERVICE_TABLE_ENTRY DispTable[] = {
  143. {szServiceName, (LPSERVICE_MAIN_FUNCTION) ServiceMain}
  144. ,
  145. {NULL, NULL}
  146. };
  148. if (argc > 1) {
  149. if (_tcsicmp(_T("--install"), argv[1]) == 0) {
  150. CmdInstallService(SERVICE_DEMAND_START);
  151. return (0);
  152. }
  153. if (_tcsicmp(_T("--install-auto"), argv[1]) == 0) {
  154. CmdInstallService(SERVICE_AUTO_START);
  155. return (0);
  156. } else if (_tcsicmp(_T("--remove"), argv[1]) == 0) {
  157. CmdRemoveService();
  158. return (0);
  159. } else if (_tcsicmp(_T("--debug"), argv[1]) == 0) {
  160. bDebug = TRUE;
  161. CmdDebugService(argc, argv);
  162. return (0);
  163. }
  164. }
  166. _tprintf(_T("%s --install          = Install the servicen"), argv[0]);
  167. _tprintf(_T("%s --remove           = Remove the servicen"), argv[0]);
  168. _tprintf(_T("%s --debug [params]   = Run as a console app for debuggingn"), argv[0]);
  170. _tprintf(_T("nStartServiceCtrlDispatcher being called.n"));
  171. _tprintf(_T("This may take several seconds.  Please wait.n"));
  173. ///////////////////////////////////////////////////////////////////////////////
  174. //  Setup std handles
  175. ///////////////////////////////////////////////////////////////////////////////
  176. if (MnSetupStdHandles() < 0)
  177. return (1);
  179. ///////////////////////////////////////////////////////////////////////////////
  180. //  Service loop
  181. ///////////////////////////////////////////////////////////////////////////////
  182. if (!StartServiceCtrlDispatcher(DispTable))
  183. AddToMessageLog(_T("StartServiceCtrlDispatcher"));
  185. return (0);
  187. }
  189. static void WINAPI ServiceMain(DWORD dwArgc, LPTSTR lpszArgv[])
  190. {
  192. if ((sshStatusHandle = RegisterServiceCtrlHandler(szServiceName, ServiceCtrl)) != NULL) {
  193. ZeroData(ssStatus);
  195. ssStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
  196. ssStatus.dwServiceSpecificExitCode = 0;
  198. if (ReportStatusToSCMgr(SERVICE_START_PENDING, NO_ERROR, SERVER_START_WAIT)) {
  199. ReportStatusToSCMgr(SERVICE_RUNNING, NO_ERROR, 0);
  201. ///////////////////////////////////////////////////////////////////////////////
  202. //  Run server
  203. ///////////////////////////////////////////////////////////////////////////////
  204. int iSvrResult = SvrMain((int) dwArgc, lpszArgv);
  206. if (iSvrResult < 0) {
  208. AddToMessageLog(ErrGetErrorString(iSvrResult));
  210. }
  211. }
  213. ReportStatusToSCMgr(SERVICE_STOPPED, dwErr, 0);
  214. } else
  215. AddToMessageLog(_T("RegisterServiceCtrlHandler"));
  217. }
  219. static VOID WINAPI ServiceCtrl(DWORD dwCtrlCode)
  220. {
  222. switch (dwCtrlCode) {
  223. case (SERVICE_CONTROL_SHUTDOWN):
  224. case (SERVICE_CONTROL_STOP):
  225. {
  226. ReportStatusToSCMgr(SERVICE_STOP_PENDING, NO_ERROR, SERVER_STOP_WAIT);
  228. ///////////////////////////////////////////////////////////////////////////////
  229. //  Signal the server to stop and wait for completion
  230. ///////////////////////////////////////////////////////////////////////////////
  231. SvrStopServer(false);
  233. while (SvrInShutdown()) {
  234. Sleep(SERVER_STOP_WAIT / 2);
  235. ReportStatusToSCMgr(SERVICE_STOP_PENDING, NO_ERROR,
  236.     SERVER_STOP_WAIT);
  237. }
  239. ReportStatusToSCMgr(SERVICE_STOPPED, 0, 0);
  240. }
  241. break;
  243. default:
  244. ReportStatusToSCMgr(ssStatus.dwCurrentState, NO_ERROR, 0);
  245. }
  247. }
  249. static BOOL ReportStatusToSCMgr(DWORD dwCurrentState, DWORD dwWin32ExitCode, DWORD dwWaitHint)
  250. {
  252. static DWORD dwCheckPoint = 1;
  253. BOOL bResult = TRUE;
  255. if (!bDebug) {
  256. if (dwCurrentState == SERVICE_START_PENDING)
  257. ssStatus.dwControlsAccepted = 0;
  258. else
  259. ssStatus.dwControlsAccepted =
  260.     SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
  262. ssStatus.dwCurrentState = dwCurrentState;
  263. ssStatus.dwWin32ExitCode = dwWin32ExitCode;
  264. ssStatus.dwWaitHint = dwWaitHint;
  266. if ((dwCurrentState == SERVICE_RUNNING) || (dwCurrentState == SERVICE_STOPPED))
  267. ssStatus.dwCheckPoint = 0;
  268. else
  269. ssStatus.dwCheckPoint = dwCheckPoint++;
  271. if (!(bResult = SetServiceStatus(sshStatusHandle, &ssStatus)))
  272. AddToMessageLog(_T("SetServiceStatus"));
  274. }
  276. return (bResult);
  278. }
  280. static VOID AddToMessageLog(LPCTSTR lpszMsg)
  281. {
  283. HANDLE hEventSource = NULL;
  284. LPTSTR lpszStrings[2];
  285. TCHAR szMsg[512] = _T("");
  286. TCHAR szErrMsg[2048] = _T("");
  288. if (!bDebug) {
  289. dwErr = GetLastError();
  291. GetLastErrorText(szErr, CountOf(szErr));
  293. _stprintf(szMsg, _T("%s error: %d"), szServiceName, dwErr);
  294. _stprintf(szErrMsg, _T("{%s}: %s"), lpszMsg, szErr);
  296. lpszStrings[0] = szMsg;
  297. lpszStrings[1] = szErrMsg;
  299. if ((hEventSource = RegisterEventSource(NULL, szServiceName)) != NULL) {
  300. ReportEvent(hEventSource, // handle of event source
  301.     EVENTLOG_ERROR_TYPE, // event type
  302.     0, // event category
  303.     0, // event ID
  304.     NULL, // current user's SID
  305.     2, // strings in lpszStrings
  306.     0, // no bytes of raw data
  307.     (const char **) lpszStrings, // array of error strings
  308.     NULL); // no raw data
  310. DeregisterEventSource(hEventSource);
  311. }
  312. }
  314. }
  316. static BOOL CmdInstallService(DWORD dwStartType)
  317. {
  319. SC_HANDLE schService = NULL;
  320. SC_HANDLE schSCManager = NULL;
  322. if ((schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS)) != NULL) {
  323. schService = CreateService(schSCManager, // SCManager database
  324.    szServiceName, // name of service
  325.    szServiceDispName, // name to display
  326.    SERVICE_ALL_ACCESS, // desired access
  327.    SERVICE_WIN32_OWN_PROCESS, // service type
  328.    dwStartType, // start type
  329.    SERVICE_ERROR_NORMAL, // error control type
  330.    szServicePath, // service's binary
  331.    NULL, // no load ordering group
  332.    NULL, // no tag identifier
  333.    SZDEPENDENCIES, // dependencies
  334.    NULL, // LocalSystem account
  335.    NULL); // no password
  337. if (schService != NULL) {
  338. _tprintf(_T("%s installed.n"), szServiceDispName);
  339. CloseServiceHandle(schService);
  340. CloseServiceHandle(schSCManager);
  342. return (TRUE);
  343. } else
  344. _tprintf(_T("CreateService failed - %sn"),
  345.  GetLastErrorText(szErr, CountOf(szErr)));
  347. CloseServiceHandle(schSCManager);
  348. } else
  349. _tprintf(_T("OpenSCManager failed - %sn"),
  350.  GetLastErrorText(szErr, CountOf(szErr)));
  352. return (FALSE);
  354. }
  356. static BOOL CmdRemoveService(void)
  357. {
  359. SC_HANDLE schService = NULL;
  360. SC_HANDLE schSCManager = NULL;
  362. if ((schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS)) != NULL) {
  363. schService = OpenService(schSCManager, szServiceName, SERVICE_ALL_ACCESS);
  365. if (schService != NULL) {
  366. if (ControlService(schService, SERVICE_CONTROL_STOP, &ssStatus)) {
  367. _tprintf(_T("Stopping %s."), szServiceDispName);
  368. Sleep(1000);
  370. while (QueryServiceStatus(schService, &ssStatus)) {
  371. if (ssStatus.dwCurrentState == SERVICE_STOP_PENDING) {
  372. _tprintf(_T("."));
  373. Sleep(1000);
  374. } else
  375. break;
  376. }
  378. if (ssStatus.dwCurrentState == SERVICE_STOPPED)
  379. _tprintf(_T("n%s stopped.n"), szServiceDispName);
  380. else
  381. _tprintf(_T("n%s failed to stop.n"), szServiceDispName);
  383. }
  385. if (DeleteService(schService)) {
  386. _tprintf(_T("%s removed.n"), szServiceDispName);
  387. CloseServiceHandle(schService);
  388. CloseServiceHandle(schSCManager);
  390. return (TRUE);
  391. } else
  392. _tprintf(_T("DeleteService failed - %sn"),
  393.  GetLastErrorText(szErr, CountOf(szErr)));
  395. CloseServiceHandle(schService);
  396. } else
  397. _tprintf(_T("OpenService failed - %sn"),
  398.  GetLastErrorText(szErr, CountOf(szErr)));
  400. CloseServiceHandle(schSCManager);
  401. } else
  402. _tprintf(_T("OpenSCManager failed - %sn"),
  403.  GetLastErrorText(szErr, CountOf(szErr)));
  405. return (FALSE);
  407. }
  409. static int CmdDebugService(int argc, LPTSTR argv[])
  410. {
  412. _tprintf(_T("Debugging %s.n"), szServiceDispName);
  414. ///////////////////////////////////////////////////////////////////////////////
  415. //  Run server
  416. ///////////////////////////////////////////////////////////////////////////////
  417. return (SvrMain(argc, argv));
  419. }
  421. static LPTSTR GetLastErrorText(LPTSTR lpszBuf, DWORD dwSize)
  422. {
  424. DWORD dwRet;
  425. DWORD dwError = GetLastError();
  426. LPTSTR lpszTemp = NULL;
  428. dwRet =
  429.     FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
  430.   FORMAT_MESSAGE_ARGUMENT_ARRAY, NULL, dwError, LANG_NEUTRAL,
  431.   (LPTSTR) & lpszTemp, 0, NULL);
  433. if ((dwRet == 0) || ((long) dwSize < (long) (dwRet + 14)))
  434. lpszBuf[0] = TCHAR('');
  435. else {
  436. lpszTemp[lstrlen(lpszTemp) - 2] = TCHAR('');
  438. _stprintf(lpszBuf, _T("%s (0x%x)"), lpszTemp, dwError);
  439. }
  441. if (lpszTemp != NULL)
  442. LocalFree((HLOCAL) lpszTemp);
  444. return (lpszBuf);
  446. }
  448. static int GetServiceNameFromModule(LPCTSTR pszModule, LPTSTR pszName, int iSize)
  449. {
  450. LPCTSTR pszSlash;
  451. LPCTSTR pszDot;
  453. if ((pszSlash = _tcsrchr(pszModule, (TCHAR) '\')) == NULL)
  454. pszSlash = pszModule;
  455. else
  456. pszSlash++;
  457. if ((pszDot = _tcschr(pszSlash, (TCHAR) '.')) == NULL)
  458. pszDot = pszSlash + _tcslen(pszSlash);
  459. iSize = Min(iSize - 1, (int) (pszDot - pszSlash));
  460. Cpy2Sz(pszName, pszSlash, iSize);
  462. return (0);
  463. }
  465. #endif // #ifndef SERVICE