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

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

Email服务器

开发平台：

Visual C++

POP3GwLink.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 "ResLocks.h"
  28. #include "StrUtils.h"
  29. #include "SList.h"
  30. #include "BuffSock.h"
  31. #include "MailConfig.h"
  32. #include "MessQueue.h"
  33. #include "MailSvr.h"
  34. #include "MiscUtils.h"
  35. #include "SvrUtils.h"
  36. #include "UsrUtils.h"
  37. #include "POP3GwLink.h"
  39. #define SVR_LINKS_FILE              "pop3links.tab"
  40. #define SVR_LINKS_ENABLE_DIR        "pop3links"
  41. #define SVR_POP3LOCKS_DIR           "pop3linklocks"
  42. #define LINKS_TABLE_LINE_MAX        2048
  44. enum LinksFileds {
  45. lnkDomain = 0,
  46. lnkName,
  47. lnkRmtDomain,
  48. lnkRmtName,
  49. lnkRmtPassword,
  50. lnkAuthType,
  52. lnkMax
  53. };
  55. struct GwLkDBScanData {
  56. char szTmpDBFile[SYS_MAX_PATH];
  57. FILE *pDBFile;
  58. };
  60. static char *GwLkGetTableFilePath(char *pszLnkFilePath, int iMaxPath);
  61. static char *GwLkEnableDir(char *pszEnableDir, int iMaxPath);
  62. static char *GwLkGetLocksDir(char *pszLocksDir, int iMaxPath);
  63. static POP3Link *GwLkGetLinkFromStrings(char **ppszStrings);
  64. static int GwLkWriteLink(FILE * pLnkFile, POP3Link * pPopLnk);
  65. static char *GwLkSanitizeFileName(char const *pszInName, char *pszOutName, int iOutSize);
  66. static char *GwLkGetLockFileName(POP3Link const *pPopLnk, char *pszLockFile);
  67. static int GwLkGetDisableFilePath(POP3Link const *pPopLnk, char *pszEnableFile);
  69. static char *GwLkGetTableFilePath(char *pszLnkFilePath, int iMaxPath)
  70. {
  72. CfgGetRootPath(pszLnkFilePath, iMaxPath);
  74. StrNCat(pszLnkFilePath, SVR_LINKS_FILE, iMaxPath);
  76. return (pszLnkFilePath);
  78. }
  80. static char *GwLkEnableDir(char *pszEnableDir, int iMaxPath)
  81. {
  83. CfgGetRootPath(pszEnableDir, iMaxPath);
  85. StrNCat(pszEnableDir, SVR_LINKS_ENABLE_DIR, iMaxPath);
  87. return (pszEnableDir);
  89. }
  91. static char *GwLkGetLocksDir(char *pszLocksDir, int iMaxPath)
  92. {
  94. CfgGetRootPath(pszLocksDir, iMaxPath);
  96. StrNCat(pszLocksDir, SVR_POP3LOCKS_DIR, iMaxPath);
  98. return (pszLocksDir);
  100. }
  102. static POP3Link *GwLkGetLinkFromStrings(char **ppszStrings)
  103. {
  105. int iFieldsCount = StrStringsCount(ppszStrings);
  107. if (iFieldsCount < lnkMax)
  108. return (NULL);
  110. char szPassword[512] = "";
  112. if (StrDeCrypt(ppszStrings[lnkRmtPassword], szPassword) == NULL)
  113. return (NULL);
  115. POP3Link *pPopLnk = (POP3Link *) SysAlloc(sizeof(POP3Link));
  117. if (pPopLnk == NULL)
  118. return (NULL);
  120. pPopLnk->pszDomain = SysStrDup(ppszStrings[lnkDomain]);
  121. pPopLnk->pszName = SysStrDup(ppszStrings[lnkName]);
  122. pPopLnk->pszRmtDomain = SysStrDup(ppszStrings[lnkRmtDomain]);
  123. pPopLnk->pszRmtName = SysStrDup(ppszStrings[lnkRmtName]);
  124. pPopLnk->pszRmtPassword = SysStrDup(szPassword);
  125. pPopLnk->pszAuthType = SysStrDup(ppszStrings[lnkAuthType]);
  127. return (pPopLnk);
  129. }
  131. POP3Link *GwLkAllocLink(char const *pszDomain, char const *pszName,
  132. char const *pszRmtDomain, char const *pszRmtName,
  133. char const *pszRmtPassword, char const *pszAuthType)
  134. {
  136. POP3Link *pPopLnk = (POP3Link *) SysAlloc(sizeof(POP3Link));
  138. if (pPopLnk == NULL)
  139. return (NULL);
  141. pPopLnk->pszDomain = (pszDomain != NULL) ? SysStrDup(pszDomain) : NULL;
  142. pPopLnk->pszName = (pszName != NULL) ? SysStrDup(pszName) : NULL;
  143. pPopLnk->pszRmtDomain = (pszRmtDomain != NULL) ? SysStrDup(pszRmtDomain) : NULL;
  144. pPopLnk->pszRmtName = (pszRmtName != NULL) ? SysStrDup(pszRmtName) : NULL;
  145. pPopLnk->pszRmtPassword = (pszRmtPassword != NULL) ? SysStrDup(pszRmtPassword) : NULL;
  146. pPopLnk->pszAuthType = (pszAuthType != NULL) ? SysStrDup(pszAuthType) : NULL;
  148. return (pPopLnk);
  150. }
  152. void GwLkFreePOP3Link(POP3Link * pPopLnk)
  153. {
  155. if (pPopLnk->pszDomain != NULL)
  156. SysFree(pPopLnk->pszDomain);
  158. if (pPopLnk->pszName != NULL)
  159. SysFree(pPopLnk->pszName);
  161. if (pPopLnk->pszRmtDomain != NULL)
  162. SysFree(pPopLnk->pszRmtDomain);
  164. if (pPopLnk->pszRmtName != NULL)
  165. SysFree(pPopLnk->pszRmtName);
  167. if (pPopLnk->pszRmtPassword != NULL)
  168. SysFree(pPopLnk->pszRmtPassword);
  170. if (pPopLnk->pszAuthType != NULL)
  171. SysFree(pPopLnk->pszAuthType);
  173. SysFree(pPopLnk);
  175. }
  177. static int GwLkWriteLink(FILE * pLnkFile, POP3Link * pPopLnk)
  178. {
  180. ///////////////////////////////////////////////////////////////////////////////
  181. //  Domain
  182. ///////////////////////////////////////////////////////////////////////////////
  183. char *pszQuoted = StrQuote(pPopLnk->pszDomain, '"');
  185. if (pszQuoted == NULL)
  186. return (ErrGetErrorCode());
  188. fprintf(pLnkFile, "%st", pszQuoted);
  190. SysFree(pszQuoted);
  192. ///////////////////////////////////////////////////////////////////////////////
  193. //  Local user
  194. ///////////////////////////////////////////////////////////////////////////////
  195. pszQuoted = StrQuote(pPopLnk->pszName, '"');
  197. if (pszQuoted == NULL)
  198. return (ErrGetErrorCode());
  200. fprintf(pLnkFile, "%st", pszQuoted);
  202. SysFree(pszQuoted);
  204. ///////////////////////////////////////////////////////////////////////////////
  205. //  Remote domain
  206. ///////////////////////////////////////////////////////////////////////////////
  207. pszQuoted = StrQuote(pPopLnk->pszRmtDomain, '"');
  209. if (pszQuoted == NULL)
  210. return (ErrGetErrorCode());
  212. fprintf(pLnkFile, "%st", pszQuoted);
  214. SysFree(pszQuoted);
  216. ///////////////////////////////////////////////////////////////////////////////
  217. //  Remote user
  218. ///////////////////////////////////////////////////////////////////////////////
  219. pszQuoted = StrQuote(pPopLnk->pszRmtName, '"');
  221. if (pszQuoted == NULL)
  222. return (ErrGetErrorCode());
  224. fprintf(pLnkFile, "%st", pszQuoted);
  226. SysFree(pszQuoted);
  228. ///////////////////////////////////////////////////////////////////////////////
  229. //  Remote password
  230. ///////////////////////////////////////////////////////////////////////////////
  231. char szPassword[512] = "";
  233. StrCrypt(pPopLnk->pszRmtPassword, szPassword);
  235. pszQuoted = StrQuote(szPassword, '"');
  237. if (pszQuoted == NULL)
  238. return (ErrGetErrorCode());
  240. fprintf(pLnkFile, "%st", pszQuoted);
  242. SysFree(pszQuoted);
  244. ///////////////////////////////////////////////////////////////////////////////
  245. //  Authentication type
  246. ///////////////////////////////////////////////////////////////////////////////
  247. pszQuoted = StrQuote(pPopLnk->pszAuthType, '"');
  249. if (pszQuoted == NULL)
  250. return (ErrGetErrorCode());
  252. fprintf(pLnkFile, "%sn", pszQuoted);
  254. SysFree(pszQuoted);
  256. return (0);
  258. }
  260. int GwLkAddLink(POP3Link * pPopLnk)
  261. {
  263. char szLnkFilePath[SYS_MAX_PATH] = "";
  265. GwLkGetTableFilePath(szLnkFilePath, sizeof(szLnkFilePath));
  267. char szResLock[SYS_MAX_PATH] = "";
  268. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szLnkFilePath, szResLock,
  269.   sizeof(szResLock)));
  271. if (hResLock == INVALID_RLCK_HANDLE)
  272. return (ErrGetErrorCode());
  274. FILE *pLnkFile = fopen(szLnkFilePath, "r+t");
  276. if (pLnkFile == NULL) {
  277. RLckUnlockEX(hResLock);
  279. ErrSetErrorCode(ERR_LINKS_FILE_NOT_FOUND);
  280. return (ERR_LINKS_FILE_NOT_FOUND);
  281. }
  283. char szLnkLine[LINKS_TABLE_LINE_MAX] = "";
  285. while (MscGetConfigLine(szLnkLine, sizeof(szLnkLine) - 1, pLnkFile) != NULL) {
  286. char **ppszStrings = StrGetTabLineStrings(szLnkLine);
  288. if (ppszStrings == NULL)
  289. continue;
  291. int iFieldsCount = StrStringsCount(ppszStrings);
  293. if ((iFieldsCount >= lnkMax) &&
  294.     (stricmp(pPopLnk->pszDomain, ppszStrings[lnkDomain]) == 0) &&
  295.     (stricmp(pPopLnk->pszName, ppszStrings[lnkName]) == 0) &&
  296.     (stricmp(pPopLnk->pszRmtDomain, ppszStrings[lnkRmtDomain]) == 0) &&
  297.     (stricmp(pPopLnk->pszRmtName, ppszStrings[lnkRmtName]) == 0)) {
  298. StrFreeStrings(ppszStrings);
  299. fclose(pLnkFile);
  300. RLckUnlockEX(hResLock);
  302. ErrSetErrorCode(ERR_LINK_EXIST);
  303. return (ERR_LINK_EXIST);
  304. }
  306. StrFreeStrings(ppszStrings);
  307. }
  309. fseek(pLnkFile, 0, SEEK_END);
  311. if (GwLkWriteLink(pLnkFile, pPopLnk) < 0) {
  312. fclose(pLnkFile);
  313. RLckUnlockEX(hResLock);
  315. ErrSetErrorCode(ERR_WRITE_LINKS_FILE);
  316. return (ERR_WRITE_LINKS_FILE);
  317. }
  319. fclose(pLnkFile);
  321. RLckUnlockEX(hResLock);
  323. return (0);
  325. }
  327. int GwLkRemoveLink(POP3Link * pPopLnk)
  328. {
  330. char szLnkFilePath[SYS_MAX_PATH] = "";
  332. GwLkGetTableFilePath(szLnkFilePath, sizeof(szLnkFilePath));
  334. char szTmpFile[SYS_MAX_PATH] = "";
  336. SysGetTmpFile(szTmpFile);
  338. char szResLock[SYS_MAX_PATH] = "";
  339. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szLnkFilePath, szResLock,
  340.   sizeof(szResLock)));
  342. if (hResLock == INVALID_RLCK_HANDLE)
  343. return (ErrGetErrorCode());
  345. FILE *pLnkFile = fopen(szLnkFilePath, "rt");
  347. if (pLnkFile == NULL) {
  348. RLckUnlockEX(hResLock);
  350. ErrSetErrorCode(ERR_LINKS_FILE_NOT_FOUND);
  351. return (ERR_LINKS_FILE_NOT_FOUND);
  352. }
  354. FILE *pTmpFile = fopen(szTmpFile, "wt");
  356. if (pTmpFile == NULL) {
  357. fclose(pLnkFile);
  358. RLckUnlockEX(hResLock);
  360. ErrSetErrorCode(ERR_FILE_CREATE);
  361. return (ERR_FILE_CREATE);
  362. }
  364. int iLinksFound = 0;
  365. char szLnkLine[LINKS_TABLE_LINE_MAX] = "";
  367. while (MscGetConfigLine(szLnkLine, sizeof(szLnkLine) - 1, pLnkFile, false) != NULL) {
  368. if (szLnkLine[0] == TAB_COMMENT_CHAR) {
  369. fprintf(pTmpFile, "%sn", szLnkLine);
  370. continue;
  371. }
  373. char **ppszStrings = StrGetTabLineStrings(szLnkLine);
  375. if (ppszStrings == NULL)
  376. continue;
  378. int iFieldsCount = StrStringsCount(ppszStrings);
  380. if ((iFieldsCount >= lnkMax) &&
  381.     (stricmp(pPopLnk->pszDomain, ppszStrings[lnkDomain]) == 0) &&
  382.     (stricmp(pPopLnk->pszName, ppszStrings[lnkName]) == 0) &&
  383.     (stricmp(pPopLnk->pszRmtDomain, ppszStrings[lnkRmtDomain]) == 0) &&
  384.     (stricmp(pPopLnk->pszRmtName, ppszStrings[lnkRmtName]) == 0)) {
  386. ++iLinksFound;
  388. } else
  389. fprintf(pTmpFile, "%sn", szLnkLine);
  391. StrFreeStrings(ppszStrings);
  392. }
  394. fclose(pLnkFile);
  395. fclose(pTmpFile);
  397. if (iLinksFound == 0) {
  398. SysRemove(szTmpFile);
  399. RLckUnlockEX(hResLock);
  401. ErrSetErrorCode(ERR_LINK_NOT_FOUND);
  402. return (ERR_LINK_NOT_FOUND);
  403. }
  405. char szTmpLnkFilePath[SYS_MAX_PATH] = "";
  407. sprintf(szTmpLnkFilePath, "%s.tmp", szLnkFilePath);
  409. if (MscMoveFile(szLnkFilePath, szTmpLnkFilePath) < 0) {
  410. ErrorPush();
  411. RLckUnlockEX(hResLock);
  412. return (ErrorPop());
  413. }
  415. if (MscMoveFile(szTmpFile, szLnkFilePath) < 0) {
  416. ErrorPush();
  417. MscMoveFile(szTmpLnkFilePath, szLnkFilePath);
  418. RLckUnlockEX(hResLock);
  419. return (ErrorPop());
  420. }
  422. SysRemove(szTmpLnkFilePath);
  424. ///////////////////////////////////////////////////////////////////////////////
  425. //  Remove the disable file if exist
  426. ///////////////////////////////////////////////////////////////////////////////
  427. char szEnableFile[SYS_MAX_PATH] = "";
  429. if (GwLkGetDisableFilePath(pPopLnk, szEnableFile) < 0) {
  430. ErrorPush();
  431. RLckUnlockEX(hResLock);
  432. return (ErrorPop());
  433. }
  435. CheckRemoveFile(szEnableFile);
  437. RLckUnlockEX(hResLock);
  439. return (0);
  441. }
  443. int GwLkRemoveUserLinks(const char *pszDomain, const char *pszName)
  444. {
  446. char szLnkFilePath[SYS_MAX_PATH] = "";
  448. GwLkGetTableFilePath(szLnkFilePath, sizeof(szLnkFilePath));
  450. char szTmpFile[SYS_MAX_PATH] = "";
  452. SysGetTmpFile(szTmpFile);
  454. char szResLock[SYS_MAX_PATH] = "";
  455. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szLnkFilePath, szResLock,
  456.   sizeof(szResLock)));
  458. if (hResLock == INVALID_RLCK_HANDLE) {
  459. ErrorPush();
  460. CheckRemoveFile(szTmpFile);
  461. return (ErrorPop());
  462. }
  464. FILE *pLnkFile = fopen(szLnkFilePath, "rt");
  466. if (pLnkFile == NULL) {
  467. RLckUnlockEX(hResLock);
  469. ErrSetErrorCode(ERR_LINKS_FILE_NOT_FOUND);
  470. return (ERR_LINKS_FILE_NOT_FOUND);
  471. }
  473. FILE *pTmpFile = fopen(szTmpFile, "wt");
  475. if (pTmpFile == NULL) {
  476. fclose(pLnkFile);
  477. RLckUnlockEX(hResLock);
  479. ErrSetErrorCode(ERR_FILE_CREATE);
  480. return (ERR_FILE_CREATE);
  481. }
  483. int iLinksFound = 0;
  484. char szLnkLine[LINKS_TABLE_LINE_MAX] = "";
  486. while (MscGetConfigLine(szLnkLine, sizeof(szLnkLine) - 1, pLnkFile, false) != NULL) {
  487. if (szLnkLine[0] == TAB_COMMENT_CHAR) {
  488. fprintf(pTmpFile, "%sn", szLnkLine);
  489. continue;
  490. }
  492. char **ppszStrings = StrGetTabLineStrings(szLnkLine);
  494. if (ppszStrings == NULL)
  495. continue;
  497. int iFieldsCount = StrStringsCount(ppszStrings);
  499. if ((iFieldsCount >= lnkMax) && (stricmp(pszDomain, ppszStrings[lnkDomain]) == 0)
  500.     && (stricmp(pszName, ppszStrings[lnkName]) == 0)) {
  502. ++iLinksFound;
  504. } else
  505. fprintf(pTmpFile, "%sn", szLnkLine);
  507. StrFreeStrings(ppszStrings);
  508. }
  510. fclose(pLnkFile);
  511. fclose(pTmpFile);
  513. if (iLinksFound == 0) {
  514. SysRemove(szTmpFile);
  515. RLckUnlockEX(hResLock);
  516. return (0);
  517. }
  519. char szTmpLnkFilePath[SYS_MAX_PATH] = "";
  521. sprintf(szTmpLnkFilePath, "%s.tmp", szLnkFilePath);
  523. if (MscMoveFile(szLnkFilePath, szTmpLnkFilePath) < 0) {
  524. ErrorPush();
  525. RLckUnlockEX(hResLock);
  526. return (ErrorPop());
  527. }
  529. if (MscMoveFile(szTmpFile, szLnkFilePath) < 0) {
  530. ErrorPush();
  531. MscMoveFile(szTmpLnkFilePath, szLnkFilePath);
  532. RLckUnlockEX(hResLock);
  533. return (ErrorPop());
  534. }
  536. SysRemove(szTmpLnkFilePath);
  538. RLckUnlockEX(hResLock);
  540. return (0);
  542. }
  544. int GwLkRemoveDomainLinks(const char *pszDomain)
  545. {
  547. char szLnkFilePath[SYS_MAX_PATH] = "";
  549. GwLkGetTableFilePath(szLnkFilePath, sizeof(szLnkFilePath));
  551. char szTmpFile[SYS_MAX_PATH] = "";
  553. SysGetTmpFile(szTmpFile);
  555. char szResLock[SYS_MAX_PATH] = "";
  556. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szLnkFilePath, szResLock,
  557.   sizeof(szResLock)));
  559. if (hResLock == INVALID_RLCK_HANDLE) {
  560. ErrorPush();
  561. CheckRemoveFile(szTmpFile);
  562. return (ErrorPop());
  563. }
  565. FILE *pLnkFile = fopen(szLnkFilePath, "rt");
  567. if (pLnkFile == NULL) {
  568. RLckUnlockEX(hResLock);
  569. CheckRemoveFile(szTmpFile);
  571. ErrSetErrorCode(ERR_LINKS_FILE_NOT_FOUND);
  572. return (ERR_LINKS_FILE_NOT_FOUND);
  573. }
  575. FILE *pTmpFile = fopen(szTmpFile, "wt");
  577. if (pTmpFile == NULL) {
  578. fclose(pLnkFile);
  579. RLckUnlockEX(hResLock);
  580. CheckRemoveFile(szTmpFile);
  582. ErrSetErrorCode(ERR_FILE_CREATE);
  583. return (ERR_FILE_CREATE);
  584. }
  586. int iLinksFound = 0;
  587. char szLnkLine[LINKS_TABLE_LINE_MAX] = "";
  589. while (MscGetConfigLine(szLnkLine, sizeof(szLnkLine) - 1, pLnkFile, false) != NULL) {
  590. if (szLnkLine[0] == TAB_COMMENT_CHAR) {
  591. fprintf(pTmpFile, "%sn", szLnkLine);
  592. continue;
  593. }
  595. char **ppszStrings = StrGetTabLineStrings(szLnkLine);
  597. if (ppszStrings == NULL)
  598. continue;
  600. int iFieldsCount = StrStringsCount(ppszStrings);
  602. if ((iFieldsCount >= lnkMax) && (stricmp(pszDomain, ppszStrings[lnkDomain]) == 0)) {
  604. ++iLinksFound;
  606. } else
  607. fprintf(pTmpFile, "%sn", szLnkLine);
  609. StrFreeStrings(ppszStrings);
  610. }
  612. fclose(pLnkFile);
  613. fclose(pTmpFile);
  615. if (iLinksFound == 0) {
  616. SysRemove(szTmpFile);
  617. RLckUnlockEX(hResLock);
  618. return (0);
  619. }
  621. char szTmpLnkFilePath[SYS_MAX_PATH] = "";
  623. sprintf(szTmpLnkFilePath, "%s.tmp", szLnkFilePath);
  625. if (MscMoveFile(szLnkFilePath, szTmpLnkFilePath) < 0) {
  626. ErrorPush();
  627. SysRemove(szTmpFile);
  628. RLckUnlockEX(hResLock);
  629. return (ErrorPop());
  630. }
  632. if (MscMoveFile(szTmpFile, szLnkFilePath) < 0) {
  633. ErrorPush();
  634. MscMoveFile(szTmpLnkFilePath, szLnkFilePath);
  635. SysRemove(szTmpFile);
  636. RLckUnlockEX(hResLock);
  637. return (ErrorPop());
  638. }
  640. SysRemove(szTmpLnkFilePath);
  642. RLckUnlockEX(hResLock);
  644. return (0);
  646. }
  648. int GwLkGetDBFileSnapShot(const char *pszFileName)
  649. {
  651. char szGwLkFilePath[SYS_MAX_PATH] = "";
  653. GwLkGetTableFilePath(szGwLkFilePath, sizeof(szGwLkFilePath));
  655. char szResLock[SYS_MAX_PATH] = "";
  656. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szGwLkFilePath, szResLock,
  657.   sizeof(szResLock)));
  659. if (hResLock == INVALID_RLCK_HANDLE)
  660. return (ErrGetErrorCode());
  662. if (MscCopyFile(pszFileName, szGwLkFilePath) < 0) {
  663. ErrorPush();
  664. RLckUnlockSH(hResLock);
  665. return (ErrorPop());
  666. }
  668. RLckUnlockSH(hResLock);
  670. return (0);
  672. }
  674. GWLKF_HANDLE GwLkOpenDB(void)
  675. {
  677. GwLkDBScanData *pGLSD = (GwLkDBScanData *) SysAlloc(sizeof(GwLkDBScanData));
  679. if (pGLSD == NULL)
  680. return (INVALID_GWLKF_HANDLE);
  682. SysGetTmpFile(pGLSD->szTmpDBFile);
  684. if (GwLkGetDBFileSnapShot(pGLSD->szTmpDBFile) < 0) {
  685. SysFree(pGLSD);
  686. return (INVALID_GWLKF_HANDLE);
  687. }
  689. if ((pGLSD->pDBFile = fopen(pGLSD->szTmpDBFile, "rt")) == NULL) {
  690. SysRemove(pGLSD->szTmpDBFile);
  691. SysFree(pGLSD);
  693. ErrSetErrorCode(ERR_FILE_OPEN);
  694. return (INVALID_GWLKF_HANDLE);
  695. }
  697. return ((GWLKF_HANDLE) pGLSD);
  699. }
  701. void GwLkCloseDB(GWLKF_HANDLE hLinksDB)
  702. {
  704. GwLkDBScanData *pGLSD = (GwLkDBScanData *) hLinksDB;
  706. fclose(pGLSD->pDBFile);
  708. SysRemove(pGLSD->szTmpDBFile);
  710. SysFree(pGLSD);
  712. }
  714. POP3Link *GwLkGetFirstUser(GWLKF_HANDLE hLinksDB)
  715. {
  717. GwLkDBScanData *pGLSD = (GwLkDBScanData *) hLinksDB;
  719. rewind(pGLSD->pDBFile);
  721. POP3Link *pPopLnk = NULL;
  722. char szLnkLine[LINKS_TABLE_LINE_MAX] = "";
  724. while ((pPopLnk == NULL) &&
  725.        (MscGetConfigLine(szLnkLine, sizeof(szLnkLine) - 1, pGLSD->pDBFile) != NULL)) {
  726. char **ppszStrings = StrGetTabLineStrings(szLnkLine);
  728. if (ppszStrings == NULL)
  729. continue;
  731. int iFieldsCount = StrStringsCount(ppszStrings);
  733. if (iFieldsCount >= lnkMax)
  734. pPopLnk = GwLkGetLinkFromStrings(ppszStrings);
  736. StrFreeStrings(ppszStrings);
  737. }
  739. return (pPopLnk);
  741. }
  743. POP3Link *GwLkGetNextUser(GWLKF_HANDLE hLinksDB)
  744. {
  746. GwLkDBScanData *pGLSD = (GwLkDBScanData *) hLinksDB;
  748. POP3Link *pPopLnk = NULL;
  749. char szLnkLine[LINKS_TABLE_LINE_MAX] = "";
  751. while ((pPopLnk == NULL) &&
  752.        (MscGetConfigLine(szLnkLine, sizeof(szLnkLine) - 1, pGLSD->pDBFile) != NULL)) {
  753. char **ppszStrings = StrGetTabLineStrings(szLnkLine);
  755. if (ppszStrings == NULL)
  756. continue;
  758. int iFieldsCount = StrStringsCount(ppszStrings);
  760. if (iFieldsCount >= lnkMax)
  761. pPopLnk = GwLkGetLinkFromStrings(ppszStrings);
  763. StrFreeStrings(ppszStrings);
  764. }
  766. return (pPopLnk);
  768. }
  770. static char *GwLkSanitizeFileName(char const *pszInName, char *pszOutName, int iOutSize)
  771. {
  773. int i;
  775. for (i = 0, iOutSize--; i < iOutSize && *pszInName != ''; i++, pszInName++) {
  776. switch (*pszInName) {
  777. case ':':
  778. case '/':
  779. case '\':
  780. pszOutName[i] = '_';
  781. break;
  782. default:
  783. pszOutName[i] = *pszInName;
  784. }
  785. }
  786. pszOutName[i] = '';
  788. return (pszOutName);
  789. }
  791. static char *GwLkGetLockFileName(POP3Link const *pPopLnk, char *pszLockFile)
  792. {
  794. char szLocksDir[SYS_MAX_PATH] = "";
  795. char szRmtDomain[MAX_HOST_NAME] = "";
  796. char szRmtName[MAX_HOST_NAME] = "";
  798. GwLkGetLocksDir(szLocksDir, sizeof(szLocksDir));
  800. GwLkSanitizeFileName(pPopLnk->pszRmtDomain, szRmtDomain, sizeof(szRmtDomain) - 1);
  801. GwLkSanitizeFileName(pPopLnk->pszRmtName, szRmtName, sizeof(szRmtName) - 1);
  803. sprintf(pszLockFile, "%s%s%s@%s", szLocksDir, SYS_SLASH_STR, szRmtName,
  804. szRmtDomain);
  806. return (pszLockFile);
  808. }
  810. int GwLkLinkLock(POP3Link const *pPopLnk)
  811. {
  813. char szLockFile[SYS_MAX_PATH] = "";
  815. GwLkGetLockFileName(pPopLnk, szLockFile);
  817. return (SysLockFile(szLockFile));
  819. }
  821. void GwLkLinkUnlock(POP3Link const *pPopLnk)
  822. {
  824. char szLockFile[SYS_MAX_PATH] = "";
  826. GwLkGetLockFileName(pPopLnk, szLockFile);
  828. SysUnlockFile(szLockFile);
  830. }
  832. int GwLkClearLinkLocksDir(void)
  833. {
  835. char szLocksDir[SYS_MAX_PATH] = "";
  837. GwLkGetLocksDir(szLocksDir, sizeof(szLocksDir));
  839. return (MscClearDirectory(szLocksDir));
  841. }
  843. int GwLkLocalDomain(POP3Link const *pPopLnk)
  844. {
  846. return (((pPopLnk != NULL) && (pPopLnk->pszDomain[0] != '@') &&
  847.  (pPopLnk->pszDomain[0] != '?') && (pPopLnk->pszDomain[0] != '&')) ? 1 : 0);
  849. }
  851. int GwLkMasqueradeDomain(POP3Link const *pPopLnk)
  852. {
  854. return (((pPopLnk != NULL) &&
  855.  ((pPopLnk->pszDomain[0] == '?') || (pPopLnk->pszDomain[0] == '&'))) ? 1 : 0);
  857. }
  859. static int GwLkGetDisableFilePath(POP3Link const *pPopLnk, char *pszEnableFile)
  860. {
  862. if (GwLkLocalDomain(pPopLnk)) {
  863. UserInfo *pUI = UsrGetUserByName(pPopLnk->pszDomain, pPopLnk->pszName);
  865. if (pUI == NULL)
  866. return (ErrGetErrorCode());
  868. char szUserPath[SYS_MAX_PATH] = "";
  870. if (UsrGetUserPath(pUI, szUserPath, sizeof(szUserPath), 1) == NULL) {
  871. ErrorPush();
  872. UsrFreeUserInfo(pUI);
  873. return (ErrorPop());
  874. }
  876. UsrFreeUserInfo(pUI);
  878. sprintf(pszEnableFile, "%s%s@%s.disabled", szUserPath, pPopLnk->pszRmtName,
  879. pPopLnk->pszRmtDomain);
  880. } else {
  881. char szEnableDir[SYS_MAX_PATH] = "";
  883. GwLkEnableDir(szEnableDir, sizeof(szEnableDir));
  885. sprintf(pszEnableFile, "%s%s%s@%s.disabled", szEnableDir, SYS_SLASH_STR,
  886. pPopLnk->pszRmtName, pPopLnk->pszRmtDomain);
  887. }
  889. return (0);
  891. }
  893. int GwLkCheckEnabled(POP3Link const *pPopLnk)
  894. {
  896. char szEnableFile[SYS_MAX_PATH] = "";
  898. if (GwLkGetDisableFilePath(pPopLnk, szEnableFile) < 0)
  899. return (ErrGetErrorCode());
  901. if (SysExistFile(szEnableFile)) {
  902. ErrSetErrorCode(ERR_POP3_EXTERNAL_LINK_DISABLED);
  903. return (ERR_POP3_EXTERNAL_LINK_DISABLED);
  904. }
  906. return (0);
  908. }
  910. int GwLkEnable(POP3Link const *pPopLnk, bool bEnable)
  911. {
  913. char szEnableFile[SYS_MAX_PATH] = "";
  915. if (GwLkGetDisableFilePath(pPopLnk, szEnableFile) < 0)
  916. return (ErrGetErrorCode());
  918. if (bEnable)
  919. CheckRemoveFile(szEnableFile);
  920. else {
  921. FILE *pFile = fopen(szEnableFile, "wt");
  923. if (pFile == NULL) {
  924. ErrSetErrorCode(ERR_FILE_CREATE);
  925. return (ERR_FILE_CREATE);
  926. }
  928. time_t tCurr;
  930. time(&tCurr);
  932. struct tm tmTime;
  933. char szTime[256] = "";
  935. SysLocalTime(&tCurr, &tmTime);
  937. strftime(szTime, sizeof(szTime), "%d %b %Y %H:%M:%S %Z", &tmTime);
  939. fprintf(pFile, "%sn", szTime);
  941. fclose(pFile);
  942. }
  944. return (0);
  946. }
  948. int GwLkEnable(char const *pszDomain, char const *pszName,
  949.        char const *pszRmtDomain, char const *pszRmtName, bool bEnable)
  950. {
  952. GWLKF_HANDLE hLinksDB = GwLkOpenDB();
  954. if (hLinksDB == INVALID_GWLKF_HANDLE)
  955. return (ErrGetErrorCode());
  957. int iMatchingUsers = 0;
  958. POP3Link *pPopLnk = GwLkGetFirstUser(hLinksDB);
  960. for (; pPopLnk != NULL; pPopLnk = GwLkGetNextUser(hLinksDB)) {
  961. if ((stricmp(pPopLnk->pszDomain, pszDomain) == 0) &&
  962.     (stricmp(pPopLnk->pszName, pszName) == 0) &&
  963.     ((pszRmtDomain == NULL) ||
  964.      (stricmp(pPopLnk->pszRmtDomain, pszRmtDomain) == 0)) && ((pszRmtName == NULL)
  965.       ||
  966.       (stricmp
  967.        (pPopLnk->
  968. pszRmtName,
  969. pszRmtName) ==
  970.        0))) {
  971. GwLkEnable(pPopLnk, bEnable);
  973. ++iMatchingUsers;
  974. }
  976. GwLkFreePOP3Link(pPopLnk);
  977. }
  979. GwLkCloseDB(hLinksDB);
  981. if (iMatchingUsers == 0) {
  982. ErrSetErrorCode(ERR_LINK_NOT_FOUND);
  983. return (ERR_LINK_NOT_FOUND);
  984. }
  986. return (0);
  988. }