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

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

Email服务器

开发平台：

Visual C++

FINGSvr.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 "StrUtils.h"
  30. #include "ResLocks.h"
  31. #include "MiscUtils.h"
  32. #include "SvrUtils.h"
  33. #include "UsrUtils.h"
  34. #include "ExtAliases.h"
  35. #include "UsrMailList.h"
  36. #include "MessQueue.h"
  37. #include "SMTPUtils.h"
  38. #include "MailConfig.h"
  39. #include "AppDefines.h"
  40. #include "MailSvr.h"
  41. #include "FINGSvr.h"
  43. #define FINGSRV_ACCEPT_TIMEOUT  4
  44. #define FING_LISTEN_SIZE        64
  45. #define FING_WAIT_SLEEP         2
  46. #define MAX_CLIENTS_WAIT        300
  47. #define FING_IPMAP_FILE         "finger.ipmap.tab"
  48. #define FING_LOG_FILE           "finger"
  49. #define FING_SERVER_NAME        "[" APP_NAME_VERSION_STR " FINGER Server]"
  51. static int FINGCheckPeerIP(SYS_SOCKET SockFD);
  52. static FINGConfig *FINGGetConfigCopy(SHB_HANDLE hShbFING);
  53. static int FINGLogEnabled(SHB_HANDLE hShbFING, FINGConfig * pFINGCfg = NULL);
  54. static unsigned int FINGClientThread(void *pThreadData);
  55. static int FINGLogSession(char const *pszSockHost, char const *pszSockDomain,
  56.   SYS_INET_ADDR & PeerInfo, char const *pszQuery);
  57. static int FINGHandleSession(SHB_HANDLE hShbFING, BSOCK_HANDLE hBSock);
  58. static int FINGProcessQuery(char const *pszQuery, BSOCK_HANDLE hBSock,
  59.     FINGConfig * pFINGCfg, char const *pszSockDomain,
  60.     SVRCFG_HANDLE hSvrConfig);
  61. static int FINGDumpUser(char const *pszUser, char const *pszDomain,
  62. BSOCK_HANDLE hBSock, FINGConfig * pFINGCfg);
  63. static int FINGDumpMailingList(UserInfo * pUI, BSOCK_HANDLE hBSock, FINGConfig * pFINGCfg);
  65. static int FINGCheckPeerIP(SYS_SOCKET SockFD)
  66. {
  68. char szIPMapFile[SYS_MAX_PATH] = "";
  70. CfgGetRootPath(szIPMapFile, sizeof(szIPMapFile));
  71. StrNCat(szIPMapFile, FING_IPMAP_FILE, sizeof(szIPMapFile));
  73. if (SysExistFile(szIPMapFile)) {
  74. SYS_INET_ADDR PeerInfo;
  76. if (SysGetPeerInfo(SockFD, PeerInfo) < 0)
  77. return (ErrGetErrorCode());
  79. if (MscCheckAllowedIP(szIPMapFile, PeerInfo, true) < 0)
  80. return (ErrGetErrorCode());
  81. }
  83. return (0);
  85. }
  87. static FINGConfig *FINGGetConfigCopy(SHB_HANDLE hShbFING)
  88. {
  90. FINGConfig *pFINGCfg = (FINGConfig *) ShbLock(hShbFING);
  92. if (pFINGCfg == NULL)
  93. return (NULL);
  95. FINGConfig *pFINGCfgCopy = (FINGConfig *) SysAlloc(sizeof(FINGConfig));
  97. if (pFINGCfgCopy != NULL)
  98. memcpy(pFINGCfgCopy, pFINGCfg, sizeof(FINGConfig));
  100. ShbUnlock(hShbFING);
  102. return (pFINGCfgCopy);
  104. }
  106. static int FINGLogEnabled(SHB_HANDLE hShbFING, FINGConfig * pFINGCfg)
  107. {
  109. int iDoUnlock = 0;
  111. if (pFINGCfg == NULL) {
  112. if ((pFINGCfg = (FINGConfig *) ShbLock(hShbFING)) == NULL)
  113. return (ErrGetErrorCode());
  115. ++iDoUnlock;
  116. }
  118. unsigned long ulFlags = pFINGCfg->ulFlags;
  120. if (iDoUnlock)
  121. ShbUnlock(hShbFING);
  123. return ((ulFlags & FINGF_LOG_ENABLED) ? 1 : 0);
  125. }
  127. static unsigned int FINGClientThread(void *pThreadData)
  128. {
  130. SYS_SOCKET SockFD = (SYS_SOCKET) (unsigned long) pThreadData;
  132. ///////////////////////////////////////////////////////////////////////////////
  133. //  Check peer IP address serivce access permissions
  134. ///////////////////////////////////////////////////////////////////////////////
  135. if (FINGCheckPeerIP(SockFD) < 0) {
  136. ErrorPush();
  137. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  138. SysCloseSocket(SockFD);
  139. return (ErrorPop());
  140. }
  141. ///////////////////////////////////////////////////////////////////////////////
  142. //  Increase threads count
  143. ///////////////////////////////////////////////////////////////////////////////
  144. FINGConfig *pFINGCfg = (FINGConfig *) ShbLock(hShbFING);
  146. if (pFINGCfg == NULL) {
  147. ErrorPush();
  148. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  149. SysCloseSocket(SockFD);
  150. return (ErrorPop());
  151. }
  153. ++pFINGCfg->lThreadCount;
  155. ShbUnlock(hShbFING);
  157. ///////////////////////////////////////////////////////////////////////////////
  158. //  Link socket to the bufferer
  159. ///////////////////////////////////////////////////////////////////////////////
  160. BSOCK_HANDLE hBSock = BSckAttach(SockFD);
  162. if (hBSock == INVALID_BSOCK_HANDLE) {
  163. ErrorPush();
  164. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  165. SysCloseSocket(SockFD);
  166. return (ErrorPop());
  167. }
  169. ///////////////////////////////////////////////////////////////////////////////
  170. //  Handle client session
  171. ///////////////////////////////////////////////////////////////////////////////
  172. FINGHandleSession(hShbFING, hBSock);
  174. ///////////////////////////////////////////////////////////////////////////////
  175. //  Unlink socket to the bufferer and close it
  176. ///////////////////////////////////////////////////////////////////////////////
  177. BSckDetach(hBSock, 1);
  179. ///////////////////////////////////////////////////////////////////////////////
  180. //  Decrease thread count
  181. ///////////////////////////////////////////////////////////////////////////////
  182. pFINGCfg = (FINGConfig *) ShbLock(hShbFING);
  184. if (pFINGCfg == NULL) {
  185. ErrorPush();
  186. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  187. return (ErrorPop());
  188. }
  190. --pFINGCfg->lThreadCount;
  192. ShbUnlock(hShbFING);
  194. return (0);
  196. }
  198. unsigned int FINGThreadProc(void *pThreadData)
  199. {
  201. FINGConfig *pFINGCfg = (FINGConfig *) ShbLock(hShbFING);
  203. if (pFINGCfg == NULL) {
  204. ErrorPush();
  205. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  206. return (ErrorPop());
  207. }
  209. int iNumSockFDs = 0;
  210. SYS_SOCKET SockFDs[MAX_FING_ACCEPT_ADDRESSES];
  212. if (MscCreateServerSockets(pFINGCfg->iNumAddr, pFINGCfg->SvrAddr, pFINGCfg->iPort,
  213.    FING_LISTEN_SIZE, SockFDs, iNumSockFDs) < 0) {
  214. ErrorPush();
  215. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString());
  216. ShbUnlock(hShbFING);
  217. return (ErrorPop());
  218. }
  220. ShbUnlock(hShbFING);
  222. SysLogMessage(LOG_LEV_MESSAGE, "%s startedn", FING_SERVER_NAME);
  224. for (;;) {
  225. int iNumConnSockFD = 0;
  226. SYS_SOCKET ConnSockFD[MAX_FING_ACCEPT_ADDRESSES];
  228. if (MscAcceptServerConnection(SockFDs, iNumSockFDs, ConnSockFD,
  229.       iNumConnSockFD, FINGSRV_ACCEPT_TIMEOUT) < 0) {
  230. unsigned long ulFlags = FINGF_STOP_SERVER;
  232. pFINGCfg = (FINGConfig *) ShbLock(hShbFING);
  234. if (pFINGCfg != NULL)
  235. ulFlags = pFINGCfg->ulFlags;
  237. ShbUnlock(hShbFING);
  239. if (ulFlags & FINGF_STOP_SERVER)
  240. break;
  241. else
  242. continue;
  243. }
  245. for (int ss = 0; ss < iNumConnSockFD; ss++) {
  246. SYS_THREAD hClientThread =
  247.     SysCreateServiceThread(FINGClientThread, ConnSockFD[ss]);
  249. if (hClientThread != SYS_INVALID_THREAD)
  250. SysCloseThread(hClientThread, 0);
  251. else
  252. SysCloseSocket(ConnSockFD[ss]);
  254. }
  255. }
  257. for (int ss = 0; ss < iNumSockFDs; ss++)
  258. SysCloseSocket(SockFDs[ss]);
  260. ///////////////////////////////////////////////////////////////////////////////
  261. //  Wait for clients completion
  262. ///////////////////////////////////////////////////////////////////////////////
  263. for (int iTotalWait = 0; (iTotalWait < MAX_CLIENTS_WAIT); iTotalWait += FING_WAIT_SLEEP) {
  264. pFINGCfg = (FINGConfig *) ShbLock(hShbFING);
  266. if (pFINGCfg == NULL)
  267. break;
  269. long lThreadCount = pFINGCfg->lThreadCount;
  271. ShbUnlock(hShbFING);
  273. if (lThreadCount == 0)
  274. break;
  276. SysSleep(FING_WAIT_SLEEP);
  277. }
  279. SysLogMessage(LOG_LEV_MESSAGE, "%s stoppedn", FING_SERVER_NAME);
  281. return (0);
  283. }
  285. static int FINGLogSession(char const *pszSockHost, char const *pszSockDomain,
  286.   SYS_INET_ADDR & PeerInfo, char const *pszQuery)
  287. {
  289. char szTime[256] = "";
  291. MscGetTimeNbrString(szTime, sizeof(szTime) - 1);
  293. RLCK_HANDLE hResLock = RLckLockEX(SVR_LOGS_DIR SYS_SLASH_STR FING_LOG_FILE);
  295. if (hResLock == INVALID_RLCK_HANDLE)
  296. return (ErrGetErrorCode());
  298. char szIP[128] = "???.???.???.???";
  300. MscFileLog(FING_LOG_FILE, ""%s""
  301.    "t"%s""
  302.    "t"%s""
  303.    "t"%s""
  304.    "t"%s""
  305.    "n", pszSockHost, pszSockDomain, SysInetNToA(PeerInfo, szIP),
  306.    szTime, pszQuery);
  308. RLckUnlockEX(hResLock);
  310. return (0);
  312. }
  314. static int FINGHandleSession(SHB_HANDLE hShbFING, BSOCK_HANDLE hBSock)
  315. {
  317. FINGConfig *pFINGCfg = FINGGetConfigCopy(hShbFING);
  319. ///////////////////////////////////////////////////////////////////////////////
  320. //  Get client socket info
  321. ///////////////////////////////////////////////////////////////////////////////
  322. SYS_INET_ADDR PeerInfo;
  324. if (SysGetPeerInfo(BSckGetAttachedSocket(hBSock), PeerInfo) < 0) {
  325. ErrorPush();
  326. BSckSendString(hBSock, ErrGetErrorString(ErrorFetch()), pFINGCfg->iTimeout);
  327. SysFree(pFINGCfg);
  329. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString(ErrorFetch()));
  330. return (ErrorPop());
  331. }
  333. ///////////////////////////////////////////////////////////////////////////////
  334. //  Get server socket FQDN
  335. ///////////////////////////////////////////////////////////////////////////////
  336. char szSvrFQDN[MAX_HOST_NAME] = "";
  338. if (MscGetSockHost(BSckGetAttachedSocket(hBSock), szSvrFQDN) < 0) {
  339. ErrorPush();
  340. BSckSendString(hBSock, ErrGetErrorString(ErrorFetch()), pFINGCfg->iTimeout);
  341. SysFree(pFINGCfg);
  343. SysLogMessage(LOG_LEV_ERROR, "%sn", ErrGetErrorString(ErrorFetch()));
  344. return (ErrorPop());
  345. }
  347. char szSockHost[MAX_HOST_NAME] = "";
  348. char szSockDomain[MAX_HOST_NAME] = "";
  350. MscSplitFQDN(szSvrFQDN, szSockHost, szSockDomain);
  352. char szIP[128] = "???.???.???.???";
  354. SysLogMessage(LOG_LEV_MESSAGE, "FINGER client connection from [%s]n",
  355.       SysInetNToA(PeerInfo, szIP));
  357. char szQuery[1024] = "";
  359. if ((BSckGetString(hBSock, szQuery, sizeof(szQuery) - 1, pFINGCfg->iTimeout) != NULL) &&
  360.     (MscCmdStringCheck(szQuery) == 0)) {
  361. ///////////////////////////////////////////////////////////////////////////////
  362. //  Log FINGER question
  363. ///////////////////////////////////////////////////////////////////////////////
  364. if (FINGLogEnabled(hShbFING))
  365. FINGLogSession(szSockHost, szSockDomain, PeerInfo, szQuery);
  367. SysLogMessage(LOG_LEV_MESSAGE, "FINGER query [%s] : "%s"n",
  368.       SysInetNToA(PeerInfo, szIP), szQuery);
  370. SVRCFG_HANDLE hSvrConfig = SvrGetConfigHandle();
  372. FINGProcessQuery(szQuery, hBSock, pFINGCfg, szSockDomain, hSvrConfig);
  374. if (hSvrConfig != INVALID_SVRCFG_HANDLE)
  375. SvrReleaseConfigHandle(hSvrConfig);
  376. }
  378. SysFree(pFINGCfg);
  380. SysLogMessage(LOG_LEV_MESSAGE, "FINGER client exit [%s]n", SysInetNToA(PeerInfo, szIP));
  382. return (0);
  384. }
  386. static int FINGProcessQuery(char const *pszQuery, BSOCK_HANDLE hBSock,
  387.     FINGConfig * pFINGCfg, char const *pszSockDomain,
  388.     SVRCFG_HANDLE hSvrConfig)
  389. {
  391. ///////////////////////////////////////////////////////////////////////////////
  392. //  Check for verbose query
  393. ///////////////////////////////////////////////////////////////////////////////
  394. int iVerbose = 0;
  396. if (pszQuery[0] == '/') {
  397. if (toupper(pszQuery[1]) != 'W') {
  398. BSckSendString(hBSock, "Invalid query", pFINGCfg->iTimeout);
  400. ErrSetErrorCode(ERR_FINGER_QUERY_FORMAT);
  401. return (ERR_FINGER_QUERY_FORMAT);
  402. }
  404. ++iVerbose;
  405. pszQuery += 2;
  406. }
  407. ///////////////////////////////////////////////////////////////////////////////
  408. //  Discard spaces
  409. ///////////////////////////////////////////////////////////////////////////////
  410. for (; *pszQuery == ' '; pszQuery++);
  412. if (*pszQuery == '') {
  413. BSckSendString(hBSock, "Empty query not allowed", pFINGCfg->iTimeout);
  415. ErrSetErrorCode(ERR_FINGER_QUERY_FORMAT);
  416. return (ERR_FINGER_QUERY_FORMAT);
  417. }
  418. ///////////////////////////////////////////////////////////////////////////////
  419. //  Split user-domain
  420. ///////////////////////////////////////////////////////////////////////////////
  421. char szUser[MAX_ADDR_NAME] = "";
  422. char szDomain[MAX_ADDR_NAME] = "";
  424. if (strchr(pszQuery, '@') != NULL) {
  425. if (USmtpSplitEmailAddr(pszQuery, szUser, szDomain) < 0) {
  426. ErrorPush();
  428. BSckSendString(hBSock, "Invalid query", pFINGCfg->iTimeout);
  430. return (ErrorPop());
  431. }
  432. } else
  433. StrSNCpy(szUser, pszQuery);
  435. ///////////////////////////////////////////////////////////////////////////////
  436. //  Check if indirect query
  437. ///////////////////////////////////////////////////////////////////////////////
  438. if (strchr(szDomain, '@') != NULL) {
  439. BSckSendString(hBSock, "Indirect query not allowed", pFINGCfg->iTimeout);
  441. ErrSetErrorCode(ERR_FINGER_QUERY_FORMAT);
  442. return (ERR_FINGER_QUERY_FORMAT);
  443. }
  444. ///////////////////////////////////////////////////////////////////////////////
  445. //  Setup domain name in case of username only query
  446. ///////////////////////////////////////////////////////////////////////////////
  447. if (IsEmptyString(szDomain)) {
  448. if (SvrConfigVar("POP3Domain", szDomain, sizeof(szDomain), hSvrConfig) < 0) {
  449. if (strlen(pszSockDomain) == 0) {
  450. if (SvrConfigVar
  451.     ("RootDomain", szDomain, sizeof(szDomain), hSvrConfig) < 0) {
  452. ErrorPush();
  454. BSckSendString(hBSock, "User not found",
  455.        pFINGCfg->iTimeout);
  457. return (ErrorPop());
  458. }
  459. } else
  460. StrSNCpy(szDomain, pszSockDomain);
  461. }
  462. }
  463. ///////////////////////////////////////////////////////////////////////////////
  464. //  Dump user
  465. ///////////////////////////////////////////////////////////////////////////////
  466. if (FINGDumpUser(szUser, szDomain, hBSock, pFINGCfg) < 0) {
  467. ErrorPush();
  469. BSckSendString(hBSock, "User not found", pFINGCfg->iTimeout);
  471. return (ErrorPop());
  472. }
  474. return (0);
  476. }
  478. static int FINGDumpUser(char const *pszUser, char const *pszDomain,
  479. BSOCK_HANDLE hBSock, FINGConfig * pFINGCfg)
  480. {
  482. ///////////////////////////////////////////////////////////////////////////////
  483. //  Lookup user
  484. ///////////////////////////////////////////////////////////////////////////////
  485. char szRealAddr[MAX_ADDR_NAME] = "";
  486. UserInfo *pUI = UsrGetUserByNameOrAlias(pszDomain, pszUser, szRealAddr);
  488. if (pUI != NULL) {
  489. if (UsrGetUserType(pUI) == usrTypeUser) {
  490. ///////////////////////////////////////////////////////////////////////////////
  491. //  Local user case
  492. ///////////////////////////////////////////////////////////////////////////////
  493. char *pszRealName = UsrGetUserInfoVar(pUI, "RealName");
  494. char *pszHomePage = UsrGetUserInfoVar(pUI, "HomePage");
  495. char szRespBuffer[2048] = "";
  497. sprintf(szRespBuffer,
  498. "EMail       : %srn"
  499. "  Real Name : %srn"
  500. "  Home Page : %s",
  501. szRealAddr,
  502. (pszRealName != NULL) ? pszRealName : "??",
  503. (pszHomePage != NULL) ? pszHomePage : "??");
  505. BSckSendString(hBSock, szRespBuffer, pFINGCfg->iTimeout);
  507. if (pszRealName != NULL)
  508. SysFree(pszRealName);
  510. if (pszHomePage != NULL)
  511. SysFree(pszHomePage);
  512. } else {
  513. ///////////////////////////////////////////////////////////////////////////////
  514. //  Local mailing list case
  515. ///////////////////////////////////////////////////////////////////////////////
  517. FINGDumpMailingList(pUI, hBSock, pFINGCfg);
  518. }
  520. UsrFreeUserInfo(pUI);
  521. } else {
  522. ErrSetErrorCode(ERR_USER_NOT_FOUND);
  523. return (ERR_USER_NOT_FOUND);
  524. }
  526. return (0);
  528. }
  530. static int FINGDumpMailingList(UserInfo * pUI, BSOCK_HANDLE hBSock, FINGConfig * pFINGCfg)
  531. {
  533. USRML_HANDLE hUsersDB = UsrMLOpenDB(pUI);
  535. if (hUsersDB == INVALID_USRML_HANDLE)
  536. return (ErrGetErrorCode());
  538. ///////////////////////////////////////////////////////////////////////////////
  539. //  Mailing list scan
  540. ///////////////////////////////////////////////////////////////////////////////
  541. MLUserInfo *pMLUI = UsrMLGetFirstUser(hUsersDB);
  543. for (; pMLUI != NULL; pMLUI = UsrMLGetNextUser(hUsersDB)) {
  544. char szUser[MAX_ADDR_NAME] = "";
  545. char szDomain[MAX_ADDR_NAME] = "";
  547. if (USmtpSplitEmailAddr(pMLUI->pszAddress, szUser, szDomain) < 0) {
  548. ErrorPush();
  549. UsrMLFreeUser(pMLUI);
  550. UsrMLCloseDB(hUsersDB);
  551. return (ErrorPop());
  552. }
  553. ///////////////////////////////////////////////////////////////////////////////
  554. //  Dump user
  555. ///////////////////////////////////////////////////////////////////////////////
  556. FINGDumpUser(szUser, szDomain, hBSock, pFINGCfg);
  558. UsrMLFreeUser(pMLUI);
  559. }
  561. UsrMLCloseDB(hUsersDB);
  563. return (0);
  565. }