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

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

Email服务器

开发平台：

Visual C++

POP3Svr.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 "StrUtils.h"
  32. #include "MD5.h"
  33. #include "SvrUtils.h"
  34. #include "UsrUtils.h"
  35. #include "UsrAuth.h"
  36. #include "POP3Svr.h"
  37. #include "POP3Utils.h"
  38. #include "MessQueue.h"
  39. #include "MailDomains.h"
  40. #include "MailConfig.h"
  41. #include "AppDefines.h"
  42. #include "MailSvr.h"
  44. #define POP3SRV_ACCEPT_TIMEOUT  4
  45. #define STD_POP3_TIMEOUT        30
  46. #define POP3_LISTEN_SIZE        64
  47. #define POP3_WAIT_SLEEP         2
  48. #define MAX_CLIENTS_WAIT        300
  49. #define POP3_IPMAP_FILE         "pop3.ipmap.tab"
  50. #define POP3_LOG_FILE           "pop3"
  51. #define POP3_SERVER_NAME        "[" APP_NAME_VERSION_STR " POP3 Server]"
  53. enum POP3States {
  54. stateInit,
  55. stateUser,
  56. stateLogged,
  58. stateExit
  59. };
  61. struct POP3Session {
  62. int iPOP3State;
  63. SHB_HANDLE hShbPOP3;
  64. POP3Config *pPOP3Cfg;
  65. SVRCFG_HANDLE hSvrConfig;
  66. int iBadLoginWait;
  67. SYS_INET_ADDR PeerInfo;
  68. char szSvrFQDN[MAX_HOST_NAME];
  69. char szSvrDomain[MAX_HOST_NAME];
  70. char szUser[MAX_ADDR_NAME];
  71. char szPassword[256];
  72. POP3_HANDLE hPOPSession;
  73. char szTimeStamp[256];
  74. };
  76. static POP3Config *POP3GetConfigCopy(SHB_HANDLE hShbPOP3);
  77. static int POP3ThreadCountAdd(long lCount, SHB_HANDLE hShbPOP3, POP3Config * pPOP3Cfg = NULL);
  78. static int POP3LogEnabled(SHB_HANDLE hShbPOP3, POP3Config * pPOP3Cfg = NULL);
  79. static int POP3CheckPeerIP(SYS_SOCKET SockFD);
  80. static unsigned int POP3ClientThread(void *pThreadData);
  81. static int POP3CheckSysResources(SVRCFG_HANDLE hSvrConfig);
  82. static int POP3InitSession(SHB_HANDLE hShbPOP3, BSOCK_HANDLE hBSock, POP3Session & POP3S);
  83. static int POP3LogSession(POP3Session & POP3S);
  84. static int POP3HandleSession(SHB_HANDLE hShbPOP3, BSOCK_HANDLE hBSock);
  85. static void POP3ClearSession(POP3Session & POP3S);
  86. static int POP3HandleCommand(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S);
  87. static int POP3HandleCmd_USER(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S);
  88. static int POP3HandleBadLogin(BSOCK_HANDLE hBSock, POP3Session & POP3S);
  89. static int POP3HandleCmd_PASS(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S);
  90. static int POP3HandleCmd_APOP(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S);
  91. static int POP3HandleCmd_STAT(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S);
  92. static int POP3HandleCmd_LIST(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S);
  93. static int POP3HandleCmd_UIDL(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S);
  94. static int POP3HandleCmd_QUIT(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S);
  95. static int POP3HandleCmd_RETR(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S);
  96. static int POP3HandleCmd_TOP(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S);
  97. static int POP3HandleCmd_DELE(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S);
  98. static int POP3HandleCmd_NOOP(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S);
  99. static int POP3HandleCmd_LAST(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S);
  100. static int POP3HandleCmd_RSET(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S);
  102. static POP3Config *POP3GetConfigCopy(SHB_HANDLE hShbPOP3)
  103. {
  105. POP3Config *pPOP3Cfg = (POP3Config *) ShbLock(hShbPOP3);
  107. if (pPOP3Cfg == NULL)
  108. return (NULL);
  110. POP3Config *pPOP3CfgCopy = (POP3Config *) SysAlloc(sizeof(POP3Config));
  112. if (pPOP3CfgCopy != NULL)
  113. memcpy(pPOP3CfgCopy, pPOP3Cfg, sizeof(POP3Config));
  115. ShbUnlock(hShbPOP3);
  117. return (pPOP3CfgCopy);
  119. }
  121. static int POP3ThreadCountAdd(long lCount, SHB_HANDLE hShbPOP3, POP3Config * pPOP3Cfg)
  122. {
  124. int iDoUnlock = 0;
  126. if (pPOP3Cfg == NULL) {
  127. if ((pPOP3Cfg = (POP3Config *) ShbLock(hShbPOP3)) == NULL)
  128. return (ErrGetErrorCode());
  130. ++iDoUnlock;
  131. }
  133. if ((pPOP3Cfg->lThreadCount + lCount) > pPOP3Cfg->lMaxThreads) {
  134. if (iDoUnlock)
  135. ShbUnlock(hShbPOP3);
  137. ErrSetErrorCode(ERR_SERVER_BUSY);
  138. return (ERR_SERVER_BUSY);
  139. }
  141. pPOP3Cfg->lThreadCount += lCount;
  143. if (iDoUnlock)
  144. ShbUnlock(hShbPOP3);
  146. return (0);
  148. }
  150. static int POP3LogEnabled(SHB_HANDLE hShbPOP3, POP3Config * pPOP3Cfg)
  151. {
  153. int iDoUnlock = 0;
  155. if (pPOP3Cfg == NULL) {
  156. if ((pPOP3Cfg = (POP3Config *) ShbLock(hShbPOP3)) == NULL)
  157. return (ErrGetErrorCode());
  159. ++iDoUnlock;
  160. }
  162. unsigned long ulFlags = pPOP3Cfg->ulFlags;
  164. if (iDoUnlock)
  165. ShbUnlock(hShbPOP3);
  167. return ((ulFlags & POP3F_LOG_ENABLED) ? 1 : 0);
  169. }
  171. static int POP3CheckPeerIP(SYS_SOCKET SockFD)
  172. {
  174. char szIPMapFile[SYS_MAX_PATH] = "";
  176. CfgGetRootPath(szIPMapFile, sizeof(szIPMapFile));
  177. StrNCat(szIPMapFile, POP3_IPMAP_FILE, sizeof(szIPMapFile));
  179. if (SysExistFile(szIPMapFile)) {
  180. SYS_INET_ADDR PeerInfo;
  182. if (SysGetPeerInfo(SockFD, PeerInfo) < 0)
  183. return (ErrGetErrorCode());
  185. if (MscCheckAllowedIP(szIPMapFile, PeerInfo, true) < 0)
  186. return (ErrGetErrorCode());
  187. }
  189. return (0);
  191. }
  193. static unsigned int POP3ClientThread(void *pThreadData)
  194. {
  196. SYS_SOCKET SockFD = (SYS_SOCKET) (unsigned long) pThreadData;
  198. ///////////////////////////////////////////////////////////////////////////////
  199. //  Link socket to the bufferer
  200. ///////////////////////////////////////////////////////////////////////////////
  201. BSOCK_HANDLE hBSock = BSckAttach(SockFD);
  203. if (hBSock == INVALID_BSOCK_HANDLE) {
  204. ErrorPush();
  205. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  206. SysCloseSocket(SockFD);
  207. return (ErrorPop());
  208. }
  209. ///////////////////////////////////////////////////////////////////////////////
  210. //  Check IP permission
  211. ///////////////////////////////////////////////////////////////////////////////
  212. if (POP3CheckPeerIP(SockFD) < 0) {
  213. ErrorPush();
  215. UPopSendErrorResponse(hBSock, ErrGetErrorCode(), STD_POP3_TIMEOUT);
  217. BSckDetach(hBSock, 1);
  218. return (ErrorPop());
  219. }
  220. ///////////////////////////////////////////////////////////////////////////////
  221. //  Increase threads count
  222. ///////////////////////////////////////////////////////////////////////////////
  223. if (POP3ThreadCountAdd(+1, hShbPOP3) < 0) {
  224. ErrorPush();
  226. UPopSendErrorResponse(hBSock, ErrGetErrorCode(), STD_POP3_TIMEOUT);
  228. BSckDetach(hBSock, 1);
  229. return (ErrorPop());
  230. }
  232. ///////////////////////////////////////////////////////////////////////////////
  233. //  Handle client session
  234. ///////////////////////////////////////////////////////////////////////////////
  235. POP3HandleSession(hShbPOP3, hBSock);
  237. ///////////////////////////////////////////////////////////////////////////////
  238. //  Decrease thread count
  239. ///////////////////////////////////////////////////////////////////////////////
  240. POP3ThreadCountAdd(-1, hShbPOP3);
  242. ///////////////////////////////////////////////////////////////////////////////
  243. //  Unlink socket to the bufferer and close it
  244. ///////////////////////////////////////////////////////////////////////////////
  245. BSckDetach(hBSock, 1);
  247. return (0);
  249. }
  251. unsigned int POP3ThreadProc(void *pThreadData)
  252. {
  254. POP3Config *pPOP3Cfg = (POP3Config *) ShbLock(hShbPOP3);
  256. if (pPOP3Cfg == NULL) {
  257. ErrorPush();
  258. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  259. return (ErrorPop());
  260. }
  262. int iNumSockFDs = 0;
  263. SYS_SOCKET SockFDs[MAX_POP3_ACCEPT_ADDRESSES];
  265. if (MscCreateServerSockets(pPOP3Cfg->iNumAddr, pPOP3Cfg->SvrAddr, pPOP3Cfg->iPort,
  266.    POP3_LISTEN_SIZE, SockFDs, iNumSockFDs) < 0) {
  267. ErrorPush();
  268. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  269. ShbUnlock(hShbPOP3);
  270. return (ErrorPop());
  271. }
  273. ShbUnlock(hShbPOP3);
  275. SysLogMessage(LOG_LEV_MESSAGE, "%s startedn", POP3_SERVER_NAME);
  277. for (;;) {
  278. int iNumConnSockFD = 0;
  279. SYS_SOCKET ConnSockFD[MAX_POP3_ACCEPT_ADDRESSES];
  281. if (MscAcceptServerConnection(SockFDs, iNumSockFDs, ConnSockFD,
  282.       iNumConnSockFD, POP3SRV_ACCEPT_TIMEOUT) < 0) {
  283. unsigned long ulFlags = POP3F_STOP_SERVER;
  285. pPOP3Cfg = (POP3Config *) ShbLock(hShbPOP3);
  287. if (pPOP3Cfg != NULL)
  288. ulFlags = pPOP3Cfg->ulFlags;
  290. ShbUnlock(hShbPOP3);
  292. if (ulFlags & POP3F_STOP_SERVER)
  293. break;
  294. else
  295. continue;
  296. }
  298. for (int ss = 0; ss < iNumConnSockFD; ss++) {
  299. SYS_THREAD hClientThread =
  300.     SysCreateServiceThread(POP3ClientThread, ConnSockFD[ss]);
  302. if (hClientThread != SYS_INVALID_THREAD)
  303. SysCloseThread(hClientThread, 0);
  304. else
  305. SysCloseSocket(ConnSockFD[ss]);
  307. }
  308. }
  310. for (int ss = 0; ss < iNumSockFDs; ss++)
  311. SysCloseSocket(SockFDs[ss]);
  313. ///////////////////////////////////////////////////////////////////////////////
  314. //  Wait for client completion
  315. ///////////////////////////////////////////////////////////////////////////////
  316. for (int iTotalWait = 0; (iTotalWait < MAX_CLIENTS_WAIT); iTotalWait += POP3_WAIT_SLEEP) {
  317. pPOP3Cfg = (POP3Config *) ShbLock(hShbPOP3);
  319. if (pPOP3Cfg == NULL)
  320. break;
  322. long lThreadCount = pPOP3Cfg->lThreadCount;
  324. ShbUnlock(hShbPOP3);
  326. if (lThreadCount == 0)
  327. break;
  329. SysSleep(POP3_WAIT_SLEEP);
  330. }
  332. SysLogMessage(LOG_LEV_MESSAGE, "%s stoppedn", POP3_SERVER_NAME);
  334. return (0);
  336. }
  338. static int POP3CheckSysResources(SVRCFG_HANDLE hSvrConfig)
  339. {
  340. ///////////////////////////////////////////////////////////////////////////////
  341. //  Check virtual memory
  342. ///////////////////////////////////////////////////////////////////////////////
  343. int iMinValue = SvrGetConfigInt("Pop3MinVirtMemSpace", -1, hSvrConfig);
  345. if ((iMinValue > 0) && (SvrCheckVirtMemSpace(1024 * (unsigned long) iMinValue) < 0))
  346. return (ErrGetErrorCode());
  348. return (0);
  350. }
  352. static int POP3InitSession(SHB_HANDLE hShbPOP3, BSOCK_HANDLE hBSock, POP3Session & POP3S)
  353. {
  355. ZeroData(POP3S);
  356. POP3S.iPOP3State = stateInit;
  357. POP3S.hShbPOP3 = hShbPOP3;
  358. POP3S.hSvrConfig = INVALID_SVRCFG_HANDLE;
  359. POP3S.pPOP3Cfg = NULL;
  360. POP3S.hPOPSession = INVALID_POP3_HANDLE;
  362. if ((POP3S.hSvrConfig = SvrGetConfigHandle()) == INVALID_SVRCFG_HANDLE)
  363. return (ErrGetErrorCode());
  365. if ((POP3CheckSysResources(POP3S.hSvrConfig) < 0) ||
  366.     (SysGetPeerInfo(BSckGetAttachedSocket(hBSock), POP3S.PeerInfo) < 0)) {
  367. SvrReleaseConfigHandle(POP3S.hSvrConfig);
  368. return (ErrGetErrorCode());
  369. }
  370. ///////////////////////////////////////////////////////////////////////////////
  371. //  Get connection socket host name
  372. ///////////////////////////////////////////////////////////////////////////////
  373. char szIP[128] = "???.???.???.???";
  375. if (MscGetSockHost(BSckGetAttachedSocket(hBSock), POP3S.szSvrFQDN) < 0)
  376. StrSNCpy(POP3S.szSvrFQDN, SysInetNToA(POP3S.PeerInfo, szIP));
  377. else {
  378. ///////////////////////////////////////////////////////////////////////////////
  379. //  Try to get a valid domain from the FQDN
  380. ///////////////////////////////////////////////////////////////////////////////
  381. if (MDomGetClientDomain(POP3S.szSvrFQDN, POP3S.szSvrDomain,
  382. sizeof(POP3S.szSvrDomain) - 1) < 0)
  383. StrSNCpy(POP3S.szSvrDomain, POP3S.szSvrFQDN);
  384. }
  386. ///////////////////////////////////////////////////////////////////////////////
  387. //  If "POP3Domain" is defined, it's taken as default POP3 domain that means
  388. //  that users of such domain can log using only the name part of their email
  389. //  address
  390. ///////////////////////////////////////////////////////////////////////////////
  391. char *pszDefDomain = SvrGetConfigVar(POP3S.hSvrConfig, "POP3Domain");
  393. if (pszDefDomain != NULL) {
  394. StrSNCpy(POP3S.szSvrDomain, pszDefDomain);
  396. SysFree(pszDefDomain);
  397. }
  398. ///////////////////////////////////////////////////////////////////////////////
  399. //  As a last tentative We try to get "RootDomain" to set POP3 domain
  400. ///////////////////////////////////////////////////////////////////////////////
  401. if (IsEmptyString(POP3S.szSvrDomain)) {
  402. char *pszRootDomain = SvrGetConfigVar(POP3S.hSvrConfig, "RootDomain");
  404. if (pszRootDomain == NULL) {
  405. SvrReleaseConfigHandle(POP3S.hSvrConfig);
  406. ErrSetErrorCode(ERR_NO_DOMAIN);
  407. return (ERR_NO_DOMAIN);
  408. }
  410. StrSNCpy(POP3S.szSvrDomain, pszRootDomain);
  412. SysFree(pszRootDomain);
  413. }
  415. if ((POP3S.pPOP3Cfg = POP3GetConfigCopy(hShbPOP3)) == NULL) {
  416. SvrReleaseConfigHandle(POP3S.hSvrConfig);
  417. return (ErrGetErrorCode());
  418. }
  420. POP3S.iBadLoginWait = POP3S.pPOP3Cfg->iBadLoginWait;
  422. ///////////////////////////////////////////////////////////////////////////////
  423. //  Create timestamp for APOP command
  424. ///////////////////////////////////////////////////////////////////////////////
  425. sprintf(POP3S.szTimeStamp, "<%lu.%lu@%s>",
  426. (unsigned long) time(NULL), SysGetCurrentThreadId(), POP3S.szSvrDomain);
  428. return (0);
  430. }
  432. static int POP3LogSession(POP3Session & POP3S)
  433. {
  435. char szTime[256] = "";
  437. MscGetTimeNbrString(szTime, sizeof(szTime) - 1);
  439. RLCK_HANDLE hResLock = RLckLockEX(SVR_LOGS_DIR SYS_SLASH_STR POP3_LOG_FILE);
  441. if (hResLock == INVALID_RLCK_HANDLE)
  442. return (ErrGetErrorCode());
  444. char szIP[128] = "???.???.???.???";
  446. MscFileLog(POP3_LOG_FILE, ""%s""
  447.    "t"%s""
  448.    "t"%s""
  449.    "t"%s""
  450.    "t"%s""
  451.    "t"%s""
  452.    "n", POP3S.szSvrFQDN, POP3S.szSvrDomain, SysInetNToA(POP3S.PeerInfo, szIP),
  453.    szTime, POP3S.szUser, POP3S.szPassword);
  455. RLckUnlockEX(hResLock);
  457. return (0);
  459. }
  461. static int POP3HandleSession(SHB_HANDLE hShbPOP3, BSOCK_HANDLE hBSock)
  462. {
  464. ///////////////////////////////////////////////////////////////////////////////
  465. //  Session structure declaration and init
  466. ///////////////////////////////////////////////////////////////////////////////
  467. POP3Session POP3S;
  469. if (POP3InitSession(hShbPOP3, hBSock, POP3S) < 0) {
  470. ErrorPush();
  472. UPopSendErrorResponse(hBSock, ErrGetErrorCode(), STD_POP3_TIMEOUT);
  474. return (ErrorPop());
  475. }
  477. char szIP[128] = "???.???.???.???";
  479. SysLogMessage(LOG_LEV_MESSAGE, "POP3 client connection from [%s]n",
  480.       SysInetNToA(POP3S.PeerInfo, szIP));
  482. ///////////////////////////////////////////////////////////////////////////////
  483. //  Send welcome message
  484. ///////////////////////////////////////////////////////////////////////////////
  485. char szTime[256] = "";
  487. MscGetTimeStr(szTime, sizeof(szTime) - 1);
  489. if (BSckVSendString(hBSock, POP3S.pPOP3Cfg->iTimeout,
  490.     "+OK %s %s service ready; %s", POP3S.szTimeStamp,
  491.     POP3_SERVER_NAME, szTime) < 0) {
  492. POP3ClearSession(POP3S);
  493. return (ErrGetErrorCode());
  494. }
  495. ///////////////////////////////////////////////////////////////////////////////
  496. //  Command loop
  497. ///////////////////////////////////////////////////////////////////////////////
  498. char szCommand[1024] = "";
  500. while (!SvrInShutdown() && (POP3S.iPOP3State != stateExit) &&
  501.        (BSckGetString(hBSock, szCommand, sizeof(szCommand) - 1,
  502.       POP3S.pPOP3Cfg->iSessionTimeout) != NULL) &&
  503.        (MscCmdStringCheck(szCommand) == 0)) {
  504. ///////////////////////////////////////////////////////////////////////////////
  505. //  Retrieve a fresh new copy of configuration and test shutdown flag
  506. ///////////////////////////////////////////////////////////////////////////////
  507. SysFree(POP3S.pPOP3Cfg);
  509. POP3S.pPOP3Cfg = POP3GetConfigCopy(hShbPOP3);
  511. if ((POP3S.pPOP3Cfg == NULL) || (POP3S.pPOP3Cfg->ulFlags & POP3F_STOP_SERVER))
  512. break;
  514. ///////////////////////////////////////////////////////////////////////////////
  515. //  Handle coomand
  516. ///////////////////////////////////////////////////////////////////////////////
  517. POP3HandleCommand(szCommand, hBSock, POP3S);
  519. }
  521. SysLogMessage(LOG_LEV_MESSAGE, "POP3 client exit [%s]n",
  522.       SysInetNToA(POP3S.PeerInfo, szIP));
  524. POP3ClearSession(POP3S);
  526. return (0);
  528. }
  530. static void POP3ClearSession(POP3Session & POP3S)
  531. {
  533. if (POP3S.hPOPSession != INVALID_POP3_HANDLE) {
  534. UPopReleaseSession(POP3S.hPOPSession, (POP3S.iPOP3State == stateExit) ? 1 : 0);
  536. POP3S.hPOPSession = INVALID_POP3_HANDLE;
  537. }
  539. if (POP3S.hSvrConfig != INVALID_SVRCFG_HANDLE)
  540. SvrReleaseConfigHandle(POP3S.hSvrConfig), POP3S.hSvrConfig =
  541.     INVALID_SVRCFG_HANDLE;
  543. if (POP3S.pPOP3Cfg != NULL)
  544. SysFree(POP3S.pPOP3Cfg), POP3S.pPOP3Cfg = NULL;
  546. }
  548. static int POP3HandleCommand(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S)
  549. {
  551. int iCmdResult = -1;
  553. if (StrCmdMatch(pszCommand, "USER"))
  554. iCmdResult = POP3HandleCmd_USER(pszCommand, hBSock, POP3S);
  555. else if (StrCmdMatch(pszCommand, "PASS"))
  556. iCmdResult = POP3HandleCmd_PASS(pszCommand, hBSock, POP3S);
  557. else if (StrCmdMatch(pszCommand, "APOP"))
  558. iCmdResult = POP3HandleCmd_APOP(pszCommand, hBSock, POP3S);
  559. else if (StrCmdMatch(pszCommand, "STAT"))
  560. iCmdResult = POP3HandleCmd_STAT(pszCommand, hBSock, POP3S);
  561. else if (StrCmdMatch(pszCommand, "LIST"))
  562. iCmdResult = POP3HandleCmd_LIST(pszCommand, hBSock, POP3S);
  563. else if (StrCmdMatch(pszCommand, "UIDL"))
  564. iCmdResult = POP3HandleCmd_UIDL(pszCommand, hBSock, POP3S);
  565. else if (StrCmdMatch(pszCommand, "QUIT"))
  566. iCmdResult = POP3HandleCmd_QUIT(pszCommand, hBSock, POP3S);
  567. else if (StrCmdMatch(pszCommand, "RETR"))
  568. iCmdResult = POP3HandleCmd_RETR(pszCommand, hBSock, POP3S);
  569. else if (StrCmdMatch(pszCommand, "TOP"))
  570. iCmdResult = POP3HandleCmd_TOP(pszCommand, hBSock, POP3S);
  571. else if (StrCmdMatch(pszCommand, "DELE"))
  572. iCmdResult = POP3HandleCmd_DELE(pszCommand, hBSock, POP3S);
  573. else if (StrCmdMatch(pszCommand, "NOOP"))
  574. iCmdResult = POP3HandleCmd_NOOP(pszCommand, hBSock, POP3S);
  575. else if (StrCmdMatch(pszCommand, "LAST"))
  576. iCmdResult = POP3HandleCmd_LAST(pszCommand, hBSock, POP3S);
  577. else if (StrCmdMatch(pszCommand, "RSET"))
  578. iCmdResult = POP3HandleCmd_RSET(pszCommand, hBSock, POP3S);
  579. else
  580. BSckSendString(hBSock, "-ERR Invalid command", POP3S.pPOP3Cfg->iTimeout);
  582. return (iCmdResult);
  584. }
  586. static int POP3HandleCmd_USER(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S)
  587. {
  589. if (POP3S.iPOP3State != stateInit) {
  590. BSckSendString(hBSock, "-ERR Command not valid here", POP3S.pPOP3Cfg->iTimeout);
  591. return (-1);
  592. }
  594. char **ppszTokens = StrTokenize(pszCommand, " ");
  596. if ((ppszTokens == NULL) || (StrStringsCount(ppszTokens) != 2)) {
  597. if (ppszTokens != NULL)
  598. StrFreeStrings(ppszTokens);
  600. POP3S.iPOP3State = stateInit;
  602. BSckSendString(hBSock, "-ERR Invalid syntax", POP3S.pPOP3Cfg->iTimeout);
  603. return (-1);
  604. }
  606. char szAccountUser[MAX_ADDR_NAME] = "";
  607. char szAccountDomain[MAX_HOST_NAME] = "";
  609. if (StrSplitString
  610.     (ppszTokens[1], POP3_USER_SPLITTERS, szAccountUser, sizeof(szAccountUser),
  611.      szAccountDomain, sizeof(szAccountDomain)) < 0) {
  612. StrFreeStrings(ppszTokens);
  614. BSckSendString(hBSock, "-ERR Invalid username", POP3S.pPOP3Cfg->iTimeout);
  615. return (-1);
  616. }
  618. StrFreeStrings(ppszTokens);
  620. StrSNCpy(POP3S.szUser, szAccountUser);
  622. if (strlen(szAccountDomain) > 0)
  623. StrSNCpy(POP3S.szSvrDomain, szAccountDomain);
  625. POP3S.iPOP3State = stateUser;
  627. BSckVSendString(hBSock, POP3S.pPOP3Cfg->iTimeout,
  628. "+OK Password required for %s@%s", POP3S.szUser, POP3S.szSvrDomain);
  630. return (0);
  632. }
  634. static int POP3HandleBadLogin(BSOCK_HANDLE hBSock, POP3Session & POP3S)
  635. {
  637. if (POP3S.pPOP3Cfg->ulFlags & POP3F_HANG_ON_BADLOGIN) {
  638. ///////////////////////////////////////////////////////////////////////////////
  639. //  Exit if POP3F_HANG_ON_BADLOGIN is set
  640. ///////////////////////////////////////////////////////////////////////////////
  642. POP3S.iPOP3State = stateExit;
  644. } else {
  645. ///////////////////////////////////////////////////////////////////////////////
  646. //  Otherwise sleep and doubles the sleeptime
  647. ///////////////////////////////////////////////////////////////////////////////
  648. SysSleep(POP3S.iBadLoginWait);
  649. POP3S.iBadLoginWait += POP3S.iBadLoginWait;
  651. POP3S.iPOP3State = stateInit;
  652. }
  654. BSckSendString(hBSock, "-ERR Invalid auth or access denied", POP3S.pPOP3Cfg->iTimeout);
  655. return (0);
  657. }
  659. static int POP3HandleCmd_PASS(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S)
  660. {
  662. if (POP3S.iPOP3State != stateUser) {
  663. BSckSendString(hBSock, "-ERR Command not valid here", POP3S.pPOP3Cfg->iTimeout);
  664. return (-1);
  665. }
  667. char **ppszTokens = StrTokenize(pszCommand, " ");
  669. if ((ppszTokens == NULL) || (StrStringsCount(ppszTokens) != 2)) {
  670. if (ppszTokens != NULL)
  671. StrFreeStrings(ppszTokens);
  673. POP3S.iPOP3State = stateInit;
  675. BSckSendString(hBSock, "-ERR Invalid syntax", POP3S.pPOP3Cfg->iTimeout);
  676. return (-1);
  677. }
  679. StrSNCpy(POP3S.szPassword, ppszTokens[1]);
  681. StrFreeStrings(ppszTokens);
  683. ///////////////////////////////////////////////////////////////////////////////
  684. //  Log POP3 session
  685. ///////////////////////////////////////////////////////////////////////////////
  686. if (POP3LogEnabled(POP3S.hShbPOP3, POP3S.pPOP3Cfg))
  687. POP3LogSession(POP3S);
  689. ///////////////////////////////////////////////////////////////////////////////
  690. //  Check the presence of external authentication modules. If authentication
  691. //  succeed "pszPassword" is set to NULL that instruct "UPopBuildSession"
  692. //  to not make local authentication
  693. ///////////////////////////////////////////////////////////////////////////////
  694. char const *pszPassword = POP3S.szPassword;
  695. int iAuthResult = UAthAuthenticateUser(AUTH_SERVICE_POP3,
  696.        POP3S.szSvrDomain, POP3S.szUser, POP3S.szPassword);
  698. if (iAuthResult < 0) {
  699. if (iAuthResult != ERR_NO_EXTERNAL_AUTH_DEFINED) {
  700. ErrorPush();
  702. POP3HandleBadLogin(hBSock, POP3S);
  704. return (ErrorPop());
  705. }
  706. } else
  707. pszPassword = NULL;
  709. ///////////////////////////////////////////////////////////////////////////////
  710. //  Create POP3 session
  711. ///////////////////////////////////////////////////////////////////////////////
  712. if ((POP3S.hPOPSession = UPopBuildSession(POP3S.szSvrDomain, POP3S.szUser,
  713.   pszPassword,
  714.   &POP3S.PeerInfo)) == INVALID_POP3_HANDLE) {
  715. ErrorPush();
  717. POP3HandleBadLogin(hBSock, POP3S);
  719. return (ErrorPop());
  720. }
  721. ///////////////////////////////////////////////////////////////////////////////
  722. //  Save the user connection IP to use for SMTP authentication
  723. ///////////////////////////////////////////////////////////////////////////////
  724. UPopSaveUserIP(POP3S.hPOPSession);
  726. POP3S.iPOP3State = stateLogged;
  728. int iMsgCount = UPopGetSessionMsgCurrent(POP3S.hPOPSession);
  729. unsigned long ulMBSize = UPopGetSessionMBSize(POP3S.hPOPSession);
  731. BSckVSendString(hBSock, POP3S.pPOP3Cfg->iTimeout,
  732. "+OK Maildrop has %d messages (%lu bytes)", iMsgCount, ulMBSize);
  734. return (0);
  736. }
  738. static int POP3HandleCmd_APOP(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S)
  739. {
  741. if (POP3S.iPOP3State != stateInit) {
  742. BSckSendString(hBSock, "-ERR Command not valid here", POP3S.pPOP3Cfg->iTimeout);
  743. return (-1);
  744. }
  746. char **ppszTokens = StrTokenize(pszCommand, " ");
  748. if ((ppszTokens == NULL) || (StrStringsCount(ppszTokens) != 3)) {
  749. if (ppszTokens != NULL)
  750. StrFreeStrings(ppszTokens);
  752. POP3S.iPOP3State = stateInit;
  754. BSckSendString(hBSock, "-ERR Invalid syntax", POP3S.pPOP3Cfg->iTimeout);
  755. return (-1);
  756. }
  757. ///////////////////////////////////////////////////////////////////////////////
  758. //  Process parameters
  759. ///////////////////////////////////////////////////////////////////////////////
  760. char szAccountUser[MAX_ADDR_NAME] = "";
  761. char szAccountDomain[MAX_HOST_NAME] = "";
  763. if (StrSplitString
  764.     (ppszTokens[1], POP3_USER_SPLITTERS, szAccountUser, sizeof(szAccountUser),
  765.      szAccountDomain, sizeof(szAccountDomain)) < 0) {
  766. StrFreeStrings(ppszTokens);
  768. BSckSendString(hBSock, "-ERR Invalid username", POP3S.pPOP3Cfg->iTimeout);
  769. return (-1);
  770. }
  772. StrSNCpy(POP3S.szUser, szAccountUser);
  773. StrSNCpy(POP3S.szPassword, ppszTokens[2]);
  775. if (strlen(szAccountDomain) > 0)
  776. StrSNCpy(POP3S.szSvrDomain, szAccountDomain);
  778. StrFreeStrings(ppszTokens);
  780. ///////////////////////////////////////////////////////////////////////////////
  781. //  Log POP3 session
  782. ///////////////////////////////////////////////////////////////////////////////
  783. if (POP3LogEnabled(POP3S.hShbPOP3, POP3S.pPOP3Cfg))
  784. POP3LogSession(POP3S);
  786. ///////////////////////////////////////////////////////////////////////////////
  787. //  Check the presence of external authentication modules. If authentication
  788. //  succeed "pszPassword" is set to NULL that instruct "UPopBuildSession"
  789. //  to not make local authentication
  790. ///////////////////////////////////////////////////////////////////////////////
  791. char const *pszPassword = POP3S.szPassword;
  792. int iAuthResult = UAthAuthenticateUser(AUTH_SERVICE_POP3,
  793.        POP3S.szSvrDomain, POP3S.szUser, POP3S.szPassword);
  795. if (iAuthResult < 0) {
  796. if (iAuthResult != ERR_NO_EXTERNAL_AUTH_DEFINED) {
  797. ErrorPush();
  799. POP3HandleBadLogin(hBSock, POP3S);
  801. return (ErrorPop());
  802. }
  803. } else
  804. pszPassword = NULL;
  806. ///////////////////////////////////////////////////////////////////////////////
  807. //  Do APOP authentication ( only if the external one is not performed )
  808. ///////////////////////////////////////////////////////////////////////////////
  809. if ((pszPassword != NULL) &&
  810.     (UPopAuthenticateAPOP(POP3S.szSvrDomain, POP3S.szUser, POP3S.szTimeStamp,
  811.   pszPassword) < 0)) {
  812. ErrorPush();
  814. POP3HandleBadLogin(hBSock, POP3S);
  816. return (ErrorPop());
  817. }
  818. ///////////////////////////////////////////////////////////////////////////////
  819. //  Create POP3 session ( the NULL as third parameter force to not perform
  820. //  user authentication that has been done before )
  821. ///////////////////////////////////////////////////////////////////////////////
  822. if ((POP3S.hPOPSession = UPopBuildSession(POP3S.szSvrDomain, POP3S.szUser,
  823.   NULL, &POP3S.PeerInfo)) == INVALID_POP3_HANDLE)
  824. {
  825. ErrorPush();
  827. POP3HandleBadLogin(hBSock, POP3S);
  829. return (ErrorPop());
  830. }
  831. ///////////////////////////////////////////////////////////////////////////////
  832. //  Save the user connection IP to use for SMTP authentication
  833. ///////////////////////////////////////////////////////////////////////////////
  834. UPopSaveUserIP(POP3S.hPOPSession);
  836. POP3S.iPOP3State = stateLogged;
  838. int iMsgCount = UPopGetSessionMsgCurrent(POP3S.hPOPSession);
  839. unsigned long ulMBSize = UPopGetSessionMBSize(POP3S.hPOPSession);
  841. BSckVSendString(hBSock, POP3S.pPOP3Cfg->iTimeout,
  842. "+OK Maildrop has %d messages (%lu bytes)", iMsgCount, ulMBSize);
  844. return (0);
  846. }
  848. static int POP3HandleCmd_STAT(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S)
  849. {
  851. if (POP3S.iPOP3State != stateLogged) {
  852. BSckSendString(hBSock, "-ERR Command not valid here", POP3S.pPOP3Cfg->iTimeout);
  853. return (-1);
  854. }
  856. int iMsgCount = UPopGetSessionMsgCurrent(POP3S.hPOPSession);
  857. unsigned long ulMBSize = UPopGetSessionMBSize(POP3S.hPOPSession);
  859. BSckVSendString(hBSock, POP3S.pPOP3Cfg->iTimeout, "+OK %d %lu", iMsgCount, ulMBSize);
  861. return (0);
  863. }
  865. static int POP3HandleCmd_LIST(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S)
  866. {
  868. if (POP3S.iPOP3State != stateLogged) {
  869. BSckSendString(hBSock, "-ERR Command not valid here", POP3S.pPOP3Cfg->iTimeout);
  870. return (-1);
  871. }
  873. int iMsgIndex = -1;
  874. int iNumArgs = sscanf(pszCommand, "%*s %d", &iMsgIndex);
  876. if (iNumArgs < 1) {
  877. int iMsgCount = UPopGetSessionMsgCurrent(POP3S.hPOPSession);
  878. int iMsgTotal = UPopGetSessionMsgTotal(POP3S.hPOPSession);
  879. unsigned long ulMBSize = UPopGetSessionMBSize(POP3S.hPOPSession);
  881. BSckVSendString(hBSock, POP3S.pPOP3Cfg->iTimeout,
  882. "+OK %d %lu", iMsgCount, ulMBSize);
  884. for (int ii = 0; ii < iMsgTotal; ii++) {
  885. unsigned long ulMessageSize = 0;
  887. if (UPopGetMessageSize(POP3S.hPOPSession, ii + 1, ulMessageSize) == 0) {
  889. BSckVSendString(hBSock, POP3S.pPOP3Cfg->iTimeout,
  890. "%d %lu", ii + 1, ulMessageSize);
  892. }
  893. }
  895. BSckSendString(hBSock, ".", POP3S.pPOP3Cfg->iTimeout);
  896. } else {
  897. unsigned long ulMessageSize = 0;
  899. if (UPopGetMessageSize(POP3S.hPOPSession, iMsgIndex, ulMessageSize) < 0)
  900. BSckSendString(hBSock, "-ERR No such message", POP3S.pPOP3Cfg->iTimeout);
  901. else {
  903. BSckVSendString(hBSock, POP3S.pPOP3Cfg->iTimeout,
  904. "+OK %d %lu", iMsgIndex, ulMessageSize);
  906. }
  908. }
  910. return (0);
  912. }
  914. static int POP3HandleCmd_UIDL(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S)
  915. {
  917. if (POP3S.iPOP3State != stateLogged) {
  918. BSckSendString(hBSock, "-ERR Command not valid here", POP3S.pPOP3Cfg->iTimeout);
  919. return (-1);
  920. }
  922. int iMsgIndex = -1;
  923. int iNumArgs = sscanf(pszCommand, "%*s %d", &iMsgIndex);
  925. if (iNumArgs < 1) {
  926. int iMsgCount = UPopGetSessionMsgCurrent(POP3S.hPOPSession);
  927. int iMsgTotal = UPopGetSessionMsgTotal(POP3S.hPOPSession);
  929. BSckVSendString(hBSock, POP3S.pPOP3Cfg->iTimeout, "+OK %d", iMsgCount);
  931. for (int ii = 0; ii < iMsgTotal; ii++) {
  932. char szMessageUIDL[256] = "";
  934. if (UPopGetMessageUIDL(POP3S.hPOPSession, ii + 1, szMessageUIDL) == 0) {
  936. BSckVSendString(hBSock, POP3S.pPOP3Cfg->iTimeout,
  937. "%d %s", ii + 1, szMessageUIDL);
  939. }
  940. }
  942. BSckSendString(hBSock, ".", POP3S.pPOP3Cfg->iTimeout);
  943. } else {
  944. char szMessageUIDL[256] = "";
  946. if (UPopGetMessageUIDL(POP3S.hPOPSession, iMsgIndex, szMessageUIDL) < 0)
  947. BSckSendString(hBSock, "-ERR No such message", POP3S.pPOP3Cfg->iTimeout);
  948. else {
  950. BSckVSendString(hBSock, POP3S.pPOP3Cfg->iTimeout,
  951. "+OK %d %s", iMsgIndex, szMessageUIDL);
  953. }
  955. }
  957. return (0);
  959. }
  961. static int POP3HandleCmd_QUIT(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S)
  962. {
  964. POP3S.iPOP3State = stateExit;
  966. BSckVSendString(hBSock, POP3S.pPOP3Cfg->iTimeout,
  967. "+OK %s closing session", POP3_SERVER_NAME);
  969. return (0);
  971. }
  973. static int POP3HandleCmd_RETR(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S)
  974. {
  976. if (POP3S.iPOP3State != stateLogged) {
  977. BSckSendString(hBSock, "-ERR Command not valid here", POP3S.pPOP3Cfg->iTimeout);
  978. return (-1);
  979. }
  981. int iMsgIndex = -1;
  983. if (sscanf(pszCommand, "%*s %d", &iMsgIndex) < 1) {
  984. BSckSendString(hBSock, "-ERR Invalid syntax", POP3S.pPOP3Cfg->iTimeout);
  985. return (-1);
  986. }
  988. return (UPopSessionSendMsg(POP3S.hPOPSession, iMsgIndex, hBSock));
  990. }
  992. static int POP3HandleCmd_TOP(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S)
  993. {
  995. if (POP3S.iPOP3State != stateLogged) {
  996. BSckSendString(hBSock, "-ERR Command not valid here", POP3S.pPOP3Cfg->iTimeout);
  997. return (-1);
  998. }
  1000. int iMsgIndex = -1;
  1001. int iNumLines = 0;
  1003. if (sscanf(pszCommand, "%*s %d %d", &iMsgIndex, &iNumLines) < 2) {
  1004. BSckSendString(hBSock, "-ERR Invalid syntax", POP3S.pPOP3Cfg->iTimeout);
  1005. return (-1);
  1006. }
  1008. return (UPopSessionTopMsg(POP3S.hPOPSession, iMsgIndex, iNumLines, hBSock));
  1010. }
  1012. static int POP3HandleCmd_DELE(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S)
  1013. {
  1015. if (POP3S.iPOP3State != stateLogged) {
  1016. BSckSendString(hBSock, "-ERR Command not valid here", POP3S.pPOP3Cfg->iTimeout);
  1017. return (-1);
  1018. }
  1020. int iMsgIndex = -1;
  1022. if (sscanf(pszCommand, "%*s %d", &iMsgIndex) < 1) {
  1023. BSckSendString(hBSock, "-ERR Invalid syntax", POP3S.pPOP3Cfg->iTimeout);
  1024. return (-1);
  1025. }
  1027. if (UPopDeleteMessage(POP3S.hPOPSession, iMsgIndex) < 0) {
  1028. UPopSendErrorResponse(hBSock, ErrGetErrorCode(), POP3S.pPOP3Cfg->iTimeout);
  1030. return (ErrGetErrorCode());
  1031. }
  1033. BSckSendString(hBSock, "+OK Message deleted", POP3S.pPOP3Cfg->iTimeout);
  1035. return (0);
  1037. }
  1039. static int POP3HandleCmd_NOOP(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S)
  1040. {
  1042. if (POP3S.iPOP3State != stateLogged) {
  1043. BSckSendString(hBSock, "-ERR Command not valid here", POP3S.pPOP3Cfg->iTimeout);
  1044. return (-1);
  1045. }
  1047. int iMsgCount = UPopGetSessionMsgCurrent(POP3S.hPOPSession);
  1048. unsigned long ulMBSize = UPopGetSessionMBSize(POP3S.hPOPSession);
  1050. BSckVSendString(hBSock, POP3S.pPOP3Cfg->iTimeout,
  1051. "+OK Maildrop has %d messages (%lu bytes)", iMsgCount, ulMBSize);
  1053. return (0);
  1055. }
  1057. static int POP3HandleCmd_LAST(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S)
  1058. {
  1060. if (POP3S.iPOP3State != stateLogged) {
  1061. BSckSendString(hBSock, "-ERR Command not valid here", POP3S.pPOP3Cfg->iTimeout);
  1062. return (-1);
  1063. }
  1065. int iMsgLast = UPopGetSessionLastAccessed(POP3S.hPOPSession);
  1067. BSckVSendString(hBSock, POP3S.pPOP3Cfg->iTimeout, "+OK %d", iMsgLast);
  1069. return (0);
  1071. }
  1073. static int POP3HandleCmd_RSET(const char *pszCommand, BSOCK_HANDLE hBSock, POP3Session & POP3S)
  1074. {
  1076. if (POP3S.iPOP3State != stateLogged) {
  1077. BSckSendString(hBSock, "-ERR Command not valid here", POP3S.pPOP3Cfg->iTimeout);
  1078. return (-1);
  1079. }
  1081. UPopResetSession(POP3S.hPOPSession);
  1083. int iMsgCount = UPopGetSessionMsgCurrent(POP3S.hPOPSession);
  1084. unsigned long ulMBSize = UPopGetSessionMBSize(POP3S.hPOPSession);
  1086. BSckVSendString(hBSock, POP3S.pPOP3Cfg->iTimeout,
  1087. "+OK Maildrop has %d messages (%lu bytes)", iMsgCount, ulMBSize);
  1089. return (0);
  1091. }