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

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

Email服务器

开发平台：

Visual C++

PSYNCSvr.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 "ShBlocks.h"
  27. #include "SList.h"
  28. #include "BuffSock.h"
  29. #include "ResLocks.h"
  30. #include "MiscUtils.h"
  31. #include "MailConfig.h"
  32. #include "SvrUtils.h"
  33. #include "UsrUtils.h"
  34. #include "POP3Svr.h"
  35. #include "POP3Utils.h"
  36. #include "MessQueue.h"
  37. #include "AppDefines.h"
  38. #include "MailSvr.h"
  39. #include "POP3GwLink.h"
  40. #include "PSYNCSvr.h"
  42. #define PSYNC_LOG_FILE              "psync"
  43. #define PSYNC_TRIGGER_FILE          ".psync-trigger"
  44. #define PSYNC_WAIT_SLEEP            2
  45. #define MAX_CLIENTS_WAIT            300
  46. #define PSYNC_WAKEUP_TIME           2
  47. #define PSYNC_SERVER_NAME           "[" APP_NAME_VERSION_STR " PSYNC Server]"
  49. struct PSYNCThreadData {
  50. PSYNCConfig *pPSYNCCfg;
  51. POP3Link *pPopLnk;
  52. };
  54. static bool PSYNCNeedSync(void);
  55. static PSYNCConfig *PSYNCGetConfigCopy(SHB_HANDLE hShbPSYNC);
  56. static int PSYNCThreadCountAdd(long lCount, SHB_HANDLE hShbPSYNC, PSYNCConfig * pPSYNCCfg = NULL);
  57. static int PSYNCTimeToStop(SHB_HANDLE hShbPSYNC);
  58. static SYS_THREAD PSYNCCreateSyncThread(SHB_HANDLE hShbPSYNC, POP3Link * pPopLnk);
  59. static int PSYNCStartTransfer(SHB_HANDLE hShbPSYNC, PSYNCConfig * pPSYNCCfg);
  60. unsigned int PSYNCThreadSyncProc(void *pThreadData);
  61. static int PSYNCThreadNotifyExit(void);
  62. static int PSYNCLogEnabled(PSYNCConfig * pPSYNCCfg);
  63. static int PSYNCLogSession(POP3Link const *pPopLnk, PopSyncReport const *pSRep,
  64.    char const *pszStatus);
  66. static bool PSYNCNeedSync(void)
  67. {
  69. char szTriggerPath[SYS_MAX_PATH] = "";
  71. CfgGetRootPath(szTriggerPath, sizeof(szTriggerPath));
  73. StrNCat(szTriggerPath, PSYNC_TRIGGER_FILE, sizeof(szTriggerPath));
  75. ///////////////////////////////////////////////////////////////////////////////
  76. //  Check for the presence of the trigger file
  77. ///////////////////////////////////////////////////////////////////////////////
  78. if (!SysExistFile(szTriggerPath))
  79. return (false);
  81. SysRemove(szTriggerPath);
  83. return (true);
  85. }
  87. static PSYNCConfig *PSYNCGetConfigCopy(SHB_HANDLE hShbPSYNC)
  88. {
  90. PSYNCConfig *pPSYNCCfg = (PSYNCConfig *) ShbLock(hShbPSYNC);
  92. if (pPSYNCCfg == NULL)
  93. return (NULL);
  95. PSYNCConfig *pNewPSYNCCfg = (PSYNCConfig *) SysAlloc(sizeof(PSYNCConfig));
  97. if (pNewPSYNCCfg != NULL)
  98. memcpy(pNewPSYNCCfg, pPSYNCCfg, sizeof(PSYNCConfig));
  100. ShbUnlock(hShbPSYNC);
  102. return (pNewPSYNCCfg);
  104. }
  106. static int PSYNCThreadCountAdd(long lCount, SHB_HANDLE hShbPSYNC, PSYNCConfig * pPSYNCCfg)
  107. {
  109. int iDoUnlock = 0;
  111. if (pPSYNCCfg == NULL) {
  112. if ((pPSYNCCfg = (PSYNCConfig *) ShbLock(hShbPSYNC)) == NULL)
  113. return (ErrGetErrorCode());
  115. ++iDoUnlock;
  116. }
  118. pPSYNCCfg->lThreadCount += lCount;
  120. if (iDoUnlock)
  121. ShbUnlock(hShbPSYNC);
  123. return (0);
  125. }
  127. static int PSYNCTimeToStop(SHB_HANDLE hShbPSYNC)
  128. {
  130. PSYNCConfig *pPSYNCCfg = (PSYNCConfig *) ShbLock(hShbPSYNC);
  132. if (pPSYNCCfg == NULL)
  133. return (1);
  135. int iTimeToStop = (pPSYNCCfg->ulFlags & PSYNCF_STOP_SERVER) ? 1 : 0;
  137. ShbUnlock(hShbPSYNC);
  139. return (iTimeToStop);
  141. }
  143. unsigned int PSYNCThreadProc(void *pThreadData)
  144. {
  146. SysLogMessage(LOG_LEV_MESSAGE, "%s startedn", PSYNC_SERVER_NAME);
  148. int iElapsedTime = 0;
  150. for (;;) {
  151. SysSleep(PSYNC_WAKEUP_TIME);
  153. iElapsedTime += PSYNC_WAKEUP_TIME;
  155. PSYNCConfig *pPSYNCCfg = PSYNCGetConfigCopy(hShbPSYNC);
  157. if (pPSYNCCfg == NULL)
  158. break;
  160. if (pPSYNCCfg->ulFlags & PSYNCF_STOP_SERVER) {
  161. SysFree(pPSYNCCfg);
  162. break;
  163. }
  165. if (((pPSYNCCfg->iSyncInterval == 0) || (iElapsedTime < pPSYNCCfg->iSyncInterval))
  166.     && !PSYNCNeedSync()) {
  167. SysFree(pPSYNCCfg);
  168. continue;
  169. }
  171. iElapsedTime = 0;
  173. PSYNCStartTransfer(hShbPSYNC, pPSYNCCfg);
  175. SysFree(pPSYNCCfg);
  176. }
  178. ///////////////////////////////////////////////////////////////////////////////
  179. //  Wait for client completion
  180. ///////////////////////////////////////////////////////////////////////////////
  181. for (int iTotalWait = 0; (iTotalWait < MAX_CLIENTS_WAIT); iTotalWait += PSYNC_WAIT_SLEEP) {
  182. PSYNCConfig *pPSYNCCfg = (PSYNCConfig *) ShbLock(hShbPSYNC);
  184. if (pPSYNCCfg == NULL)
  185. break;
  187. long lThreadCount = pPSYNCCfg->lThreadCount;
  189. ShbUnlock(hShbPSYNC);
  191. if (lThreadCount == 0)
  192. break;
  194. SysSleep(PSYNC_WAIT_SLEEP);
  195. }
  197. SysLogMessage(LOG_LEV_MESSAGE, "%s stoppedn", PSYNC_SERVER_NAME);
  199. return (0);
  201. }
  203. static SYS_THREAD PSYNCCreateSyncThread(SHB_HANDLE hShbPSYNC, POP3Link * pPopLnk)
  204. {
  206. PSYNCThreadData *pSTD = (PSYNCThreadData *) SysAlloc(sizeof(PSYNCThreadData));
  208. if (pSTD == NULL)
  209. return (SYS_INVALID_THREAD);
  211. if ((pSTD->pPSYNCCfg = PSYNCGetConfigCopy(hShbPSYNC)) == NULL) {
  212. SysFree(pSTD);
  213. return (SYS_INVALID_THREAD);
  214. }
  216. pSTD->pPopLnk = pPopLnk;
  218. SYS_THREAD hThread = SysCreateThread(PSYNCThreadSyncProc, pSTD);
  220. if (hThread == SYS_INVALID_THREAD) {
  221. SysFree(pSTD->pPSYNCCfg);
  222. SysFree(pSTD);
  223. return (SYS_INVALID_THREAD);
  224. }
  226. return (hThread);
  228. }
  230. static int PSYNCStartTransfer(SHB_HANDLE hShbPSYNC, PSYNCConfig * pPSYNCCfg)
  231. {
  233. GWLKF_HANDLE hLinksDB = GwLkOpenDB();
  235. if (hLinksDB == INVALID_GWLKF_HANDLE) {
  236. ErrorPush();
  237. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString(ErrorFetch()));
  238. return (ErrorPop());
  239. }
  241. POP3Link *pPopLnk = GwLkGetFirstUser(hLinksDB);
  243. for (; pPopLnk != NULL; pPopLnk = GwLkGetNextUser(hLinksDB)) {
  244. ///////////////////////////////////////////////////////////////////////////////
  245. //  Check if link is enabled
  246. ///////////////////////////////////////////////////////////////////////////////
  247. if (GwLkCheckEnabled(pPopLnk) < 0) {
  248. GwLkFreePOP3Link(pPopLnk);
  249. continue;
  250. }
  252. if ((SysWaitSemaphore(hSyncSem, SYS_INFINITE_TIMEOUT) < 0) ||
  253.     PSYNCTimeToStop(hShbPSYNC)) {
  254. GwLkFreePOP3Link(pPopLnk);
  255. break;
  256. }
  258. SYS_THREAD hClientThread = PSYNCCreateSyncThread(hShbPSYNC, pPopLnk);
  260. if (hClientThread == SYS_INVALID_THREAD) {
  261. ErrorPush();
  262. GwLkFreePOP3Link(pPopLnk);
  263. SysReleaseSemaphore(hSyncSem, 1);
  264. GwLkCloseDB(hLinksDB);
  265. return (ErrorPop());
  266. }
  268. SysCloseThread(hClientThread, 0);
  269. }
  271. GwLkCloseDB(hLinksDB);
  273. return (0);
  275. }
  277. static int PSYNCThreadNotifyExit(void)
  278. {
  280. SysReleaseSemaphore(hSyncSem, 1);
  282. return (0);
  284. }
  286. unsigned int PSYNCThreadSyncProc(void *pThreadData)
  287. {
  289. PSYNCThreadData *pSTD = (PSYNCThreadData *) pThreadData;
  290. POP3Link *pPopLnk = pSTD->pPopLnk;
  291. PSYNCConfig *pPSYNCCfg = pSTD->pPSYNCCfg;
  293. SysFree(pSTD);
  295. SysLogMessage(LOG_LEV_MESSAGE, "[PSYNC] entryn");
  297. ///////////////////////////////////////////////////////////////////////////////
  298. //  Get configuration handle
  299. ///////////////////////////////////////////////////////////////////////////////
  300. SVRCFG_HANDLE hSvrConfig = SvrGetConfigHandle();
  302. if (hSvrConfig == INVALID_SVRCFG_HANDLE) {
  303. ErrorPush();
  304. SysLogMessage(LOG_LEV_MESSAGE, "%sn", ErrGetErrorString(ErrorFetch()));
  306. GwLkFreePOP3Link(pPopLnk);
  307. SysFree(pPSYNCCfg);
  308. ///////////////////////////////////////////////////////////////////////////////
  309. //  Notify thread exit semaphore
  310. ///////////////////////////////////////////////////////////////////////////////
  311. PSYNCThreadNotifyExit();
  312. return (ErrorPop());
  313. }
  314. ///////////////////////////////////////////////////////////////////////////////
  315. //  Get the error account for email that the server is not able to deliver coz
  316. //  it does not find information about where it has to deliver
  317. ///////////////////////////////////////////////////////////////////////////////
  318. char szErrorAccount[MAX_ADDR_NAME] = "";
  320. SvrConfigVar("Pop3SyncErrorAccount", szErrorAccount, sizeof(szErrorAccount) - 1,
  321.      hSvrConfig, "");
  323. char const *pszErrorAccount = (IsEmptyString(szErrorAccount)) ? NULL : szErrorAccount;
  325. ///////////////////////////////////////////////////////////////////////////////
  326. //  Get headers tags that must be checked to extract recipients
  327. ///////////////////////////////////////////////////////////////////////////////
  328. char szFetchHdrTags[256] = "";
  330. SvrConfigVar("FetchHdrTags", szFetchHdrTags, sizeof(szFetchHdrTags) - 1,
  331.      hSvrConfig, "+X-Deliver-To,+Received,To,Cc");
  333. ///////////////////////////////////////////////////////////////////////////////
  334. //  Lock the link
  335. ///////////////////////////////////////////////////////////////////////////////
  336. if (GwLkLinkLock(pPopLnk) < 0) {
  337. ErrorPush();
  338. SysLogMessage(LOG_LEV_MESSAGE, "%sn", ErrGetErrorString(ErrorFetch()));
  340. SvrReleaseConfigHandle(hSvrConfig);
  341. GwLkFreePOP3Link(pPopLnk);
  342. SysFree(pPSYNCCfg);
  343. ///////////////////////////////////////////////////////////////////////////////
  344. //  Notify thread exit semaphore
  345. ///////////////////////////////////////////////////////////////////////////////
  346. PSYNCThreadNotifyExit();
  347. return (ErrorPop());
  348. }
  349. ///////////////////////////////////////////////////////////////////////////////
  350. //  Increase threads count
  351. ///////////////////////////////////////////////////////////////////////////////
  352. PSYNCThreadCountAdd(+1, hShbPSYNC);
  354. ///////////////////////////////////////////////////////////////////////////////
  355. //  Sync for real internal account ?
  356. ///////////////////////////////////////////////////////////////////////////////
  357. PopSyncReport SRep;
  359. if (GwLkLocalDomain(pPopLnk)) {
  360. ///////////////////////////////////////////////////////////////////////////////
  361. //  Verify user credentials
  362. ///////////////////////////////////////////////////////////////////////////////
  363. UserInfo *pUI = UsrGetUserByName(pPopLnk->pszDomain, pPopLnk->pszName);
  365. if (pUI != NULL) {
  366. SysLogMessage(LOG_LEV_MESSAGE,
  367.       "[PSYNC] User = "%s" - Domain = "%s"n",
  368.       pPopLnk->pszName, pPopLnk->pszDomain);
  370. ///////////////////////////////////////////////////////////////////////////////
  371. //  Sync
  372. ///////////////////////////////////////////////////////////////////////////////
  373. char szUserAddress[MAX_ADDR_NAME] = "";
  375. UsrGetAddress(pUI, szUserAddress);
  377. if (UPopSyncRemoteLink
  378.     (szUserAddress, pPopLnk->pszRmtDomain, pPopLnk->pszRmtName,
  379.      pPopLnk->pszRmtPassword, &SRep, szFetchHdrTags, pPopLnk->pszAuthType,
  380.      pszErrorAccount) < 0) {
  381. ErrLogMessage(LOG_LEV_MESSAGE,
  382.       "[PSYNC] User = "%s" - Domain = "%s" Failed !n",
  383.       pPopLnk->pszName, pPopLnk->pszDomain);
  385. ZeroData(SRep);
  386. if (PSYNCLogEnabled(pPSYNCCfg))
  387. PSYNCLogSession(pPopLnk, &SRep, "SYNC=EFAIL");
  388. } else {
  389. if (PSYNCLogEnabled(pPSYNCCfg))
  390. PSYNCLogSession(pPopLnk, &SRep, "SYNC=OK");
  391. }
  393. UsrFreeUserInfo(pUI);
  394. } else {
  395. SysLogMessage(LOG_LEV_MESSAGE,
  396.       "[PSYNC] User = "%s" - Domain = "%s" Failed !n"
  397.       "Error = %sn", pPopLnk->pszName, pPopLnk->pszDomain,
  398.       ErrGetErrorString());
  400. ZeroData(SRep);
  401. if (PSYNCLogEnabled(pPSYNCCfg))
  402. PSYNCLogSession(pPopLnk, &SRep, "SYNC=ENOUSER");
  403. }
  404. } else if (GwLkMasqueradeDomain(pPopLnk)) {
  405. SysLogMessage(LOG_LEV_MESSAGE,
  406.       "[PSYNC/MASQ] MasqDomain = "%s" - RmtDomain = "%s" - RmtName = "%s"n",
  407.       pPopLnk->pszDomain + 1, pPopLnk->pszRmtDomain, pPopLnk->pszRmtName);
  409. ///////////////////////////////////////////////////////////////////////////////
  410. //  Sync ( "pszDomain" == "?" + masq-domain or "pszDomain" == "&" + add-domain )
  411. ///////////////////////////////////////////////////////////////////////////////
  412. if (UPopSyncRemoteLink
  413.     (pPopLnk->pszDomain, pPopLnk->pszRmtDomain, pPopLnk->pszRmtName,
  414.      pPopLnk->pszRmtPassword, &SRep, szFetchHdrTags, pPopLnk->pszAuthType,
  415.      pszErrorAccount) < 0) {
  416. ErrLogMessage(LOG_LEV_MESSAGE,
  417.       "[PSYNC/MASQ] MasqDomain = "%s" - RmtDomain = "%s" - RmtName = "%s" Failed !n",
  418.       pPopLnk->pszDomain + 1, pPopLnk->pszRmtDomain,
  419.       pPopLnk->pszRmtName);
  421. ZeroData(SRep);
  422. if (PSYNCLogEnabled(pPSYNCCfg))
  423. PSYNCLogSession(pPopLnk, &SRep, "SYNC=EFAIL");
  424. } else {
  425. if (PSYNCLogEnabled(pPSYNCCfg))
  426. PSYNCLogSession(pPopLnk, &SRep, "SYNC=OK");
  427. }
  428. } else {
  429. char szSyncAddress[MAX_ADDR_NAME] = "";
  431. SysSNPrintf(szSyncAddress, sizeof(szSyncAddress) - 1, "%s%s", pPopLnk->pszName,
  432.     pPopLnk->pszDomain);
  434. SysLogMessage(LOG_LEV_MESSAGE,
  435.       "[PSYNC/EXT] Acount = "%s" - RmtDomain = "%s" - RmtName = "%s"n",
  436.       szSyncAddress, pPopLnk->pszRmtDomain, pPopLnk->pszRmtName);
  438. ///////////////////////////////////////////////////////////////////////////////
  439. //  Sync ( "pszDomain" == "@" + domain )
  440. ///////////////////////////////////////////////////////////////////////////////
  441. if (UPopSyncRemoteLink(szSyncAddress, pPopLnk->pszRmtDomain, pPopLnk->pszRmtName,
  442.        pPopLnk->pszRmtPassword, &SRep, szFetchHdrTags,
  443.        pPopLnk->pszAuthType, pszErrorAccount) < 0) {
  444. ErrLogMessage(LOG_LEV_MESSAGE,
  445.       "[PSYNC/EXT] Acount = "%s" - RmtDomain = "%s" - RmtName = "%s" Failed !n",
  446.       szSyncAddress, pPopLnk->pszRmtDomain, pPopLnk->pszRmtName);
  448. ZeroData(SRep);
  449. if (PSYNCLogEnabled(pPSYNCCfg))
  450. PSYNCLogSession(pPopLnk, &SRep, "SYNC=EFAIL");
  451. } else {
  452. if (PSYNCLogEnabled(pPSYNCCfg))
  453. PSYNCLogSession(pPopLnk, &SRep, "SYNC=OK");
  454. }
  455. }
  457. ///////////////////////////////////////////////////////////////////////////////
  458. //  Decrease threads count
  459. ///////////////////////////////////////////////////////////////////////////////
  460. PSYNCThreadCountAdd(-1, hShbPSYNC);
  462. GwLkLinkUnlock(pPopLnk);
  463. SvrReleaseConfigHandle(hSvrConfig);
  464. GwLkFreePOP3Link(pPopLnk);
  465. SysFree(pPSYNCCfg);
  467. ///////////////////////////////////////////////////////////////////////////////
  468. //  Notify thread exit semaphore
  469. ///////////////////////////////////////////////////////////////////////////////
  470. PSYNCThreadNotifyExit();
  472. SysLogMessage(LOG_LEV_MESSAGE, "[PSYNC] exitn");
  474. return (0);
  476. }
  478. static int PSYNCLogEnabled(PSYNCConfig * pPSYNCCfg)
  479. {
  481. return ((pPSYNCCfg->ulFlags & PSYNCF_LOG_ENABLED) ? 1 : 0);
  483. }
  485. static int PSYNCLogSession(POP3Link const *pPopLnk, PopSyncReport const *pSRep,
  486.    char const *pszStatus)
  487. {
  489. char szTime[256] = "";
  491. MscGetTimeNbrString(szTime, sizeof(szTime) - 1);
  493. RLCK_HANDLE hResLock = RLckLockEX(SVR_LOGS_DIR SYS_SLASH_STR PSYNC_LOG_FILE);
  495. if (hResLock == INVALID_RLCK_HANDLE)
  496. return (ErrGetErrorCode());
  498. MscFileLog(PSYNC_LOG_FILE,
  499.    ""%s""
  500.    "t"%s""
  501.    "t"%s""
  502.    "t"%s""
  503.    "t"%s""
  504.    "t"%s""
  505.    "t"%s""
  506.    "t"%d""
  507.    "t"%lu""
  508.    "t"%d""
  509.    "t"%lu""
  510.    "n", szTime, pPopLnk->pszDomain, pPopLnk->pszName,
  511.    pPopLnk->pszRmtDomain, pPopLnk->pszRmtName, pPopLnk->pszAuthType, pszStatus,
  512.    pSRep->iMsgSync, pSRep->ulSizeSync, pSRep->iMsgErr, pSRep->ulSizeErr);
  514. RLckUnlockEX(hResLock);
  516. return (0);
  518. }