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

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

Email服务器

开发平台：

Visual C++

MailSvr.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 "StrUtils.h"
  29. #include "BuffSock.h"
  30. #include "MailConfig.h"
  31. #include "MiscUtils.h"
  32. #include "ResLocks.h"
  33. #include "POP3Svr.h"
  34. #include "SMTPSvr.h"
  35. #include "SMAILSvr.h"
  36. #include "PSYNCSvr.h"
  37. #include "DNS.h"
  38. #include "DNSCache.h"
  39. #include "UsrUtils.h"
  40. #include "SvrUtils.h"
  41. #include "MessQueue.h"
  42. #include "SMAILUtils.h"
  43. #include "QueueUtils.h"
  44. #include "ExtAliases.h"
  45. #include "AliasDomain.h"
  46. #include "MailDomains.h"
  47. #include "POP3GwLink.h"
  48. #include "CTRLSvr.h"
  49. #include "FINGSvr.h"
  50. #include "LMAILSvr.h"
  51. #include "DynDNS.h"
  52. #include "AppDefines.h"
  53. #include "MailSvr.h"
  55. #define ENV_MAIN_PATH               "MAIL_ROOT"
  56. #define ENV_CMD_LINE                "MAIL_CMD_LINE"
  57. #define SVR_SHUTDOWN_FILE           ".shutdown"
  58. #define STD_SMAIL_THREADS           16
  59. #define MAX_SMAIL_THREADS           256
  60. #define STD_SMAIL_RETRY_TIMEOUT     480
  61. #define STD_SMAIL_RETRY_INCR_RATIO  16
  62. #define STD_SMAIL_MAX_RETRY         32
  63. #define STD_PSYNC_INTERVAL          120
  64. #define STD_PSYNC_NUM_THREADS       8
  65. #define MAX_PSYNC_NUM_THREADS       32
  66. #define STD_POP3_BADLOGIN_WAIT      5
  67. #define MAX_POP3_THREADS            1024
  68. #define MAX_SMTP_THREADS            1024
  69. #define STD_SMTP_MAX_RCPTS          100
  70. #define MAX_CTRL_THREADS            512
  71. #define STD_LMAIL_THREADS           3
  72. #define MAX_LMAIL_THREADS           17
  73. #define STD_LMAILTHREAD_SLEEP_TIME  2
  74. #define SVR_EXIT_WAIT               480
  75. #define STD_SERVER_SESSION_TIMEOUT  90
  76. #define MAX_CLIENTS_WAIT            300
  77. #define CTRL_SERVER_SESSION_TIMEOUT 120
  78. #define SERVER_SLEEP_TIMESLICE      2
  79. #define SHUTDOWN_CHECK_TIME         2
  80. #define STD_POP3AUTH_EXPIRE_TIME    (15 * 60)
  81. #define FILTER_TIMEOUT              90
  83. static void SvrShutdownCleanup(void);
  84. static int SvrSetShutdown(void);
  85. static int SvrSetupCTRL(int iArgCount, char *pszArgs[]);
  86. static void SvrCleanupCTRL(void);
  87. static int SvrSetupFING(int iArgCount, char *pszArgs[]);
  88. static void SvrCleanupFING(void);
  89. static int SvrSetupPOP3(int iArgCount, char *pszArgs[]);
  90. static void SvrCleanupPOP3(void);
  91. static int SvrSetupSMTP(int iArgCount, char *pszArgs[]);
  92. static void SvrCleanupSMTP(void);
  93. static int SvrSetupSMAIL(int iArgCount, char *pszArgs[]);
  94. static void SvrCleanupSMAIL(void);
  95. static int SvrSetupPSYNC(int iArgCount, char *pszArgs[]);
  96. static void SvrCleanupPSYNC(void);
  97. static int SvrSetupLMAIL(int iArgCount, char *pszArgs[]);
  98. static void SvrCleanupLMAIL(void);
  99. static int SvrSetup(int iArgCount, char *pszArgs[]);
  100. static void SvrCleanup(void);
  101. static void SvrBreakHandler(void);
  102. static char **SvrMergeArgs(int iArgs, char *pszArgs[], int &iArgsCount);
  104. ///////////////////////////////////////////////////////////////////////////////
  105. //  External visible variabiles
  106. ///////////////////////////////////////////////////////////////////////////////
  107. SHB_HANDLE hShbFING;
  108. SHB_HANDLE hShbCTRL;
  109. SHB_HANDLE hShbPOP3;
  110. SHB_HANDLE hShbSMTP;
  111. SHB_HANDLE hShbSMAIL;
  112. SHB_HANDLE hShbPSYNC;
  113. SHB_HANDLE hShbLMAIL;
  114. char szMailPath[SYS_MAX_PATH];
  115. QUEUE_HANDLE hSpoolQueue;
  116. SYS_SEMAPHORE hSyncSem;
  117. bool bServerDebug;
  118. int iFilterTimeout = FILTER_TIMEOUT;
  119. bool bFilterLogEnabled = false;
  120. int iLogRotateHours = LOG_ROTATE_HOURS;
  121. int iQueueSplitLevel = STD_QUEUEFS_DIRS_X_LEVEL;
  123. #ifdef __UNIX__
  124. int iMailboxType = XMAIL_MAILDIR;
  125. #else
  126. int iMailboxType = XMAIL_MAILBOX;
  127. #endif
  129. ///////////////////////////////////////////////////////////////////////////////
  130. //  Local visible variabiles
  131. ///////////////////////////////////////////////////////////////////////////////
  132. static char szShutdownFile[SYS_MAX_PATH];
  133. static bool bServerShutdown = false;
  134. static int iNumSMAILThreads;
  135. static int iNumLMAILThreads;
  136. static SYS_THREAD hCTRLThread;
  137. static SYS_THREAD hFINGThread;
  138. static SYS_THREAD hPOP3Thread;
  139. static SYS_THREAD hSMTPThread;
  140. static SYS_THREAD hSMAILThreads[MAX_SMAIL_THREADS];
  141. static SYS_THREAD hLMAILThreads[MAX_LMAIL_THREADS];
  142. static SYS_THREAD hPSYNCThread;
  144. static void SvrShutdownCleanup(void)
  145. {
  147. CheckRemoveFile(szShutdownFile);
  149. bServerShutdown = false;
  151. }
  153. static int SvrSetShutdown(void)
  154. {
  155. ///////////////////////////////////////////////////////////////////////////////
  156. //  Set the shutdown flag and shutdown the library
  157. ///////////////////////////////////////////////////////////////////////////////
  158. bServerShutdown = true;
  160. SysShutdownLibrary();
  162. FILE *pFile = fopen(szShutdownFile, "wt");
  164. if (pFile == NULL) {
  165. ErrSetErrorCode(ERR_FILE_CREATE, szShutdownFile);
  166. return (ERR_FILE_CREATE);
  167. }
  169. char szShutdownTimeStr[256] = "";
  171. MscGetTimeStr(szShutdownTimeStr, sizeof(szShutdownTimeStr));
  173. fprintf(pFile, "%sn", szShutdownTimeStr);
  175. fclose(pFile);
  177. return (0);
  179. }
  181. static int SvrSetupCTRL(int iArgCount, char *pszArgs[])
  182. {
  184. int iPort = STD_CTRL_PORT;
  185. int iSessionTimeout = CTRL_SERVER_SESSION_TIMEOUT;
  186. int iNumAddr = 0;
  187. long lMaxThreads = MAX_CTRL_THREADS;
  188. unsigned long ulFlags = 0;
  189. SYS_INET_ADDR SvrAddr[MAX_CTRL_ACCEPT_ADDRESSES];
  191. for (int ii = 0; ii < iArgCount; ii++) {
  192. if ((pszArgs[ii][0] != '-') || (pszArgs[ii][1] != 'C'))
  193. continue;
  195. switch (pszArgs[ii][2]) {
  196. case ('p'):
  197. if (++ii < iArgCount)
  198. iPort = atoi(pszArgs[ii]);
  199. break;
  201. case ('t'):
  202. if (++ii < iArgCount)
  203. iSessionTimeout = atoi(pszArgs[ii]);
  204. break;
  206. case ('l'):
  207. ulFlags |= CTRLF_LOG_ENABLED;
  208. break;
  210. case ('I'):
  211. if ((++ii < iArgCount) &&
  212.     (MscGetServerAddress(pszArgs[ii], SvrAddr[iNumAddr]) == 0))
  213. ++iNumAddr;
  214. break;
  216. case ('X'):
  217. if (++ii < iArgCount)
  218. lMaxThreads = atol(pszArgs[ii]);
  219. break;
  220. }
  221. }
  223. if ((hShbCTRL = ShbCreateBlock(sizeof(CTRLConfig))) == SHB_INVALID_HANDLE)
  224. return (ErrGetErrorCode());
  226. CTRLConfig *pCTRLCfg = (CTRLConfig *) ShbLock(hShbCTRL);
  228. if (pCTRLCfg == NULL) {
  229. ErrorPush();
  230. ShbCloseBlock(hShbCTRL);
  231. return (ErrorPop());
  232. }
  234. pCTRLCfg->iPort = iPort;
  235. pCTRLCfg->ulFlags = ulFlags;
  236. pCTRLCfg->lThreadCount = 0;
  237. pCTRLCfg->lMaxThreads = lMaxThreads;
  238. pCTRLCfg->iSessionTimeout = iSessionTimeout;
  239. pCTRLCfg->iTimeout = STD_SERVER_TIMEOUT;
  240. pCTRLCfg->iNumAddr = iNumAddr;
  242. for (int nn = 0; nn < iNumAddr; nn++)
  243. pCTRLCfg->SvrAddr[nn] = SvrAddr[nn];
  245. ShbUnlock(hShbCTRL);
  247. if ((hCTRLThread = SysCreateThread(CTRLThreadProc, NULL)) == SYS_INVALID_THREAD) {
  248. ShbCloseBlock(hShbCTRL);
  249. return (ErrGetErrorCode());
  250. }
  252. return (0);
  254. }
  256. static void SvrCleanupCTRL(void)
  257. {
  259. ///////////////////////////////////////////////////////////////////////////////
  260. //  Stop CTRL Thread
  261. ///////////////////////////////////////////////////////////////////////////////
  262. CTRLConfig *pCTRLCfg = (CTRLConfig *) ShbLock(hShbCTRL);
  264. pCTRLCfg->ulFlags |= CTRLF_STOP_SERVER;
  266. ShbUnlock(hShbCTRL);
  268. ///////////////////////////////////////////////////////////////////////////////
  269. //  Wait CTRL
  270. ///////////////////////////////////////////////////////////////////////////////
  271. SysWaitThread(hCTRLThread, SVR_EXIT_WAIT);
  273. ///////////////////////////////////////////////////////////////////////////////
  274. //  Close CTRL Thread
  275. ///////////////////////////////////////////////////////////////////////////////
  276. SysCloseThread(hCTRLThread, 1);
  278. ShbCloseBlock(hShbCTRL);
  280. }
  282. static int SvrSetupFING(int iArgCount, char *pszArgs[])
  283. {
  285. int iPort = STD_FINGER_PORT;
  286. int iNumAddr = 0;
  287. unsigned long ulFlags = 0;
  288. SYS_INET_ADDR SvrAddr[MAX_FING_ACCEPT_ADDRESSES];
  290. for (int ii = 0; ii < iArgCount; ii++) {
  291. if ((pszArgs[ii][0] != '-') || (pszArgs[ii][1] != 'F'))
  292. continue;
  294. switch (pszArgs[ii][2]) {
  295. case ('p'):
  296. if (++ii < iArgCount)
  297. iPort = atoi(pszArgs[ii]);
  298. break;
  300. case ('l'):
  301. ulFlags |= FINGF_LOG_ENABLED;
  302. break;
  304. case ('I'):
  305. if ((++ii < iArgCount) &&
  306.     (MscGetServerAddress(pszArgs[ii], SvrAddr[iNumAddr]) == 0))
  307. ++iNumAddr;
  308. break;
  309. }
  310. }
  312. if ((hShbFING = ShbCreateBlock(sizeof(FINGConfig))) == SHB_INVALID_HANDLE)
  313. return (ErrGetErrorCode());
  315. FINGConfig *pFINGCfg = (FINGConfig *) ShbLock(hShbFING);
  317. if (pFINGCfg == NULL) {
  318. ShbCloseBlock(hShbFING);
  319. return (ErrGetErrorCode());
  320. }
  322. pFINGCfg->iPort = iPort;
  323. pFINGCfg->ulFlags = ulFlags;
  324. pFINGCfg->lThreadCount = 0;
  325. pFINGCfg->iTimeout = STD_SERVER_TIMEOUT;
  326. pFINGCfg->iNumAddr = iNumAddr;
  328. for (int nn = 0; nn < iNumAddr; nn++)
  329. pFINGCfg->SvrAddr[nn] = SvrAddr[nn];
  331. ShbUnlock(hShbFING);
  333. if ((hFINGThread = SysCreateThread(FINGThreadProc, NULL)) == SYS_INVALID_THREAD) {
  334. ShbCloseBlock(hShbFING);
  335. return (ErrGetErrorCode());
  336. }
  338. return (0);
  340. }
  342. static void SvrCleanupFING(void)
  343. {
  345. ///////////////////////////////////////////////////////////////////////////////
  346. //  Stop FING Thread
  347. ///////////////////////////////////////////////////////////////////////////////
  348. FINGConfig *pFINGCfg = (FINGConfig *) ShbLock(hShbFING);
  350. pFINGCfg->ulFlags |= FINGF_STOP_SERVER;
  352. ShbUnlock(hShbFING);
  354. ///////////////////////////////////////////////////////////////////////////////
  355. //  Wait FINGER
  356. ///////////////////////////////////////////////////////////////////////////////
  357. SysWaitThread(hFINGThread, SVR_EXIT_WAIT);
  359. ///////////////////////////////////////////////////////////////////////////////
  360. //  Close FINGER Thread
  361. ///////////////////////////////////////////////////////////////////////////////
  362. SysCloseThread(hFINGThread, 1);
  364. ShbCloseBlock(hShbFING);
  366. }
  368. static int SvrSetupPOP3(int iArgCount, char *pszArgs[])
  369. {
  371. int iPort = STD_POP3_PORT;
  372. int iSessionTimeout = STD_SERVER_SESSION_TIMEOUT;
  373. int iBadLoginWait = STD_POP3_BADLOGIN_WAIT;
  374. int iNumAddr = 0;
  375. long lMaxThreads = MAX_POP3_THREADS;
  376. unsigned long ulFlags = 0;
  377. SYS_INET_ADDR SvrAddr[MAX_POP3_ACCEPT_ADDRESSES];
  379. for (int ii = 0; ii < iArgCount; ii++) {
  380. if ((pszArgs[ii][0] != '-') || (pszArgs[ii][1] != 'P'))
  381. continue;
  383. switch (pszArgs[ii][2]) {
  384. case ('p'):
  385. if (++ii < iArgCount)
  386. iPort = atoi(pszArgs[ii]);
  387. break;
  389. case ('t'):
  390. if (++ii < iArgCount)
  391. iSessionTimeout = atoi(pszArgs[ii]);
  392. break;
  394. case ('w'):
  395. if (++ii < iArgCount)
  396. iBadLoginWait = atoi(pszArgs[ii]);
  397. break;
  399. case ('l'):
  400. ulFlags |= POP3F_LOG_ENABLED;
  401. break;
  403. case ('h'):
  404. ulFlags |= POP3F_HANG_ON_BADLOGIN;
  405. break;
  407. case ('I'):
  408. if ((++ii < iArgCount) &&
  409.     (MscGetServerAddress(pszArgs[ii], SvrAddr[iNumAddr]) == 0))
  410. ++iNumAddr;
  411. break;
  413. case ('X'):
  414. if (++ii < iArgCount)
  415. lMaxThreads = atol(pszArgs[ii]);
  416. break;
  417. }
  418. }
  420. if ((hShbPOP3 = ShbCreateBlock(sizeof(POP3Config))) == SHB_INVALID_HANDLE)
  421. return (ErrGetErrorCode());
  423. POP3Config *pPOP3Cfg = (POP3Config *) ShbLock(hShbPOP3);
  425. if (pPOP3Cfg == NULL) {
  426. ShbCloseBlock(hShbPOP3);
  427. return (ErrGetErrorCode());
  428. }
  430. pPOP3Cfg->iPort = iPort;
  431. pPOP3Cfg->ulFlags = ulFlags;
  432. pPOP3Cfg->lThreadCount = 0;
  433. pPOP3Cfg->lMaxThreads = lMaxThreads;
  434. pPOP3Cfg->iSessionTimeout = iSessionTimeout;
  435. pPOP3Cfg->iTimeout = STD_SERVER_TIMEOUT;
  436. pPOP3Cfg->iBadLoginWait = iBadLoginWait;
  437. pPOP3Cfg->iNumAddr = iNumAddr;
  439. for (int nn = 0; nn < iNumAddr; nn++)
  440. pPOP3Cfg->SvrAddr[nn] = SvrAddr[nn];
  442. ShbUnlock(hShbPOP3);
  444. ///////////////////////////////////////////////////////////////////////////////
  445. //  Remove POP3 lock files
  446. ///////////////////////////////////////////////////////////////////////////////
  447. UsrClearPop3LocksDir();
  449. if ((hPOP3Thread = SysCreateThread(POP3ThreadProc, NULL)) == SYS_INVALID_THREAD) {
  450. ShbCloseBlock(hShbPOP3);
  451. return (ErrGetErrorCode());
  452. }
  454. return (0);
  456. }
  458. static void SvrCleanupPOP3(void)
  459. {
  461. ///////////////////////////////////////////////////////////////////////////////
  462. //  Stop POP3 Thread
  463. ///////////////////////////////////////////////////////////////////////////////
  464. POP3Config *pPOP3Cfg = (POP3Config *) ShbLock(hShbPOP3);
  466. pPOP3Cfg->ulFlags |= POP3F_STOP_SERVER;
  468. ShbUnlock(hShbPOP3);
  470. ///////////////////////////////////////////////////////////////////////////////
  471. //  Wait POP3 Thread
  472. ///////////////////////////////////////////////////////////////////////////////
  473. SysWaitThread(hPOP3Thread, SVR_EXIT_WAIT);
  475. ///////////////////////////////////////////////////////////////////////////////
  476. //  Close POP3 Thread
  477. ///////////////////////////////////////////////////////////////////////////////
  478. SysCloseThread(hPOP3Thread, 1);
  480. ShbCloseBlock(hShbPOP3);
  482. }
  484. static int SvrSetupSMTP(int iArgCount, char *pszArgs[])
  485. {
  487. int iPort = STD_SMTP_PORT;
  488. int iSessionTimeout = STD_SERVER_SESSION_TIMEOUT;
  489. int iMaxRcpts = STD_SMTP_MAX_RCPTS;
  490. int iNumAddr = 0;
  491. unsigned int uPopAuthExpireTime = STD_POP3AUTH_EXPIRE_TIME;
  492. long lMaxThreads = MAX_SMTP_THREADS;
  493. unsigned long ulFlags = 0;
  494. SYS_INET_ADDR SvrAddr[MAX_SMTP_ACCEPT_ADDRESSES];
  496. for (int ii = 0; ii < iArgCount; ii++) {
  497. if ((pszArgs[ii][0] != '-') || (pszArgs[ii][1] != 'S'))
  498. continue;
  500. switch (pszArgs[ii][2]) {
  501. case ('p'):
  502. if (++ii < iArgCount)
  503. iPort = atoi(pszArgs[ii]);
  504. break;
  506. case ('t'):
  507. if (++ii < iArgCount)
  508. iSessionTimeout = atoi(pszArgs[ii]);
  509. break;
  511. case ('l'):
  512. ulFlags |= SMTPF_LOG_ENABLED;
  513. break;
  515. case ('I'):
  516. if ((++ii < iArgCount) &&
  517.     (MscGetServerAddress(pszArgs[ii], SvrAddr[iNumAddr]) == 0))
  518. ++iNumAddr;
  519. break;
  521. case ('X'):
  522. if (++ii < iArgCount)
  523. lMaxThreads = atol(pszArgs[ii]);
  524. break;
  526. case ('r'):
  527. if (++ii < iArgCount)
  528. iMaxRcpts = atoi(pszArgs[ii]);
  529. break;
  531. case ('e'):
  532. if (++ii < iArgCount)
  533. uPopAuthExpireTime = (unsigned int) atol(pszArgs[ii]);
  534. break;
  536. }
  537. }
  539. if ((hShbSMTP = ShbCreateBlock(sizeof(SMTPConfig))) == SHB_INVALID_HANDLE)
  540. return (ErrGetErrorCode());
  542. SMTPConfig *pSMTPCfg = (SMTPConfig *) ShbLock(hShbSMTP);
  544. if (pSMTPCfg == NULL) {
  545. ShbCloseBlock(hShbSMTP);
  546. return (ErrGetErrorCode());
  547. }
  549. pSMTPCfg->iPort = iPort;
  550. pSMTPCfg->ulFlags = ulFlags;
  551. pSMTPCfg->lThreadCount = 0;
  552. pSMTPCfg->lMaxThreads = lMaxThreads;
  553. pSMTPCfg->iSessionTimeout = iSessionTimeout;
  554. pSMTPCfg->iTimeout = STD_SERVER_TIMEOUT;
  555. pSMTPCfg->iMaxRcpts = iMaxRcpts;
  556. pSMTPCfg->uPopAuthExpireTime = uPopAuthExpireTime;
  557. pSMTPCfg->iNumAddr = iNumAddr;
  559. for (int nn = 0; nn < iNumAddr; nn++)
  560. pSMTPCfg->SvrAddr[nn] = SvrAddr[nn];
  562. ShbUnlock(hShbSMTP);
  564. if ((hSMTPThread = SysCreateThread(SMTPThreadProc, NULL)) == SYS_INVALID_THREAD) {
  565. ShbCloseBlock(hShbSMTP);
  566. return (ErrGetErrorCode());
  567. }
  569. return (0);
  571. }
  573. static void SvrCleanupSMTP(void)
  574. {
  576. ///////////////////////////////////////////////////////////////////////////////
  577. //  Stop SMTP Thread
  578. ///////////////////////////////////////////////////////////////////////////////
  579. SMTPConfig *pSMTPCfg = (SMTPConfig *) ShbLock(hShbSMTP);
  581. pSMTPCfg->ulFlags |= SMTPF_STOP_SERVER;
  583. ShbUnlock(hShbSMTP);
  585. ///////////////////////////////////////////////////////////////////////////////
  586. //  Wait SMTP Thread
  587. ///////////////////////////////////////////////////////////////////////////////
  588. SysWaitThread(hSMTPThread, SVR_EXIT_WAIT);
  590. ///////////////////////////////////////////////////////////////////////////////
  591. //  Close SMTP Thread
  592. ///////////////////////////////////////////////////////////////////////////////
  593. SysCloseThread(hSMTPThread, 1);
  595. ShbCloseBlock(hShbSMTP);
  597. }
  599. static int SvrSetupSMAIL(int iArgCount, char *pszArgs[])
  600. {
  602. int ii;
  603. int iRetryTimeout = STD_SMAIL_RETRY_TIMEOUT;
  604. int iRetryIncrRatio = STD_SMAIL_RETRY_INCR_RATIO;
  605. int iMaxRetry = STD_SMAIL_MAX_RETRY;
  606. unsigned long ulFlags = 0;
  608. iNumSMAILThreads = STD_SMAIL_THREADS;
  610. for (ii = 0; ii < iArgCount; ii++) {
  611. if ((pszArgs[ii][0] != '-') || (pszArgs[ii][1] != 'Q'))
  612. continue;
  614. switch (pszArgs[ii][2]) {
  615. case ('n'):
  616. if (++ii < iArgCount)
  617. iNumSMAILThreads = atoi(pszArgs[ii]);
  619. iNumSMAILThreads = Min(MAX_SMAIL_THREADS, Max(1, iNumSMAILThreads));
  620. break;
  622. case ('t'):
  623. if (++ii < iArgCount)
  624. iRetryTimeout = atoi(pszArgs[ii]);
  625. break;
  627. case ('i'):
  628. if (++ii < iArgCount)
  629. iRetryIncrRatio = atoi(pszArgs[ii]);
  630. break;
  632. case ('r'):
  633. if (++ii < iArgCount)
  634. iMaxRetry = atoi(pszArgs[ii]);
  635. break;
  637. case ('l'):
  638. ulFlags |= SMAILF_LOG_ENABLED;
  639. break;
  641. case ('T'):
  642. if (++ii < iArgCount)
  643. iFilterTimeout = atoi(pszArgs[ii]);
  644. break;
  646. case ('g'):
  647. bFilterLogEnabled = true;
  648. break;
  649. }
  650. }
  652. if ((hShbSMAIL = ShbCreateBlock(sizeof(SMAILConfig))) == SHB_INVALID_HANDLE)
  653. return (ErrGetErrorCode());
  655. SMAILConfig *pSMAILCfg = (SMAILConfig *) ShbLock(hShbSMAIL);
  657. if (pSMAILCfg == NULL) {
  658. ErrorPush();
  659. ShbCloseBlock(hShbSMAIL);
  661. return (ErrorPop());
  662. }
  664. pSMAILCfg->ulFlags = ulFlags;
  665. pSMAILCfg->lThreadCount = 0;
  667. ShbUnlock(hShbSMAIL);
  669. ///////////////////////////////////////////////////////////////////////////////
  670. //  Initialize queue fs
  671. ///////////////////////////////////////////////////////////////////////////////
  672. char szSpoolDir[SYS_MAX_PATH] = "";
  674. SvrGetSpoolDir(szSpoolDir, sizeof(szSpoolDir));
  676. if ((hSpoolQueue = QueOpen(szSpoolDir, iMaxRetry, iRetryTimeout, iRetryIncrRatio,
  677.    iQueueSplitLevel)) == INVALID_QUEUE_HANDLE) {
  678. ErrorPush();
  679. ShbCloseBlock(hShbSMAIL);
  681. return (ErrorPop());
  682. }
  683. ///////////////////////////////////////////////////////////////////////////////
  684. //  Create mailer threads
  685. ///////////////////////////////////////////////////////////////////////////////
  686. for (ii = 0; ii < iNumSMAILThreads; ii++)
  687. hSMAILThreads[ii] = SysCreateThread(SMAILThreadProc, NULL);
  689. return (0);
  691. }
  693. static void SvrCleanupSMAIL(void)
  694. {
  696. ///////////////////////////////////////////////////////////////////////////////
  697. //  Stop SMAIL Thread ( and unlock threads wait with "SysReleaseSemaphore" )
  698. ///////////////////////////////////////////////////////////////////////////////
  699. SMAILConfig *pSMAILCfg = (SMAILConfig *) ShbLock(hShbSMAIL);
  701. pSMAILCfg->ulFlags |= SMAILF_STOP_SERVER;
  703. ShbUnlock(hShbSMAIL);
  705. ///////////////////////////////////////////////////////////////////////////////
  706. //  Wait SMAIL Threads
  707. ///////////////////////////////////////////////////////////////////////////////
  708. int tt;
  710. for (tt = 0; tt < iNumSMAILThreads; tt++)
  711. SysWaitThread(hSMAILThreads[tt], SVR_EXIT_WAIT);
  713. ///////////////////////////////////////////////////////////////////////////////
  714. //  Close SMAIL Threads
  715. ///////////////////////////////////////////////////////////////////////////////
  716. for (tt = 0; tt < iNumSMAILThreads; tt++)
  717. SysCloseThread(hSMAILThreads[tt], 1);
  719. ShbCloseBlock(hShbSMAIL);
  721. ///////////////////////////////////////////////////////////////////////////////
  722. //  Close the mail queue
  723. ///////////////////////////////////////////////////////////////////////////////
  724. QueClose(hSpoolQueue);
  726. }
  728. static int SvrSetupPSYNC(int iArgCount, char *pszArgs[])
  729. {
  731. int iSyncInterval = STD_PSYNC_INTERVAL;
  732. int iNumSyncThreads = STD_PSYNC_NUM_THREADS;
  733. unsigned long ulFlags = 0;
  735. for (int ii = 0; ii < iArgCount; ii++) {
  736. if ((pszArgs[ii][0] != '-') || (pszArgs[ii][1] != 'Y'))
  737. continue;
  739. switch (pszArgs[ii][2]) {
  740. case ('i'):
  741. if (++ii < iArgCount)
  742. iSyncInterval = atoi(pszArgs[ii]);
  743. break;
  745. case ('t'):
  746. if (++ii < iArgCount)
  747. iNumSyncThreads = atoi(pszArgs[ii]);
  749. iNumSyncThreads = Min(MAX_PSYNC_NUM_THREADS, Max(1, iNumSyncThreads));
  750. break;
  752. case ('l'):
  753. ulFlags |= PSYNCF_LOG_ENABLED;
  754. break;
  755. }
  756. }
  758. if ((hSyncSem =
  759.      SysCreateSemaphore(iNumSyncThreads, SYS_DEFAULT_MAXCOUNT)) == SYS_INVALID_SEMAPHORE)
  760. return (ErrGetErrorCode());
  762. if ((hShbPSYNC = ShbCreateBlock(sizeof(PSYNCConfig))) == SHB_INVALID_HANDLE) {
  763. ErrorPush();
  764. SysCloseSemaphore(hSyncSem);
  765. return (ErrorPop());
  766. }
  768. PSYNCConfig *pPSYNCCfg = (PSYNCConfig *) ShbLock(hShbPSYNC);
  770. if (pPSYNCCfg == NULL) {
  771. ErrorPush();
  772. ShbCloseBlock(hShbPSYNC);
  773. SysCloseSemaphore(hSyncSem);
  774. return (ErrorPop());
  775. }
  777. pPSYNCCfg->ulFlags = ulFlags;
  778. pPSYNCCfg->lThreadCount = 0;
  779. pPSYNCCfg->iTimeout = STD_SERVER_TIMEOUT;
  780. pPSYNCCfg->iSyncInterval = iSyncInterval;
  781. pPSYNCCfg->iNumSyncThreads = iNumSyncThreads;
  783. ShbUnlock(hShbPSYNC);
  785. ///////////////////////////////////////////////////////////////////////////////
  786. //  Remove POP3 links lock files
  787. ///////////////////////////////////////////////////////////////////////////////
  788. GwLkClearLinkLocksDir();
  790. if ((hPSYNCThread = SysCreateThread(PSYNCThreadProc, NULL)) == SYS_INVALID_THREAD) {
  791. ShbCloseBlock(hShbPSYNC);
  792. SysCloseSemaphore(hSyncSem);
  794. return (ErrGetErrorCode());
  795. }
  797. return (0);
  799. }
  801. static void SvrCleanupPSYNC(void)
  802. {
  804. ///////////////////////////////////////////////////////////////////////////////
  805. //  Stop PSYNC Thread
  806. ///////////////////////////////////////////////////////////////////////////////
  807. PSYNCConfig *pPSYNCCfg = (PSYNCConfig *) ShbLock(hShbPSYNC);
  809. pPSYNCCfg->ulFlags |= PSYNCF_STOP_SERVER;
  811. ShbUnlock(hShbPSYNC);
  813. ///////////////////////////////////////////////////////////////////////////////
  814. //  Wait PSYNC Thread
  815. ///////////////////////////////////////////////////////////////////////////////
  816. SysWaitThread(hPSYNCThread, SVR_EXIT_WAIT);
  818. ///////////////////////////////////////////////////////////////////////////////
  819. //  Close PSYNC Thread
  820. ///////////////////////////////////////////////////////////////////////////////
  821. SysCloseThread(hPSYNCThread, 1);
  823. ShbCloseBlock(hShbPSYNC);
  825. SysCloseSemaphore(hSyncSem);
  827. }
  829. static int SvrSetupLMAIL(int iArgCount, char *pszArgs[])
  830. {
  832. int ii;
  833. int iSleepTimeout = STD_LMAILTHREAD_SLEEP_TIME;
  834. unsigned long ulFlags = 0;
  836. iNumLMAILThreads = STD_LMAIL_THREADS;
  838. for (ii = 0; ii < iArgCount; ii++) {
  839. if ((pszArgs[ii][0] != '-') || (pszArgs[ii][1] != 'L'))
  840. continue;
  842. switch (pszArgs[ii][2]) {
  843. case ('n'):
  844. if (++ii < iArgCount)
  845. iNumLMAILThreads = atoi(pszArgs[ii]);
  847. iNumLMAILThreads = Min(MAX_LMAIL_THREADS, Max(1, iNumLMAILThreads));
  848. break;
  850. case ('l'):
  851. ulFlags |= LMAILF_LOG_ENABLED;
  852. break;
  854. case ('t'):
  855. if (++ii < iArgCount)
  856. iSleepTimeout = atoi(pszArgs[ii]);
  857. break;
  858. }
  859. }
  861. if ((hShbLMAIL = ShbCreateBlock(sizeof(LMAILConfig))) == SHB_INVALID_HANDLE)
  862. return (ErrGetErrorCode());
  864. LMAILConfig *pLMAILCfg = (LMAILConfig *) ShbLock(hShbLMAIL);
  866. if (pLMAILCfg == NULL) {
  867. ErrorPush();
  868. ShbCloseBlock(hShbLMAIL);
  870. return (ErrorPop());
  871. }
  873. pLMAILCfg->ulFlags = ulFlags;
  874. pLMAILCfg->iSleepTimeout = iSleepTimeout;
  875. pLMAILCfg->lNumThreads = iNumLMAILThreads;
  876. pLMAILCfg->lThreadCount = 0;
  878. ShbUnlock(hShbLMAIL);
  880. ///////////////////////////////////////////////////////////////////////////////
  881. //  Create mailer threads
  882. ///////////////////////////////////////////////////////////////////////////////
  883. for (ii = 0; ii < iNumLMAILThreads; ii++)
  884. hLMAILThreads[ii] = SysCreateThread(LMAILThreadProc, NULL);
  886. return (0);
  888. }
  890. static void SvrCleanupLMAIL(void)
  891. {
  893. ///////////////////////////////////////////////////////////////////////////////
  894. //  Stop LMAIL Thread ( and unlock threads wait with "SysReleaseSemaphore" )
  895. ///////////////////////////////////////////////////////////////////////////////
  896. LMAILConfig *pLMAILCfg = (LMAILConfig *) ShbLock(hShbLMAIL);
  898. pLMAILCfg->ulFlags |= LMAILF_STOP_SERVER;
  900. ShbUnlock(hShbLMAIL);
  902. ///////////////////////////////////////////////////////////////////////////////
  903. //  Wait LMAIL Threads
  904. ///////////////////////////////////////////////////////////////////////////////
  905. int tt;
  907. for (tt = 0; tt < iNumLMAILThreads; tt++)
  908. SysWaitThread(hLMAILThreads[tt], SVR_EXIT_WAIT);
  910. ///////////////////////////////////////////////////////////////////////////////
  911. //  Close LMAIL Threads
  912. ///////////////////////////////////////////////////////////////////////////////
  913. for (tt = 0; tt < iNumLMAILThreads; tt++)
  914. SysCloseThread(hLMAILThreads[tt], 1);
  916. ShbCloseBlock(hShbLMAIL);
  918. }
  920. static int SvrSetup(int iArgCount, char *pszArgs[])
  921. {
  923. StrSNCpy(szMailPath, SYS_BASE_FS_STR);
  925. char *pszValue = SysGetEnv(ENV_MAIN_PATH);
  927. if (pszValue != NULL) {
  928. if (strncmp(szMailPath, pszValue, strlen(szMailPath)) == 0)
  929. StrSNCpy(szMailPath, pszValue);
  930. else
  931. StrSNCat(szMailPath, pszValue);
  932. DelFinalSlash(szMailPath);
  934. SysFree(pszValue);
  935. }
  937. bServerDebug = false;
  939. int iSndBufSize = -1;
  940. int iRcvBufSize = -1;
  941. int iDnsCacheDirs = DNS_HASH_NUM_DIRS;
  943. for (int ii = 0; ii < iArgCount; ii++) {
  944. if ((pszArgs[ii][0] != '-') || (pszArgs[ii][1] != 'M'))
  945. continue;
  947. switch (pszArgs[ii][2]) {
  948. case ('s'):
  949. if (++ii < iArgCount) {
  950. StrSNCpy(szMailPath, pszArgs[ii]);
  951. DelFinalSlash(szMailPath);
  952. }
  953. break;
  955. case ('d'):
  956. bServerDebug = true;
  957. break;
  959. case ('r'):
  960. if (++ii < iArgCount)
  961. iLogRotateHours = atoi(pszArgs[ii]);
  962. break;
  964. case ('x'):
  965. if (++ii < iArgCount) {
  966. iQueueSplitLevel = atoi(pszArgs[ii]);
  968. while (!IsPrimeNumber(iQueueSplitLevel))
  969. ++iQueueSplitLevel;
  970. }
  971. break;
  973. case ('R'):
  974. if (++ii < iArgCount) {
  975. iRcvBufSize = atoi(pszArgs[ii]);
  976. iRcvBufSize = NbrCeil(iRcvBufSize, 1024);
  977. }
  978. break;
  980. case ('S'):
  981. if (++ii < iArgCount) {
  982. iSndBufSize = atoi(pszArgs[ii]);
  983. iSndBufSize = NbrCeil(iSndBufSize, 1024);
  984. }
  985. break;
  987. case ('M'):
  988. iMailboxType = XMAIL_MAILDIR;
  989. break;
  991. case ('m'):
  992. iMailboxType = XMAIL_MAILBOX;
  993. break;
  995. case ('D'):
  996. if (++ii < iArgCount)
  997. iDnsCacheDirs = atoi(pszArgs[ii]);
  998. break;
  999. }
  1000. }
  1002. if ((strlen(szMailPath) == 0) || !SysExistDir(szMailPath)) {
  1003. ErrSetErrorCode(ERR_CONF_PATH);
  1004. return (ERR_CONF_PATH);
  1005. }
  1007. AppendSlash(szMailPath);
  1009. ///////////////////////////////////////////////////////////////////////////////
  1010. //  Setup library socket buffers
  1011. ///////////////////////////////////////////////////////////////////////////////
  1012. SysSetupSocketBuffers((iSndBufSize > 0) ? &iSndBufSize : NULL,
  1013.       (iRcvBufSize > 0) ? &iRcvBufSize : NULL);
  1015. ///////////////////////////////////////////////////////////////////////////////
  1016. //  Setup shutdown file name ( must be called before any shutdown function )
  1017. ///////////////////////////////////////////////////////////////////////////////
  1018. sprintf(szShutdownFile, "%s%s", szMailPath, SVR_SHUTDOWN_FILE);
  1020. ///////////////////////////////////////////////////////////////////////////////
  1021. //  Setup resource lockers
  1022. ///////////////////////////////////////////////////////////////////////////////
  1023. if (RLckInitLockers() < 0)
  1024. return (ErrGetErrorCode());
  1026. ///////////////////////////////////////////////////////////////////////////////
  1027. //  Check dynamic DNS setup
  1028. ///////////////////////////////////////////////////////////////////////////////
  1029. if (DynDnsSetup() < 0) {
  1030. ErrorPush();
  1031. RLckCleanupLockers();
  1033. return (ErrorPop());
  1034. }
  1035. ///////////////////////////////////////////////////////////////////////////////
  1036. //  Clear shutdown condition
  1037. ///////////////////////////////////////////////////////////////////////////////
  1038. SvrShutdownCleanup();
  1040. ///////////////////////////////////////////////////////////////////////////////
  1041. //  Align table indexes
  1042. ///////////////////////////////////////////////////////////////////////////////
  1043. if ((UsrCheckUsersIndexes() < 0) ||
  1044.     (UsrCheckAliasesIndexes() < 0) ||
  1045.     (ExAlCheckAliasIndexes() < 0) ||
  1046.     (MDomCheckDomainsIndexes() < 0) || (ADomCheckDomainsIndexes() < 0)) {
  1047. ErrorPush();
  1048. RLckCleanupLockers();
  1050. return (ErrorPop());
  1051. }
  1052. ///////////////////////////////////////////////////////////////////////////////
  1053. //  Initialize DNS cache
  1054. ///////////////////////////////////////////////////////////////////////////////
  1055. if (CDNS_Initialize(iDnsCacheDirs) < 0) {
  1056. ErrorPush();
  1057. RLckCleanupLockers();
  1059. return (ErrorPop());
  1060. }
  1062. return (0);
  1064. }
  1066. static void SvrCleanup(void)
  1067. {
  1068. ///////////////////////////////////////////////////////////////////////////////
  1069. //  Cleanup resource lockers
  1070. ///////////////////////////////////////////////////////////////////////////////
  1071. RLckCleanupLockers();
  1073. ///////////////////////////////////////////////////////////////////////////////
  1074. //  Clear shutdown condition
  1075. ///////////////////////////////////////////////////////////////////////////////
  1076. SvrShutdownCleanup();
  1078. }
  1080. static void SvrBreakHandler(void)
  1081. {
  1083. ///////////////////////////////////////////////////////////////////////////////
  1084. //  Set shutdown condition
  1085. ///////////////////////////////////////////////////////////////////////////////
  1086. SvrSetShutdown();
  1088. }
  1090. static char **SvrMergeArgs(int iArgs, char *pszArgs[], int &iArgsCount)
  1091. {
  1093. int iCmdArgs = 0;
  1094. char **ppszCmdArgs = NULL;
  1095. char *pszCmdLine = SysGetEnv(ENV_CMD_LINE);
  1097. if (pszCmdLine != NULL) {
  1098. ppszCmdArgs = StrGetArgs(pszCmdLine, iCmdArgs);
  1100. SysFree(pszCmdLine);
  1101. }
  1103. char **ppszMergeArgs = (char **) SysAlloc((iCmdArgs + iArgs + 1) * sizeof(char *));
  1105. if (ppszMergeArgs == NULL) {
  1106. if (ppszCmdArgs != NULL)
  1107. StrFreeStrings(ppszCmdArgs);
  1109. return (NULL);
  1110. }
  1112. iArgsCount = 0;
  1114. for (int ii = 0; ii < iArgs; ii++, iArgsCount++)
  1115. ppszMergeArgs[iArgsCount] = SysStrDup(pszArgs[ii]);
  1117. for (int jj = 0; jj < iCmdArgs; jj++, iArgsCount++)
  1118. ppszMergeArgs[iArgsCount] = SysStrDup(ppszCmdArgs[jj]);
  1120. ppszMergeArgs[iArgsCount] = NULL;
  1122. if (ppszCmdArgs != NULL)
  1123. StrFreeStrings(ppszCmdArgs);
  1125. return (ppszMergeArgs);
  1127. }
  1129. int SvrMain(int iArgCount, char *pszArgs[])
  1130. {
  1132. if (SysInitLibrary() < 0) {
  1133. ErrorPush();
  1134. SysEventLog(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  1135. return (ErrorPop());
  1136. }
  1138. int iMergeArgsCount = 0;
  1139. char **ppszMergeArgs = SvrMergeArgs(iArgCount, pszArgs, iMergeArgsCount);
  1141. if (ppszMergeArgs == NULL) {
  1142. ErrorPush();
  1143. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  1144. SysCleanupLibrary();
  1145. return (ErrorPop());
  1146. }
  1148. if (SvrSetup(iMergeArgsCount, ppszMergeArgs) < 0) {
  1149. ErrorPush();
  1150. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  1151. StrFreeStrings(ppszMergeArgs);
  1152. SysCleanupLibrary();
  1153. return (ErrorPop());
  1154. }
  1156. if (SvrSetupSMAIL(iMergeArgsCount, ppszMergeArgs) < 0) {
  1157. ErrorPush();
  1158. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  1159. StrFreeStrings(ppszMergeArgs);
  1160. SvrCleanup();
  1161. SysCleanupLibrary();
  1162. return (ErrorPop());
  1163. }
  1165. if (SvrSetupCTRL(iMergeArgsCount, ppszMergeArgs) < 0) {
  1166. ErrorPush();
  1167. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  1168. SvrCleanupSMAIL();
  1169. StrFreeStrings(ppszMergeArgs);
  1170. SvrCleanup();
  1171. SysCleanupLibrary();
  1172. return (ErrorPop());
  1173. }
  1175. if (SvrSetupPOP3(iMergeArgsCount, ppszMergeArgs) < 0) {
  1176. ErrorPush();
  1177. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  1178. SvrCleanupCTRL();
  1179. SvrCleanupSMAIL();
  1180. StrFreeStrings(ppszMergeArgs);
  1181. SvrCleanup();
  1182. SysCleanupLibrary();
  1183. return (ErrorPop());
  1184. }
  1186. if (SvrSetupSMTP(iMergeArgsCount, ppszMergeArgs) < 0) {
  1187. ErrorPush();
  1188. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  1189. SvrCleanupPOP3();
  1190. SvrCleanupCTRL();
  1191. SvrCleanupSMAIL();
  1192. StrFreeStrings(ppszMergeArgs);
  1193. SvrCleanup();
  1194. SysCleanupLibrary();
  1195. return (ErrorPop());
  1196. }
  1198. if (SvrSetupPSYNC(iMergeArgsCount, ppszMergeArgs) < 0) {
  1199. ErrorPush();
  1200. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  1201. SvrCleanupSMTP();
  1202. SvrCleanupPOP3();
  1203. SvrCleanupCTRL();
  1204. SvrCleanupSMAIL();
  1205. StrFreeStrings(ppszMergeArgs);
  1206. SvrCleanup();
  1207. SysCleanupLibrary();
  1208. return (ErrorPop());
  1209. }
  1211. if (SvrSetupFING(iMergeArgsCount, ppszMergeArgs) < 0) {
  1212. ErrorPush();
  1213. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  1214. SvrCleanupPSYNC();
  1215. SvrCleanupSMTP();
  1216. SvrCleanupPOP3();
  1217. SvrCleanupCTRL();
  1218. SvrCleanupSMAIL();
  1219. StrFreeStrings(ppszMergeArgs);
  1220. SvrCleanup();
  1221. SysCleanupLibrary();
  1222. return (ErrorPop());
  1223. }
  1225. if (SvrSetupLMAIL(iMergeArgsCount, ppszMergeArgs) < 0) {
  1226. ErrorPush();
  1227. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  1228. SvrCleanupFING();
  1229. SvrCleanupPSYNC();
  1230. SvrCleanupSMTP();
  1231. SvrCleanupPOP3();
  1232. SvrCleanupCTRL();
  1233. SvrCleanupSMAIL();
  1234. StrFreeStrings(ppszMergeArgs);
  1235. SvrCleanup();
  1236. SysCleanupLibrary();
  1237. return (ErrorPop());
  1238. }
  1240. StrFreeStrings(ppszMergeArgs);
  1242. ///////////////////////////////////////////////////////////////////////////////
  1243. //  Set stop handler
  1244. ///////////////////////////////////////////////////////////////////////////////
  1245. SysSetBreakHandler(SvrBreakHandler);
  1247. ///////////////////////////////////////////////////////////////////////////////
  1248. //  Server main loop
  1249. ///////////////////////////////////////////////////////////////////////////////
  1250. for (; !SvrInShutdown(true);) {
  1251. SysSleep(SERVER_SLEEP_TIMESLICE);
  1253. }
  1255. ///////////////////////////////////////////////////////////////////////////////
  1256. //  Goodbye cleanups
  1257. ///////////////////////////////////////////////////////////////////////////////
  1258. SvrCleanupLMAIL();
  1259. SvrCleanupFING();
  1260. SvrCleanupPSYNC();
  1261. SvrCleanupSMTP();
  1262. SvrCleanupPOP3();
  1263. SvrCleanupCTRL();
  1264. SvrCleanupSMAIL();
  1266. SvrCleanup();
  1268. SysLogMessage(LOG_LEV_MESSAGE, APP_NAME_VERSION_STR " server stoppedn");
  1270. SysCleanupLibrary();
  1272. return (0);
  1274. }
  1276. int SvrStopServer(bool bWait)
  1277. {
  1279. ///////////////////////////////////////////////////////////////////////////////
  1280. //  Set shutdown condition
  1281. ///////////////////////////////////////////////////////////////////////////////
  1282. SvrSetShutdown();
  1284. if (bWait) {
  1285. int iWaitTime = 0;
  1287. for (; SvrInShutdown(true); iWaitTime += SERVER_SLEEP_TIMESLICE)
  1288. SysSleep(SERVER_SLEEP_TIMESLICE);
  1289. }
  1291. return (0);
  1293. }
  1295. bool SvrInShutdown(bool bForceCheck)
  1296. {
  1298. time_t tNow = time(NULL);
  1299. static time_t tLastCheck = 0;
  1300. static bool bShutdown = false;
  1302. if (bForceCheck || (tNow > (tLastCheck + SHUTDOWN_CHECK_TIME))) {
  1303. tLastCheck = tNow;
  1305. if (bServerShutdown)
  1306. bShutdown = true;
  1307. else if (SysExistFile(szShutdownFile)) {
  1308. bServerShutdown = true;
  1310. SysShutdownLibrary();
  1312. bShutdown = true;
  1313. }
  1314. }
  1316. return (bShutdown);
  1318. }