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

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

Email服务器

开发平台：

Visual C++

POP3Utils.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 "MD5.h"
  32. #include "MailConfig.h"
  33. #include "UsrUtils.h"
  34. #include "SvrUtils.h"
  35. #include "MessQueue.h"
  36. #include "SMAILUtils.h"
  37. #include "QueueUtils.h"
  38. #include "MiscUtils.h"
  39. #include "Maildir.h"
  40. #include "POP3Svr.h"
  41. #include "POP3Utils.h"
  42. #include "SMTPUtils.h"
  43. #include "MailSvr.h"
  45. #define UPOP_IPMAP_FILE         "pop3.ipmap.tab"
  46. #define POP3_IP_LOGFILE         ".ipconn"
  48. #define POPF_MSG_DELETED        (1 << 0)
  49. #define POPF_MSG_SENT           (1 << 1)
  50. #define POPF_MSG_TOP            (1 << 2)
  52. #define STD_POP3_TIMEOUT        STD_SERVER_TIMEOUT
  54. struct POP3MsgData {
  55. LISTLINK LL;
  56. char szMsgName[SYS_MAX_PATH];
  57. unsigned long ulMsgSize;
  58. unsigned long ulFlags;
  59. };
  61. struct POP3SessionData {
  62. SYS_INET_ADDR PeerInfo;
  63. UserInfo *pUI;
  64. HSLIST hMessageList;
  65. POP3MsgData **ppMsgArray;
  66. int iMsgListed;
  67. int iMsgCount;
  68. unsigned long ulMBSize;
  69. int iLastAccessed;
  70. int iTimeout;
  71. };
  73. static int UPopMailFileNameFilter(char const *pszFileName);
  74. static int UPopFillMessageList(char const *pszBasePath, char const *pszSubPath,
  75.        HSLIST & hMessageList, int &iMsgCount, unsigned long &ulMBSize);
  76. static int UPopBuildMessageList(UserInfo * pUI, HSLIST & hMessageList,
  77. int *piMsgCount = NULL, unsigned long *pulMBSize = NULL);
  78. static void UPopFreeMsgData(POP3MsgData * pPOPMD);
  79. static void UPopFreeMessageList(HSLIST & hMessageList);
  80. static unsigned long UPopMessagesSize(HSLIST & hMessageList);
  81. static POP3MsgData *UPopMessageFromIndex(POP3SessionData * pPOPSD, int iMsgIndex);
  82. static int UPopCheckPeerIP(UserInfo * pUI, SYS_INET_ADDR const &PeerInfo);
  83. static int UPopUpdateMailbox(POP3SessionData * pPOPSD);
  84. static int UPopCheckResponse(const char *pszResponse, char *pszMessage = NULL);
  85. static int UPopGetResponse(BSOCK_HANDLE hBSock, char *pszResponse, int iMaxChars,
  86.    int iTimeout = STD_POP3_TIMEOUT);
  87. static char *UPopExtractServerTimeStamp(char const *pszResponse, char *pszTimeStamp,
  88. int iMaxTimeStamp);
  89. static int UPopSendCommand(BSOCK_HANDLE hBSock, const char *pszCommand, char *pszResponse,
  90.    int iMaxChars, int iTimeout = STD_POP3_TIMEOUT);
  91. static int UPopDoClearTextAuth(BSOCK_HANDLE hBSock, const char *pszUsername,
  92.        const char *pszPassword, char *pszRespBuffer, int iMaxRespChars);
  93. static int UPopDoAPOPAuth(BSOCK_HANDLE hBSock, const char *pszUsername,
  94.   const char *pszPassword, char const *pszTimeStamp,
  95.   char *pszRespBuffer, int iMaxRespChars);
  96. static BSOCK_HANDLE UPopCreateChannel(const char *pszServer, const char *pszUsername,
  97.       const char *pszPassword, bool bTryAuthAPOP = false);
  98. static int UPopCloseChannel(BSOCK_HANDLE hBSock, int iHardClose = 0);
  99. static int UPopGetMailboxStatus(BSOCK_HANDLE hBSock, int &iMsgCount,
  100. unsigned long &ulMailboxSize);
  101. static int UPopGetMailboxStatus(BSOCK_HANDLE hBSock, int &iMsgCount,
  102. unsigned long &ulMailboxSize);
  103. static int UPopRetrieveMessage(BSOCK_HANDLE hBSock, int iMsgIndex, const char *pszFileName,
  104.        unsigned long *pulMsgSize);
  105. static int UPopDeleteMessage(BSOCK_HANDLE hBSock, int iMsgIndex);
  106. static int UPopGetIpLogFilePath(UserInfo * pUI, char *pszFilePath, int iMaxPath);
  108. static int UPopMailFileNameFilter(char const *pszFileName)
  109. {
  111. return ((*pszFileName != '.') ? 1 : 0);
  113. }
  115. int UPopGetMailboxSize(UserInfo * pUI, unsigned long &ulMBSize, unsigned long &ulNumMessages)
  116. {
  118. char szMBPath[SYS_MAX_PATH] = "";
  120. UsrGetMailboxPath(pUI, szMBPath, sizeof(szMBPath), 0);
  122. char szResLock[SYS_MAX_PATH] = "";
  123. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(szMBPath, szResLock,
  124.   sizeof(szResLock)));
  126. if (hResLock == INVALID_RLCK_HANDLE)
  127. return (ErrGetErrorCode());
  129. ulMBSize = 0;
  130. ulNumMessages = 0;
  132. if (MscGetDirectorySize(szMBPath, true, ulMBSize, ulNumMessages,
  133. UPopMailFileNameFilter) < 0) {
  134. ErrorPush();
  135. RLckUnlockSH(hResLock);
  136. return (ErrorPop());
  137. }
  139. RLckUnlockSH(hResLock);
  141. return (0);
  143. }
  145. int UPopCheckMailboxSize(UserInfo * pUI, unsigned long *pulAvailSpace)
  146. {
  148. unsigned long ulMBSize = 0;
  149. unsigned long ulNumMessages = 0;
  151. if (UPopGetMailboxSize(pUI, ulMBSize, ulNumMessages) < 0)
  152. return (ErrGetErrorCode());
  154. char *pszMaxMBSize = UsrGetUserInfoVar(pUI, "MaxMBSize");
  156. if (pszMaxMBSize != NULL) {
  157. unsigned long ulMaxMBSize = (unsigned long) atol(pszMaxMBSize) * 1024;
  159. if (ulMaxMBSize && (ulMBSize >= ulMaxMBSize)) {
  160. SysFree(pszMaxMBSize);
  162. ErrSetErrorCode(ERR_MAILBOX_SIZE);
  163. return (ERR_MAILBOX_SIZE);
  164. }
  166. if (pulAvailSpace != NULL)
  167. *pulAvailSpace = (ulMaxMBSize ? ulMaxMBSize - ulMBSize:
  168.   (unsigned long) -1);
  170. SysFree(pszMaxMBSize);
  171. } else if (pulAvailSpace != NULL)
  172. *pulAvailSpace = ULONG_MAX;
  174. return (0);
  176. }
  178. static int UPopFillMessageList(char const *pszBasePath, char const *pszSubPath,
  179.        HSLIST & hMessageList, int &iMsgCount, unsigned long &ulMBSize)
  180. {
  181. ///////////////////////////////////////////////////////////////////////////////
  182. //  Setup pathname to scan for messages
  183. ///////////////////////////////////////////////////////////////////////////////
  184. char szScanPath[SYS_MAX_PATH] = "";
  186. if (pszSubPath == NULL)
  187. StrSNCpy(szScanPath, pszBasePath);
  188. else
  189. SysSNPrintf(szScanPath, sizeof(szScanPath) - 1, "%s" SYS_SLASH_STR "%s",
  190.     pszBasePath, pszSubPath);
  192. char szFileName[SYS_MAX_PATH] = "";
  193. SYS_HANDLE hFind = SysFirstFile(szScanPath, szFileName);
  195. if (hFind != SYS_INVALID_HANDLE) {
  196. do {
  197. ///////////////////////////////////////////////////////////////////////////////
  198. //  Skip directories and dot-files
  199. ///////////////////////////////////////////////////////////////////////////////
  200. if (SysIsDirectory(hFind) || IsDotFilename(szFileName))
  201. continue;
  203. POP3MsgData *pPOPMD = (POP3MsgData *) SysAlloc(sizeof(POP3MsgData));
  205. if (pPOPMD == NULL) {
  206. ErrorPush();
  207. SysFindClose(hFind);
  208. return (ErrorPop());
  209. }
  210. ///////////////////////////////////////////////////////////////////////////////
  211. //  Setup message entry fields
  212. ///////////////////////////////////////////////////////////////////////////////
  213. ListLinkInit(pPOPMD);
  215. if (pszSubPath == NULL)
  216. StrSNCpy(pPOPMD->szMsgName, szFileName);
  217. else
  218. SysSNPrintf(pPOPMD->szMsgName, sizeof(pPOPMD->szMsgName) - 1,
  219.     "%s" SYS_SLASH_STR "%s", pszSubPath, szFileName);
  221. pPOPMD->ulMsgSize = SysGetSize(hFind);
  222. pPOPMD->ulFlags = 0;
  224. ///////////////////////////////////////////////////////////////////////////////
  225. //  Insert entry in message list
  226. ///////////////////////////////////////////////////////////////////////////////
  227. ListAddTail(hMessageList, (PLISTLINK) pPOPMD);
  229. ///////////////////////////////////////////////////////////////////////////////
  230. //  Update mailbox information
  231. ///////////////////////////////////////////////////////////////////////////////
  232. ulMBSize += pPOPMD->ulMsgSize;
  233. ++iMsgCount;
  235. } while (SysNextFile(hFind, szFileName));
  237. SysFindClose(hFind);
  238. }
  240. return (0);
  242. }
  244. static int UPopBuildMessageList(UserInfo * pUI, HSLIST & hMessageList,
  245. int *piMsgCount, unsigned long *pulMBSize)
  246. {
  248. char szMBPath[SYS_MAX_PATH] = "";
  250. UsrGetMailboxPath(pUI, szMBPath, sizeof(szMBPath), 0);
  252. char szResLock[SYS_MAX_PATH] = "";
  253. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szMBPath, szResLock,
  254.   sizeof(szResLock)));
  256. if (hResLock == INVALID_RLCK_HANDLE)
  257. return (ErrGetErrorCode());
  259. ///////////////////////////////////////////////////////////////////////////////
  260. //  Initialize list and mailbox size information
  261. ///////////////////////////////////////////////////////////////////////////////
  262. ListInit(hMessageList);
  264. int iMsgCount = 0;
  265. unsigned long ulMBSize = 0;
  267. if (iMailboxType == XMAIL_MAILBOX) {
  268. if (UPopFillMessageList(szMBPath, NULL, hMessageList, iMsgCount, ulMBSize) < 0) {
  269. ErrorPush();
  270. UPopFreeMessageList(hMessageList);
  271. RLckUnlockEX(hResLock);
  272. return (ErrorPop());
  273. }
  274. } else {
  275. if ((UPopFillMessageList(szMBPath, "new", hMessageList, iMsgCount, ulMBSize) < 0)
  276.     || (UPopFillMessageList(szMBPath, "cur", hMessageList, iMsgCount, ulMBSize) <
  277. 0)) {
  278. ErrorPush();
  279. UPopFreeMessageList(hMessageList);
  280. RLckUnlockEX(hResLock);
  281. return (ErrorPop());
  282. }
  283. }
  285. RLckUnlockEX(hResLock);
  287. if (piMsgCount != NULL)
  288. *piMsgCount = iMsgCount;
  290. if (pulMBSize != NULL)
  291. *pulMBSize = ulMBSize;
  293. return (0);
  295. }
  297. static void UPopFreeMsgData(POP3MsgData * pPOPMD)
  298. {
  300. SysFree(pPOPMD);
  302. }
  304. static void UPopFreeMessageList(HSLIST & hMessageList)
  305. {
  307. POP3MsgData *pPOPMD;
  309. while ((pPOPMD = (POP3MsgData *) ListRemove(hMessageList)) != INVALID_SLIST_PTR)
  310. UPopFreeMsgData(pPOPMD);
  312. }
  314. static unsigned long UPopMessagesSize(HSLIST & hMessageList)
  315. {
  317. unsigned long ulMBSize = 0;
  318. POP3MsgData *pPOPMD = (POP3MsgData *) ListFirst(hMessageList);
  320. for (; pPOPMD != INVALID_SLIST_PTR; pPOPMD = (POP3MsgData *)
  321.      ListNext(hMessageList, (PLISTLINK) pPOPMD))
  322. ulMBSize += pPOPMD->ulMsgSize;
  324. return (ulMBSize);
  326. }
  328. static POP3MsgData *UPopMessageFromIndex(POP3SessionData * pPOPSD, int iMsgIndex)
  329. {
  331. return (((iMsgIndex >= 0) && (iMsgIndex < pPOPSD->iMsgListed)) ?
  332. pPOPSD->ppMsgArray[iMsgIndex] : NULL);
  334. }
  336. int UPopAuthenticateAPOP(const char *pszDomain, const char *pszUsrName,
  337.  const char *pszTimeStamp, const char *pszDigest)
  338. {
  340. UserInfo *pUI = UsrGetUserByName(pszDomain, pszUsrName);
  342. if (pUI == NULL)
  343. return (ErrGetErrorCode());
  345. int iAuthResult = MscMD5Authenticate(pUI->pszPassword, pszTimeStamp, pszDigest);
  347. UsrFreeUserInfo(pUI);
  349. return (iAuthResult);
  351. }
  353. static int UPopCheckPeerIP(UserInfo * pUI, SYS_INET_ADDR const &PeerInfo)
  354. {
  356. char szIPMapFile[SYS_MAX_PATH] = "";
  358. UsrGetUserPath(pUI, szIPMapFile, sizeof(szIPMapFile), 1);
  359. StrNCat(szIPMapFile, UPOP_IPMAP_FILE, sizeof(szIPMapFile));
  361. if (SysExistFile(szIPMapFile) && (MscCheckAllowedIP(szIPMapFile, PeerInfo, true) < 0))
  362. return (ErrGetErrorCode());
  364. return (0);
  366. }
  368. POP3_HANDLE UPopBuildSession(const char *pszDomain, const char *pszUsrName,
  369.      const char *pszUsrPass, SYS_INET_ADDR const *pPeerInfo)
  370. {
  372. UserInfo *pUI = UsrGetUserByName(pszDomain, pszUsrName);
  374. if (pUI == NULL)
  375. return (INVALID_POP3_HANDLE);
  377. ///////////////////////////////////////////////////////////////////////////////
  378. //  Check if the account is enabled for POP3 sessions
  379. ///////////////////////////////////////////////////////////////////////////////
  380. if (!UsrGetUserInfoVarInt(pUI, "PopEnable", 1)) {
  381. UsrFreeUserInfo(pUI);
  383. ErrSetErrorCode(ERR_USER_DISABLED);
  384. return (INVALID_POP3_HANDLE);
  385. }
  386. ///////////////////////////////////////////////////////////////////////////////
  387. //  Check if peer is allowed to connect from its IP
  388. ///////////////////////////////////////////////////////////////////////////////
  389. if ((pPeerInfo != NULL) && (UPopCheckPeerIP(pUI, *pPeerInfo) < 0)) {
  390. UsrFreeUserInfo(pUI);
  391. return (INVALID_POP3_HANDLE);
  392. }
  394. if ((pszUsrPass != NULL) && (strcmp(pszUsrPass, pUI->pszPassword) != 0)) {
  395. ErrSetErrorCode(ERR_INVALID_PASSWORD);
  396. UsrFreeUserInfo(pUI);
  397. return (INVALID_POP3_HANDLE);
  398. }
  400. if (UsrPOP3Lock(pUI) < 0) {
  401. UsrFreeUserInfo(pUI);
  402. return (INVALID_POP3_HANDLE);
  403. }
  405. POP3SessionData *pPOPSD = (POP3SessionData *) SysAlloc(sizeof(POP3SessionData));
  407. if (pPOPSD == NULL) {
  408. UsrPOP3Unlock(pUI);
  409. UsrFreeUserInfo(pUI);
  410. return (INVALID_POP3_HANDLE);
  411. }
  413. pPOPSD->PeerInfo = *pPeerInfo;
  414. pPOPSD->pUI = pUI;
  415. pPOPSD->iLastAccessed = 0;
  416. pPOPSD->iTimeout = STD_POP3_TIMEOUT;
  418. if (UPopBuildMessageList(pUI, pPOPSD->hMessageList, &pPOPSD->iMsgCount,
  419.  &pPOPSD->ulMBSize) < 0) {
  420. SysFree(pPOPSD);
  421. UsrPOP3Unlock(pUI);
  422. UsrFreeUserInfo(pUI);
  423. return (INVALID_POP3_HANDLE);
  424. }
  426. pPOPSD->iMsgListed = pPOPSD->iMsgCount;
  428. ///////////////////////////////////////////////////////////////////////////////
  429. //  Build lookup array
  430. ///////////////////////////////////////////////////////////////////////////////
  431. if ((pPOPSD->ppMsgArray = (POP3MsgData **) SysAlloc((pPOPSD->iMsgCount + 1) *
  432.     sizeof(POP3MsgData *))) == NULL) {
  433. UPopFreeMessageList(pPOPSD->hMessageList);
  434. SysFree(pPOPSD);
  435. UsrPOP3Unlock(pUI);
  436. UsrFreeUserInfo(pUI);
  437. return (INVALID_POP3_HANDLE);
  438. }
  440. POP3MsgData *pPOPMD = (POP3MsgData *) ListFirst(pPOPSD->hMessageList);
  442. for (int ii = 0; (ii < pPOPSD->iMsgCount) && (pPOPMD != INVALID_SLIST_PTR);
  443.      pPOPMD = (POP3MsgData *) ListNext(pPOPSD->hMessageList, (PLISTLINK) pPOPMD), ii++)
  444. pPOPSD->ppMsgArray[ii] = pPOPMD;
  446. return ((POP3_HANDLE) pPOPSD);
  448. }
  450. void UPopReleaseSession(POP3_HANDLE hPOPSession, int iUpdate)
  451. {
  453. POP3SessionData *pPOPSD = (POP3SessionData *) hPOPSession;
  455. if (iUpdate)
  456. UPopUpdateMailbox(pPOPSD);
  458. UsrPOP3Unlock(pPOPSD->pUI);
  460. UsrFreeUserInfo(pPOPSD->pUI);
  462. UPopFreeMessageList(pPOPSD->hMessageList);
  464. SysFree(pPOPSD->ppMsgArray);
  466. SysFree(pPOPSD);
  468. }
  470. char *UPopGetUserInfoVar(POP3_HANDLE hPOPSession, const char *pszName, const char *pszDefault)
  471. {
  473. POP3SessionData *pPOPSD = (POP3SessionData *) hPOPSession;
  475. return (UsrGetUserInfoVar(pPOPSD->pUI, pszName, pszDefault));
  477. }
  479. static int UPopUpdateMailbox(POP3SessionData * pPOPSD)
  480. {
  482. char szMBPath[SYS_MAX_PATH] = "";
  484. UsrGetMailboxPath(pPOPSD->pUI, szMBPath, sizeof(szMBPath), 0);
  486. char szResLock[SYS_MAX_PATH] = "";
  487. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szMBPath, szResLock,
  488.   sizeof(szResLock)));
  490. if (hResLock == INVALID_RLCK_HANDLE)
  491. return (ErrGetErrorCode());
  493. POP3MsgData *pPOPMD = (POP3MsgData *) ListFirst(pPOPSD->hMessageList);
  495. for (; pPOPMD != INVALID_SLIST_PTR; pPOPMD = (POP3MsgData *)
  496.      ListNext(pPOPSD->hMessageList, (PLISTLINK) pPOPMD)) {
  497. if (pPOPMD->ulFlags & POPF_MSG_DELETED) {
  498. char szMsgPath[SYS_MAX_PATH] = "";
  500. SysSNPrintf(szMsgPath, sizeof(szMsgPath) - 1, "%s" SYS_SLASH_STR "%s",
  501.     szMBPath, pPOPMD->szMsgName);
  503. SysRemove(szMsgPath);
  504. }
  505. }
  507. RLckUnlockEX(hResLock);
  509. return (0);
  511. }
  513. int UPopGetSessionMsgCurrent(POP3_HANDLE hPOPSession)
  514. {
  516. POP3SessionData *pPOPSD = (POP3SessionData *) hPOPSession;
  518. return (pPOPSD->iMsgCount);
  520. }
  522. int UPopGetSessionMsgTotal(POP3_HANDLE hPOPSession)
  523. {
  525. POP3SessionData *pPOPSD = (POP3SessionData *) hPOPSession;
  527. return (pPOPSD->iMsgListed);
  529. }
  531. unsigned long UPopGetSessionMBSize(POP3_HANDLE hPOPSession)
  532. {
  534. POP3SessionData *pPOPSD = (POP3SessionData *) hPOPSession;
  536. return (pPOPSD->ulMBSize);
  538. }
  540. int UPopGetSessionLastAccessed(POP3_HANDLE hPOPSession)
  541. {
  543. POP3SessionData *pPOPSD = (POP3SessionData *) hPOPSession;
  545. return (pPOPSD->iLastAccessed);
  547. }
  549. int UPopGetMessageSize(POP3_HANDLE hPOPSession, int iMsgIndex, unsigned long &ulMessageSize)
  550. {
  552. POP3SessionData *pPOPSD = (POP3SessionData *) hPOPSession;
  554. ulMessageSize = 0;
  556. POP3MsgData *pPOPMD = UPopMessageFromIndex(pPOPSD, iMsgIndex - 1);
  558. if (pPOPMD == NULL) {
  559. ErrSetErrorCode(ERR_MSG_NOT_IN_RANGE);
  560. return (ERR_MSG_NOT_IN_RANGE);
  561. }
  563. if (pPOPMD->ulFlags & POPF_MSG_DELETED) {
  564. ErrSetErrorCode(ERR_MSG_DELETED);
  565. return (ERR_MSG_DELETED);
  566. }
  568. ulMessageSize = pPOPMD->ulMsgSize;
  570. return (0);
  572. }
  574. int UPopGetMessageUIDL(POP3_HANDLE hPOPSession, int iMsgIndex, char *pszMessageUIDL)
  575. {
  577. POP3SessionData *pPOPSD = (POP3SessionData *) hPOPSession;
  579. POP3MsgData *pPOPMD = UPopMessageFromIndex(pPOPSD, iMsgIndex - 1);
  581. if (pPOPMD == NULL) {
  582. ErrSetErrorCode(ERR_MSG_NOT_IN_RANGE);
  583. return (ERR_MSG_NOT_IN_RANGE);
  584. }
  586. if (pPOPMD->ulFlags & POPF_MSG_DELETED) {
  587. ErrSetErrorCode(ERR_MSG_DELETED);
  588. return (ERR_MSG_DELETED);
  589. }
  590. ///////////////////////////////////////////////////////////////////////////////
  591. //  Extract message UIDL from mailbox file path
  592. ///////////////////////////////////////////////////////////////////////////////
  593. char const *pszSlash = strrchr(pPOPMD->szMsgName, SYS_SLASH_CHAR);
  595. strcpy(pszMessageUIDL, (pszSlash != NULL) ? (pszSlash + 1) : pPOPMD->szMsgName);
  597. return (0);
  599. }
  601. int UPopDeleteMessage(POP3_HANDLE hPOPSession, int iMsgIndex)
  602. {
  604. POP3SessionData *pPOPSD = (POP3SessionData *) hPOPSession;
  606. POP3MsgData *pPOPMD = UPopMessageFromIndex(pPOPSD, iMsgIndex - 1);
  608. if (pPOPMD == NULL) {
  609. ErrSetErrorCode(ERR_MSG_NOT_IN_RANGE);
  610. return (ERR_MSG_NOT_IN_RANGE);
  611. }
  613. if (pPOPMD->ulFlags & POPF_MSG_DELETED) {
  614. ErrSetErrorCode(ERR_MSG_DELETED);
  615. return (ERR_MSG_DELETED);
  616. }
  618. pPOPSD->ulMBSize -= pPOPMD->ulMsgSize;
  619. --pPOPSD->iMsgCount;
  621. pPOPMD->ulFlags |= POPF_MSG_DELETED;
  623. pPOPSD->iLastAccessed = iMsgIndex;
  625. return (0);
  627. }
  629. int UPopResetSession(POP3_HANDLE hPOPSession)
  630. {
  632. POP3SessionData *pPOPSD = (POP3SessionData *) hPOPSession;
  634. POP3MsgData *pPOPMD = (POP3MsgData *) ListFirst(pPOPSD->hMessageList);
  636. for (; pPOPMD != INVALID_SLIST_PTR; pPOPMD = (POP3MsgData *)
  637.      ListNext(pPOPSD->hMessageList, (PLISTLINK) pPOPMD)) {
  638. if (pPOPMD->ulFlags & POPF_MSG_DELETED) {
  639. pPOPSD->ulMBSize += pPOPMD->ulMsgSize;
  641. ++pPOPSD->iMsgCount;
  643. pPOPMD->ulFlags &= ~(POPF_MSG_DELETED | POPF_MSG_SENT | POPF_MSG_TOP);
  644. }
  645. }
  647. pPOPSD->iLastAccessed = 0;
  649. return (0);
  651. }
  653. int UPopSendErrorResponse(BSOCK_HANDLE hBSock, int iErrorCode, int iTimeout)
  654. {
  656. char const *pszError = ErrGetErrorString(iErrorCode);
  657. char *pszPOP3Error = (char *) SysAlloc(strlen(pszError) + 8);
  659. if (pszPOP3Error == NULL)
  660. return (ErrGetErrorCode());
  662. sprintf(pszPOP3Error, "-ERR %s", pszError);
  664. if (BSckSendString(hBSock, pszPOP3Error, iTimeout) < 0) {
  665. SysFree(pszPOP3Error);
  666. return (ErrGetErrorCode());
  667. }
  669. SysFree(pszPOP3Error);
  671. return (0);
  673. }
  675. int UPopSessionSendMsg(POP3_HANDLE hPOPSession, int iMsgIndex, BSOCK_HANDLE hBSock)
  676. {
  678. POP3SessionData *pPOPSD = (POP3SessionData *) hPOPSession;
  680. POP3MsgData *pPOPMD = UPopMessageFromIndex(pPOPSD, iMsgIndex - 1);
  682. if (pPOPMD == NULL) {
  683. UPopSendErrorResponse(hBSock, ERR_MSG_NOT_IN_RANGE, pPOPSD->iTimeout);
  685. ErrSetErrorCode(ERR_MSG_NOT_IN_RANGE);
  686. return (ERR_MSG_NOT_IN_RANGE);
  687. }
  689. if (pPOPMD->ulFlags & POPF_MSG_DELETED) {
  690. UPopSendErrorResponse(hBSock, ERR_MSG_DELETED, pPOPSD->iTimeout);
  692. ErrSetErrorCode(ERR_MSG_DELETED);
  693. return (ERR_MSG_DELETED);
  694. }
  696. char szMsgFilePath[SYS_MAX_PATH] = "";
  698. UsrGetMailboxPath(pPOPSD->pUI, szMsgFilePath, sizeof(szMsgFilePath), 1);
  700. StrNCat(szMsgFilePath, pPOPMD->szMsgName, sizeof(szMsgFilePath));
  702. char szResponse[256] = "";
  704. sprintf(szResponse, "+OK %lu bytes", pPOPMD->ulMsgSize);
  706. if (BSckSendString(hBSock, szResponse, pPOPSD->iTimeout) < 0)
  707. return (ErrGetErrorCode());
  709. if ((pPOPMD->ulMsgSize > 0) &&
  710.     (SysSendFile(BSckGetAttachedSocket(hBSock), szMsgFilePath, 0, (unsigned long) -1,
  711.  pPOPSD->iTimeout) < 0))
  712. return (ErrGetErrorCode());
  714. if (BSckSendString(hBSock, ".", pPOPSD->iTimeout) < 0)
  715. return (ErrGetErrorCode());
  717. pPOPSD->iLastAccessed = iMsgIndex;
  719. pPOPMD->ulFlags |= POPF_MSG_SENT;
  721. return (0);
  723. }
  725. int UPopSessionTopMsg(POP3_HANDLE hPOPSession, int iMsgIndex, int iNumLines, BSOCK_HANDLE hBSock)
  726. {
  728. POP3SessionData *pPOPSD = (POP3SessionData *) hPOPSession;
  730. POP3MsgData *pPOPMD = UPopMessageFromIndex(pPOPSD, iMsgIndex - 1);
  732. if (pPOPMD == NULL) {
  733. UPopSendErrorResponse(hBSock, ERR_MSG_NOT_IN_RANGE, pPOPSD->iTimeout);
  735. ErrSetErrorCode(ERR_MSG_NOT_IN_RANGE);
  736. return (ERR_MSG_NOT_IN_RANGE);
  737. }
  739. if (pPOPMD->ulFlags & POPF_MSG_DELETED) {
  740. UPopSendErrorResponse(hBSock, ERR_MSG_DELETED, pPOPSD->iTimeout);
  742. ErrSetErrorCode(ERR_MSG_DELETED);
  743. return (ERR_MSG_DELETED);
  744. }
  746. char szMsgFilePath[SYS_MAX_PATH] = "";
  748. UsrGetMailboxPath(pPOPSD->pUI, szMsgFilePath, sizeof(szMsgFilePath), 1);
  750. StrNCat(szMsgFilePath, pPOPMD->szMsgName, sizeof(szMsgFilePath));
  752. FILE *pMsgFile = fopen(szMsgFilePath, "rb");
  754. if (pMsgFile == NULL) {
  755. UPopSendErrorResponse(hBSock, ERR_FILE_OPEN, pPOPSD->iTimeout);
  757. ErrSetErrorCode(ERR_FILE_OPEN);
  758. return (ERR_FILE_OPEN);
  759. }
  761. char szResponse[256] = "";
  763. sprintf(szResponse, "+OK message is %lu bytes", pPOPMD->ulMsgSize);
  765. if (BSckSendString(hBSock, szResponse, pPOPSD->iTimeout) < 0) {
  766. fclose(pMsgFile);
  767. return (ErrGetErrorCode());
  768. }
  770. bool bSendingMsg = false;
  771. char szMsgLine[2048] = "";
  773. while (MscGetString(pMsgFile, szMsgLine, sizeof(szMsgLine) - 1) != NULL) {
  774. if (bSendingMsg && (--iNumLines < 0))
  775. break;
  777. if (BSckSendString(hBSock, szMsgLine, pPOPSD->iTimeout) < 0) {
  778. fclose(pMsgFile);
  779. return (ErrGetErrorCode());
  780. }
  782. if (!bSendingMsg && (strlen(szMsgLine) == 0))
  783. bSendingMsg = true;
  785. if (SvrInShutdown()) {
  786. fclose(pMsgFile);
  787. ErrSetErrorCode(ERR_SERVER_SHUTDOWN);
  788. return (ERR_SERVER_SHUTDOWN);
  789. }
  791. }
  793. fclose(pMsgFile);
  795. if (BSckSendString(hBSock, ".", pPOPSD->iTimeout) < 0)
  796. return (ErrGetErrorCode());
  798. pPOPSD->iLastAccessed = iMsgIndex;
  800. pPOPMD->ulFlags |= POPF_MSG_TOP;
  802. return (0);
  804. }
  806. int UPopSaveUserIP(POP3_HANDLE hPOPSession)
  807. {
  809. POP3SessionData *pPOPSD = (POP3SessionData *) hPOPSession;
  810. char szIpFilePath[SYS_MAX_PATH] = "";
  812. UPopGetIpLogFilePath(pPOPSD->pUI, szIpFilePath, sizeof(szIpFilePath));
  814. char szIP[128] = "???.???.???.???";
  816. SysInetNToA(pPOPSD->PeerInfo, szIP);
  818. FILE *pIpFile = fopen(szIpFilePath, "wt");
  820. if (pIpFile == NULL) {
  821. ErrSetErrorCode(ERR_FILE_CREATE, szIpFilePath);
  822. return (ERR_FILE_CREATE);
  823. }
  825. fprintf(pIpFile, "%sn", szIP);
  827. fclose(pIpFile);
  829. return (0);
  831. }
  833. static int UPopCheckResponse(const char *pszResponse, char *pszMessage)
  834. {
  836. if (strnicmp(pszResponse, "+OK", 3) == 0) {
  837. if (pszMessage != NULL)
  838. strcpy(pszMessage, pszResponse + ((pszResponse[3] == ' ') ? 4 : 3));
  840. return (0);
  841. } else if (strnicmp(pszResponse, "-ERR", 4) == 0) {
  842. if (pszMessage != NULL)
  843. strcpy(pszMessage, pszResponse + ((pszResponse[4] == ' ') ? 5 : 4));
  845. ErrSetErrorCode(ERR_BAD_SERVER_RESPONSE, pszResponse);
  847. return (ERR_BAD_SERVER_RESPONSE);
  848. }
  850. ErrSetErrorCode(ERR_INVALID_POP3_RESPONSE, pszResponse);
  852. return (ERR_INVALID_POP3_RESPONSE);
  854. }
  856. static int UPopGetResponse(BSOCK_HANDLE hBSock, char *pszResponse, int iMaxChars, int iTimeout)
  857. {
  859. if (BSckGetString(hBSock, pszResponse, iMaxChars, iTimeout) == NULL)
  860. return (ErrGetErrorCode());
  862. return (UPopCheckResponse(pszResponse));
  864. }
  866. static char *UPopExtractServerTimeStamp(char const *pszResponse, char *pszTimeStamp,
  867. int iMaxTimeStamp)
  868. {
  870. char const *pszStartTS = strchr(pszResponse, '<');
  871. char const *pszEndTS = strchr(pszResponse, '>');
  873. if ((pszStartTS == NULL) || (pszEndTS == NULL))
  874. return (NULL);
  876. int iLengthTS = (int) (pszEndTS - pszStartTS) + 1;
  878. if (iLengthTS <= 0)
  879. return (NULL);
  881. iLengthTS = Min(iLengthTS, iMaxTimeStamp - 1);
  883. strncpy(pszTimeStamp, pszStartTS, iLengthTS);
  884. pszTimeStamp[iLengthTS] = '';
  886. return (pszTimeStamp);
  888. }
  890. static int UPopSendCommand(BSOCK_HANDLE hBSock, const char *pszCommand, char *pszResponse,
  891.    int iMaxChars, int iTimeout)
  892. {
  894. if (BSckSendString(hBSock, pszCommand, iTimeout) <= 0)
  895. return (ErrGetErrorCode());
  897. if (UPopGetResponse(hBSock, pszResponse, iMaxChars, iTimeout) < 0)
  898. return (ErrGetErrorCode());
  900. return (0);
  902. }
  904. static int UPopDoClearTextAuth(BSOCK_HANDLE hBSock, const char *pszUsername,
  905.        const char *pszPassword, char *pszRespBuffer, int iMaxRespChars)
  906. {
  908. ///////////////////////////////////////////////////////////////////////////////
  909. //  Send USER and read result
  910. ///////////////////////////////////////////////////////////////////////////////
  911. SysSNPrintf(pszRespBuffer, iMaxRespChars - 1, "USER %s", pszUsername);
  913. if (UPopSendCommand(hBSock, pszRespBuffer, pszRespBuffer, iMaxRespChars) < 0)
  914. return (ErrGetErrorCode());
  916. ///////////////////////////////////////////////////////////////////////////////
  917. //  Send PASS and read result
  918. ///////////////////////////////////////////////////////////////////////////////
  919. SysSNPrintf(pszRespBuffer, iMaxRespChars - 1, "PASS %s", pszPassword);
  921. if (UPopSendCommand(hBSock, pszRespBuffer, pszRespBuffer, iMaxRespChars) < 0)
  922. return (ErrGetErrorCode());
  924. return (0);
  926. }
  928. static int UPopDoAPOPAuth(BSOCK_HANDLE hBSock, const char *pszUsername,
  929.   const char *pszPassword, char const *pszTimeStamp,
  930.   char *pszRespBuffer, int iMaxRespChars)
  931. {
  933. ///////////////////////////////////////////////////////////////////////////////
  934. //  Perform APOP authentication
  935. ///////////////////////////////////////////////////////////////////////////////
  936. char *pszHash = StrSprint("%s%s", pszTimeStamp, pszPassword);
  938. if (pszHash == NULL)
  939. return (ErrGetErrorCode());
  941. char szMD5[128] = "";
  943. do_md5_string(pszHash, strlen(pszHash), szMD5);
  945. SysFree(pszHash);
  947. ///////////////////////////////////////////////////////////////////////////////
  948. //  Send APOP and read result
  949. ///////////////////////////////////////////////////////////////////////////////
  950. SysSNPrintf(pszRespBuffer, iMaxRespChars - 1, "APOP %s %s", pszUsername, szMD5);
  952. if (UPopSendCommand(hBSock, pszRespBuffer, pszRespBuffer, iMaxRespChars) < 0)
  953. return (ErrGetErrorCode());
  955. return (0);
  957. }
  959. static BSOCK_HANDLE UPopCreateChannel(const char *pszServer, const char *pszUsername,
  960.       const char *pszPassword, bool bTryAuthAPOP)
  961. {
  963. SYS_INET_ADDR SvrAddr;
  965. if (MscGetServerAddress(pszServer, SvrAddr, STD_POP3_PORT) < 0)
  966. return (INVALID_BSOCK_HANDLE);
  968. SYS_SOCKET SockFD = SysCreateSocket(AF_INET, SOCK_STREAM, 0);
  970. if (SockFD == SYS_INVALID_SOCKET)
  971. return (INVALID_BSOCK_HANDLE);
  973. if (SysConnect(SockFD, &SvrAddr, sizeof(SvrAddr), STD_POP3_TIMEOUT) < 0) {
  974. SysCloseSocket(SockFD);
  975. return (INVALID_BSOCK_HANDLE);
  976. }
  978. BSOCK_HANDLE hBSock = BSckAttach(SockFD);
  980. if (hBSock == INVALID_BSOCK_HANDLE) {
  981. SysCloseSocket(SockFD);
  982. return (INVALID_BSOCK_HANDLE);
  983. }
  984. ///////////////////////////////////////////////////////////////////////////////
  985. //  Read welcome message
  986. ///////////////////////////////////////////////////////////////////////////////
  987. char szRTXBuffer[2048] = "";
  989. if (UPopGetResponse(hBSock, szRTXBuffer, sizeof(szRTXBuffer) - 1) < 0) {
  990. UPopCloseChannel(hBSock);
  991. return (INVALID_BSOCK_HANDLE);
  992. }
  993. ///////////////////////////////////////////////////////////////////////////////
  994. //  Extract TimeStamp from server respose ( if any )
  995. ///////////////////////////////////////////////////////////////////////////////
  996. char szTimeStamp[256] = "";
  998. if (!bTryAuthAPOP ||
  999.     (MscExtractServerTimeStamp(szRTXBuffer, szTimeStamp, sizeof(szTimeStamp) - 1) ==
  1000.      NULL)) {
  1001. ///////////////////////////////////////////////////////////////////////////////
  1002. //  Try clear text authentication
  1003. ///////////////////////////////////////////////////////////////////////////////
  1004. if (UPopDoClearTextAuth(hBSock, pszUsername, pszPassword, szRTXBuffer,
  1005. sizeof(szRTXBuffer) - 1) < 0) {
  1006. UPopCloseChannel(hBSock);
  1007. return (INVALID_BSOCK_HANDLE);
  1008. }
  1009. } else {
  1010. ///////////////////////////////////////////////////////////////////////////////
  1011. //  Try APOP authentication first
  1012. ///////////////////////////////////////////////////////////////////////////////
  1013. int iApopAuthResult = UPopDoAPOPAuth(hBSock, pszUsername, pszPassword,
  1014.      szTimeStamp, szRTXBuffer,
  1015.      sizeof(szRTXBuffer) - 1);
  1017. if (iApopAuthResult < 0) {
  1018. if (iApopAuthResult != ERR_BAD_SERVER_RESPONSE) {
  1019. UPopCloseChannel(hBSock);
  1020. return (INVALID_BSOCK_HANDLE);
  1021. }
  1022. ///////////////////////////////////////////////////////////////////////////////
  1023. //  Try clear text authentication
  1024. ///////////////////////////////////////////////////////////////////////////////
  1025. if (UPopDoClearTextAuth(hBSock, pszUsername, pszPassword, szRTXBuffer,
  1026. sizeof(szRTXBuffer) - 1) < 0) {
  1027. UPopCloseChannel(hBSock);
  1028. return (INVALID_BSOCK_HANDLE);
  1029. }
  1030. }
  1031. }
  1033. return (hBSock);
  1035. }
  1037. static int UPopCloseChannel(BSOCK_HANDLE hBSock, int iHardClose)
  1038. {
  1040. if (!iHardClose) {
  1041. ///////////////////////////////////////////////////////////////////////////////
  1042. //  Send QUIT and read result
  1043. ///////////////////////////////////////////////////////////////////////////////
  1044. char szRTXBuffer[2048] = "";
  1046. if (UPopSendCommand(hBSock, "QUIT", szRTXBuffer, sizeof(szRTXBuffer) - 1) < 0) {
  1047. BSckDetach(hBSock, 1);
  1048. return (ErrGetErrorCode());
  1049. }
  1050. }
  1052. BSckDetach(hBSock, 1);
  1054. return (0);
  1056. }
  1058. static int UPopGetMailboxStatus(BSOCK_HANDLE hBSock, int &iMsgCount, unsigned long &ulMailboxSize)
  1059. {
  1061. char szRTXBuffer[2048] = "";
  1063. if (UPopSendCommand(hBSock, "STAT", szRTXBuffer, sizeof(szRTXBuffer) - 1) < 0)
  1064. return (ErrGetErrorCode());
  1066. if (sscanf(szRTXBuffer, "+OK %d %lu", &iMsgCount, &ulMailboxSize) != 2) {
  1067. ErrSetErrorCode(ERR_INVALID_POP3_RESPONSE, szRTXBuffer);
  1068. return (ERR_INVALID_POP3_RESPONSE);
  1069. }
  1071. return (0);
  1073. }
  1075. static int UPopRetrieveMessage(BSOCK_HANDLE hBSock, int iMsgIndex, const char *pszFileName,
  1076.        unsigned long *pulMsgSize)
  1077. {
  1079. FILE *pMsgFile = fopen(pszFileName, "wb");
  1081. if (pMsgFile == NULL) {
  1082. ErrSetErrorCode(ERR_FILE_CREATE);
  1083. return (ERR_FILE_CREATE);
  1084. }
  1086. char szRTXBuffer[2048] = "";
  1088. sprintf(szRTXBuffer, "RETR %d", iMsgIndex);
  1090. if (UPopSendCommand(hBSock, szRTXBuffer, szRTXBuffer, sizeof(szRTXBuffer) - 1) < 0) {
  1091. fclose(pMsgFile);
  1092. return (ErrGetErrorCode());
  1093. }
  1095. int iLineLength = 0;
  1096. int iGotNL;
  1097. int iGotNLPrev = 1;
  1098. unsigned long ulMsgSize = 0;
  1100. for (;;) {
  1101. if (BSckGetString(hBSock, szRTXBuffer, sizeof(szRTXBuffer) - 3,
  1102.   STD_POP3_TIMEOUT, &iLineLength, &iGotNL) == NULL) {
  1103. fclose(pMsgFile);
  1105. ErrSetErrorCode(ERR_POP3_RETR_BROKEN);
  1106. return (ERR_POP3_RETR_BROKEN);
  1107. }
  1108. ///////////////////////////////////////////////////////////////////////////////
  1109. //  Check end of data condition
  1110. ///////////////////////////////////////////////////////////////////////////////
  1111. if (iGotNL && iGotNLPrev && (strcmp(szRTXBuffer, ".") == 0))
  1112. break;
  1114. ///////////////////////////////////////////////////////////////////////////////
  1115. //  Correctly terminate the line
  1116. ///////////////////////////////////////////////////////////////////////////////
  1117. if (iGotNL)
  1118. memcpy(szRTXBuffer + iLineLength, "rn", 3), iLineLength += 2;
  1120. if (!fwrite(szRTXBuffer, iLineLength, 1, pMsgFile)) {
  1121. fclose(pMsgFile);
  1123. ErrSetErrorCode(ERR_FILE_WRITE, pszFileName);
  1124. return (ERR_FILE_WRITE);
  1125. }
  1127. ulMsgSize += (unsigned long) iLineLength;
  1129. iGotNLPrev = iGotNL;
  1130. }
  1132. fclose(pMsgFile);
  1134. if (pulMsgSize != NULL)
  1135. *pulMsgSize = ulMsgSize;
  1137. return (0);
  1139. }
  1141. static int UPopDeleteMessage(BSOCK_HANDLE hBSock, int iMsgIndex)
  1142. {
  1144. char szRTXBuffer[2048] = "";
  1146. sprintf(szRTXBuffer, "DELE %d", iMsgIndex);
  1148. if (UPopSendCommand(hBSock, szRTXBuffer, szRTXBuffer, sizeof(szRTXBuffer) - 1) < 0)
  1149. return (ErrGetErrorCode());
  1151. return (0);
  1153. }
  1155. int UPopSyncRemoteLink(const char *pszSyncAddr, const char *pszRmtServer, const char *pszRmtName,
  1156.        const char *pszRmtPassword, PopSyncReport * pSRep,
  1157.        const char *pszFetchHdrTags, const char *pszAuthType,
  1158.        const char *pszErrorAccount)
  1159. {
  1160. ///////////////////////////////////////////////////////////////////////////////
  1161. //  Connection to POP3 server
  1162. ///////////////////////////////////////////////////////////////////////////////
  1163. BSOCK_HANDLE hBSock = UPopCreateChannel(pszRmtServer, pszRmtName, pszRmtPassword,
  1164. (stricmp(pszAuthType, AUTH_TYPE_APOP) ==
  1165.  0) ? true : false);
  1167. if (hBSock == INVALID_BSOCK_HANDLE)
  1168. return (ErrGetErrorCode());
  1170. ///////////////////////////////////////////////////////////////////////////////
  1171. //  Get mailbox status
  1172. ///////////////////////////////////////////////////////////////////////////////
  1173. int iMsgCount = 0;
  1174. unsigned long ulMailboxSize = 0;
  1176. if (UPopGetMailboxStatus(hBSock, iMsgCount, ulMailboxSize) < 0) {
  1177. ErrorPush();
  1178. UPopCloseChannel(hBSock);
  1179. return (ErrorPop());
  1180. }
  1181. ///////////////////////////////////////////////////////////////////////////////
  1182. //  Initialize the report structure with current mailbox informations
  1183. ///////////////////////////////////////////////////////////////////////////////
  1184. pSRep->iMsgSync = 0;
  1185. pSRep->iMsgErr = iMsgCount;
  1186. pSRep->ulSizeSync = 0;
  1187. pSRep->ulSizeErr = ulMailboxSize;
  1189. if (iMsgCount > 0) {
  1190. ///////////////////////////////////////////////////////////////////////////////
  1191. //  Retrieve messages
  1192. ///////////////////////////////////////////////////////////////////////////////
  1193. char szMsgFileName[SYS_MAX_PATH] = "";
  1195. SysGetTmpFile(szMsgFileName);
  1197. for (int ii = 0; ii < iMsgCount; ii++) {
  1198. ///////////////////////////////////////////////////////////////////////////////
  1199. //  Get the message
  1200. ///////////////////////////////////////////////////////////////////////////////
  1201. unsigned long ulMsgSize;
  1203. if (UPopRetrieveMessage(hBSock, ii + 1, szMsgFileName, &ulMsgSize) < 0) {
  1204. ErrorPush();
  1205. CheckRemoveFile(szMsgFileName);
  1206. UPopCloseChannel(hBSock);
  1207. return (ErrorPop());
  1208. }
  1209. ///////////////////////////////////////////////////////////////////////////////
  1210. //  Spool deliver fetched message
  1211. ///////////////////////////////////////////////////////////////////////////////
  1212. if (USmlDeliverFetchedMsg(pszSyncAddr, pszFetchHdrTags, szMsgFileName) <
  1213.     0) {
  1214. ///////////////////////////////////////////////////////////////////////////////
  1215. //  If there's an error ( catch errors ) account try to deliver to this one
  1216. ///////////////////////////////////////////////////////////////////////////////
  1217. if ((pszErrorAccount != NULL) &&
  1218.     (USmlDeliverFetchedMsg(pszErrorAccount, NULL, szMsgFileName)
  1219.      == 0)) {
  1220. ///////////////////////////////////////////////////////////////////////////////
  1221. //  Delete remote message only if successfully delivered
  1222. ///////////////////////////////////////////////////////////////////////////////
  1223. UPopDeleteMessage(hBSock, ii + 1);
  1225. }
  1227. } else {
  1228. ///////////////////////////////////////////////////////////////////////////////
  1229. //  Delete remote message only if successfully delivered
  1230. ///////////////////////////////////////////////////////////////////////////////
  1231. UPopDeleteMessage(hBSock, ii + 1);
  1233. pSRep->iMsgSync++;
  1234. pSRep->ulSizeSync += ulMsgSize;
  1235. }
  1237. SysRemove(szMsgFileName);
  1239. if (SvrInShutdown()) {
  1240. UPopCloseChannel(hBSock);
  1242. ErrSetErrorCode(ERR_SERVER_SHUTDOWN);
  1243. return (ERR_SERVER_SHUTDOWN);
  1244. }
  1245. }
  1246. }
  1247. ///////////////////////////////////////////////////////////////////////////////
  1248. //  Disconnect from POP3 server
  1249. ///////////////////////////////////////////////////////////////////////////////
  1250. UPopCloseChannel(hBSock);
  1252. ///////////////////////////////////////////////////////////////////////////////
  1253. //  Update report struct to reflect final status
  1254. ///////////////////////////////////////////////////////////////////////////////
  1255. pSRep->iMsgErr -= pSRep->iMsgSync;
  1256. pSRep->ulSizeErr =
  1257.     (pSRep->ulSizeErr > pSRep->ulSizeSync) ? (pSRep->ulSizeErr - pSRep->ulSizeSync) : 0;
  1259. return (0);
  1261. }
  1263. static int UPopGetIpLogFilePath(UserInfo * pUI, char *pszFilePath, int iMaxPath)
  1264. {
  1266. UsrGetUserPath(pUI, pszFilePath, iMaxPath, 1);
  1268. StrNCat(pszFilePath, POP3_IP_LOGFILE, iMaxPath);
  1270. return (0);
  1272. }
  1274. int UPopUserIpCheck(UserInfo * pUI, SYS_INET_ADDR const *pPeerInfo, unsigned int uExpireTime)
  1275. {
  1277. char szIpFilePath[SYS_MAX_PATH] = "";
  1279. UPopGetIpLogFilePath(pUI, szIpFilePath, sizeof(szIpFilePath));
  1281. ///////////////////////////////////////////////////////////////////////////////
  1282. //  Load IP log file info and do expire check
  1283. ///////////////////////////////////////////////////////////////////////////////
  1284. SYS_FILE_INFO FI;
  1286. if ((SysGetFileInfo(szIpFilePath, FI) < 0) ||
  1287.     ((time_t) (FI.tMod + uExpireTime) < time(NULL))) {
  1288. ErrSetErrorCode(ERR_NO_POP3_IP);
  1289. return (ERR_NO_POP3_IP);
  1290. }
  1291. ///////////////////////////////////////////////////////////////////////////////
  1292. //  Load IP from file
  1293. ///////////////////////////////////////////////////////////////////////////////
  1294. FILE *pIpFile = fopen(szIpFilePath, "rt");
  1296. if (pIpFile == NULL) {
  1297. ErrSetErrorCode(ERR_NO_POP3_IP);
  1298. return (ERR_NO_POP3_IP);
  1299. }
  1301. char szIP[128] = "";
  1303. MscFGets(szIP, sizeof(szIP) - 1, pIpFile);
  1305. fclose(pIpFile);
  1307. ///////////////////////////////////////////////////////////////////////////////
  1308. //  Do IP matching
  1309. ///////////////////////////////////////////////////////////////////////////////
  1310. NET_ADDRESS PrevAddr;
  1311. NET_ADDRESS CurrAddr;
  1313. if ((SysInetAddr(szIP, PrevAddr) < 0) ||
  1314.     (SysGetAddrAddress(*pPeerInfo, CurrAddr) < 0) ||
  1315.     !SysSameAddress(PrevAddr, CurrAddr)) {
  1316. ErrSetErrorCode(ERR_NO_POP3_IP);
  1317. return (ERR_NO_POP3_IP);
  1318. }
  1320. return (0);
  1322. }
  1324. int UPopGetLastLoginInfo(UserInfo *pUI, PopLastLoginInfo *pInfo)
  1325. {
  1327. SYS_FILE_INFO FI;
  1328. char szIpFilePath[SYS_MAX_PATH] = "";
  1330. UPopGetIpLogFilePath(pUI, szIpFilePath, sizeof(szIpFilePath));
  1331. if (SysGetFileInfo(szIpFilePath, FI) < 0)
  1332. return (ErrGetErrorCode());
  1334. pInfo->LTime = FI.tMod;
  1336. ///////////////////////////////////////////////////////////////////////////////
  1337. //  Load IP from file
  1338. ///////////////////////////////////////////////////////////////////////////////
  1339. FILE *pIpFile = fopen(szIpFilePath, "rt");
  1341. if (pIpFile == NULL) {
  1342. ErrSetErrorCode(ERR_NO_POP3_IP);
  1343. return (ERR_NO_POP3_IP);
  1344. }
  1346. char szIP[128] = "";
  1348. MscFGets(szIP, sizeof(szIP) - 1, pIpFile);
  1350. fclose(pIpFile);
  1352. NET_ADDRESS NetAddr;
  1354. if (SysInetAddr(szIP, NetAddr) < 0)
  1355. return (ErrGetErrorCode());
  1357. return (SysSetupAddress(pInfo->Address, AF_INET, NetAddr, 0));
  1359. }