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

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

Email服务器

开发平台：

Visual C++

SvrUtils.cpp：源码内容
  1. /*
  2.  *  XMail by Davide Libenzi ( Intranet and Internet mail server )
  3.  *  Copyright (C) 1999,..,2004  Davide Libenzi
  4.  *
  5.  *  This program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2 of the License, or
  8.  *  (at your option) any later version.
  9.  *
  10.  *  This program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  *  GNU General Public License for more details.
  14.  *
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with this program; if not, write to the Free Software
  17.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  *
  19.  *  Davide Libenzi <davidel@xmailserver.org>
  20.  *
  21.  */
  23. #include "SysInclude.h"
  24. #include "SysDep.h"
  25. #include "SvrDefines.h"
  26. #include "ShBlocks.h"
  27. #include "ResLocks.h"
  28. #include "StrUtils.h"
  29. #include "SList.h"
  30. #include "BuffSock.h"
  31. #include "MailConfig.h"
  32. #include "UsrUtils.h"
  33. #include "SvrUtils.h"
  34. #include "MessQueue.h"
  35. #include "SMAILUtils.h"
  36. #include "QueueUtils.h"
  37. #include "SMAILSvr.h"
  38. #include "AppDefines.h"
  39. #include "MailSvr.h"
  40. #include "MiscUtils.h"
  42. #define SVR_PROFILE_FILE            "server.tab"
  43. #define MESSAGEID_FILE              "message.id"
  44. #define SMTP_SPOOL_DIR              "spool"
  45. #define MAX_MSG_FILENAME_LENGTH     80
  46. #define SVR_PROFILE_LINE_MAX        2048
  47. #define SYS_RES_CHECK_INTERVAL      8
  49. struct ServerInfoVar {
  50. LISTLINK LL;
  51. char *pszName;
  52. char *pszValue;
  53. };
  55. struct ServerConfigData {
  56. RLCK_HANDLE hResLock;
  57. int iWriteLock;
  58. HSLIST hConfigList;
  59. };
  61. static char *SvrGetProfileFilePath(char *pszFilePath, int iMaxPath);
  62. static ServerInfoVar *SvrAllocVar(const char *pszName, const char *pszValue);
  63. static void SvrFreeVar(ServerInfoVar * pSIV);
  64. static void SvrFreeInfoList(HSLIST & hConfigList);
  65. static ServerInfoVar *SvrGetUserVar(HSLIST & hConfigList, const char *pszName);
  66. static int SvrWriteInfoList(HSLIST & hConfigList, FILE * pProfileFile);
  67. static int SvrLoadServerConfig(HSLIST & hConfigList, const char *pszFilePath);
  69. static char *SvrGetProfileFilePath(char *pszFilePath, int iMaxPath)
  70. {
  72. CfgGetRootPath(pszFilePath, iMaxPath);
  74. StrNCat(pszFilePath, SVR_PROFILE_FILE, iMaxPath);
  76. return (pszFilePath);
  78. }
  80. SVRCFG_HANDLE SvrGetConfigHandle(int iWriteLock)
  81. {
  83. char szProfilePath[SYS_MAX_PATH] = "";
  85. SvrGetProfileFilePath(szProfilePath, sizeof(szProfilePath));
  87. ///////////////////////////////////////////////////////////////////////////////
  88. //  Lock the profile resource
  89. ///////////////////////////////////////////////////////////////////////////////
  90. RLCK_HANDLE hResLock = INVALID_RLCK_HANDLE;
  91. char szResLock[SYS_MAX_PATH] = "";
  93. if (iWriteLock) {
  95. if ((hResLock = RLckLockEX(CfgGetBasedPath(szProfilePath, szResLock,
  96.    sizeof(szResLock)))) ==
  97.     INVALID_RLCK_HANDLE)
  98. return (INVALID_SVRCFG_HANDLE);
  100. } else {
  102. if ((hResLock = RLckLockSH(CfgGetBasedPath(szProfilePath, szResLock,
  103.    sizeof(szResLock)))) ==
  104.     INVALID_RLCK_HANDLE)
  105. return (INVALID_SVRCFG_HANDLE);
  107. }
  109. ServerConfigData *pSCD = (ServerConfigData *) SysAlloc(sizeof(ServerConfigData));
  111. if (pSCD == NULL) {
  112. if (iWriteLock)
  113. RLckUnlockEX(hResLock);
  114. else
  115. RLckUnlockSH(hResLock);
  117. return (INVALID_SVRCFG_HANDLE);
  118. }
  120. pSCD->hResLock = hResLock;
  122. pSCD->iWriteLock = iWriteLock;
  124. ListInit(pSCD->hConfigList);
  126. if (SvrLoadServerConfig(pSCD->hConfigList, szProfilePath) < 0) {
  127. if (iWriteLock)
  128. RLckUnlockEX(hResLock);
  129. else
  130. RLckUnlockSH(hResLock);
  132. SysFree(pSCD);
  133. return (INVALID_SVRCFG_HANDLE);
  134. }
  136. return ((SVRCFG_HANDLE) pSCD);
  138. }
  140. void SvrReleaseConfigHandle(SVRCFG_HANDLE hSvrConfig)
  141. {
  143. ServerConfigData *pSCD = (ServerConfigData *) hSvrConfig;
  145. ///////////////////////////////////////////////////////////////////////////////
  146. //  Unlock the profile resource
  147. ///////////////////////////////////////////////////////////////////////////////
  148. if (pSCD->iWriteLock)
  149. RLckUnlockEX(pSCD->hResLock);
  150. else
  151. RLckUnlockSH(pSCD->hResLock);
  153. SvrFreeInfoList(pSCD->hConfigList);
  155. SysFree(pSCD);
  157. }
  159. char *SvrGetConfigVar(SVRCFG_HANDLE hSvrConfig, const char *pszName, const char *pszDefault)
  160. {
  162. ServerConfigData *pSCD = (ServerConfigData *) hSvrConfig;
  164. ServerInfoVar *pSIV = SvrGetUserVar(pSCD->hConfigList, pszName);
  166. if (pSIV != NULL)
  167. return (SysStrDup(pSIV->pszValue));
  169. return ((pszDefault != NULL) ? SysStrDup(pszDefault) : NULL);
  171. }
  173. bool SvrTestConfigFlag(char const *pszName, bool bDefault, SVRCFG_HANDLE hSvrConfig)
  174. {
  176. char szValue[64] = "";
  178. SvrConfigVar(pszName, szValue, sizeof(szValue) - 1, hSvrConfig, (bDefault) ? "1" : "0");
  180. return ((atoi(szValue) != 0) ? true : false);
  182. }
  184. int SvrGetConfigInt(char const *pszName, int iDefault, SVRCFG_HANDLE hSvrConfig)
  185. {
  187. char szValue[64] = "";
  189. return (((SvrConfigVar(pszName, szValue, sizeof(szValue) - 1, hSvrConfig, NULL) < 0) ||
  190.  IsEmptyString(szValue)) ? iDefault : atoi(szValue));
  192. }
  194. int SysFlushConfig(SVRCFG_HANDLE hSvrConfig)
  195. {
  197. ServerConfigData *pSCD = (ServerConfigData *) hSvrConfig;
  199. if (!pSCD->iWriteLock) {
  200. ErrSetErrorCode(ERR_SVR_PRFILE_NOT_LOCKED);
  201. return (ERR_SVR_PRFILE_NOT_LOCKED);
  202. }
  204. char szProfilePath[SYS_MAX_PATH] = "";
  206. SvrGetProfileFilePath(szProfilePath, sizeof(szProfilePath));
  208. char szResLock[SYS_MAX_PATH] = "";
  209. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szProfilePath, szResLock,
  210.   sizeof(szResLock)));
  212. if (hResLock == INVALID_RLCK_HANDLE)
  213. return (ErrGetErrorCode());
  215. FILE *pProfileFile = fopen(szProfilePath, "wt");
  217. if (pProfileFile == NULL) {
  218. RLckUnlockEX(hResLock);
  219. ErrSetErrorCode(ERR_FILE_CREATE);
  220. return (ERR_FILE_CREATE);
  221. }
  223. int iFlushResult = SvrWriteInfoList(pSCD->hConfigList, pProfileFile);
  225. fclose(pProfileFile);
  227. RLckUnlockEX(hResLock);
  229. return (iFlushResult);
  231. }
  233. static ServerInfoVar *SvrAllocVar(const char *pszName, const char *pszValue)
  234. {
  236. ServerInfoVar *pSIV = (ServerInfoVar *) SysAlloc(sizeof(ServerInfoVar));
  238. if (pSIV == NULL)
  239. return (NULL);
  241. ListLinkInit(pSIV);
  242. pSIV->pszName = SysStrDup(pszName);
  243. pSIV->pszValue = SysStrDup(pszValue);
  245. return (pSIV);
  247. }
  249. static void SvrFreeVar(ServerInfoVar * pSIV)
  250. {
  252. SysFree(pSIV->pszName);
  253. SysFree(pSIV->pszValue);
  255. SysFree(pSIV);
  257. }
  259. static void SvrFreeInfoList(HSLIST & hConfigList)
  260. {
  262. ServerInfoVar *pSIV;
  264. while ((pSIV = (ServerInfoVar *) ListRemove(hConfigList)) != INVALID_SLIST_PTR)
  265. SvrFreeVar(pSIV);
  267. }
  269. static ServerInfoVar *SvrGetUserVar(HSLIST & hConfigList, const char *pszName)
  270. {
  272. ServerInfoVar *pSIV = (ServerInfoVar *) ListFirst(hConfigList);
  274. for (; pSIV != INVALID_SLIST_PTR; pSIV = (ServerInfoVar *)
  275.      ListNext(hConfigList, (PLISTLINK) pSIV))
  276. if (strcmp(pSIV->pszName, pszName) == 0)
  277. return (pSIV);
  279. return (NULL);
  281. }
  283. static int SvrWriteInfoList(HSLIST & hConfigList, FILE * pProfileFile)
  284. {
  286. ServerInfoVar *pSIV = (ServerInfoVar *) ListFirst(hConfigList);
  288. for (; pSIV != INVALID_SLIST_PTR; pSIV = (ServerInfoVar *)
  289.      ListNext(hConfigList, (PLISTLINK) pSIV)) {
  290. ///////////////////////////////////////////////////////////////////////////////
  291. //  Write variabile name
  292. ///////////////////////////////////////////////////////////////////////////////
  293. char *pszQuoted = StrQuote(pSIV->pszName, '"');
  295. if (pszQuoted == NULL)
  296. return (ErrGetErrorCode());
  298. fprintf(pProfileFile, "%st", pszQuoted);
  300. SysFree(pszQuoted);
  302. ///////////////////////////////////////////////////////////////////////////////
  303. //  Write variabile value
  304. ///////////////////////////////////////////////////////////////////////////////
  305. pszQuoted = StrQuote(pSIV->pszValue, '"');
  307. if (pszQuoted == NULL)
  308. return (ErrGetErrorCode());
  310. fprintf(pProfileFile, "%sn", pszQuoted);
  312. SysFree(pszQuoted);
  313. }
  315. return (0);
  317. }
  319. static int SvrLoadServerConfig(HSLIST & hConfigList, const char *pszFilePath)
  320. {
  322. char szResLock[SYS_MAX_PATH] = "";
  323. RLCK_HANDLE hResLock = RLckLockSH(CfgGetBasedPath(pszFilePath, szResLock,
  324.   sizeof(szResLock)));
  326. if (hResLock == INVALID_RLCK_HANDLE)
  327. return (ErrGetErrorCode());
  329. FILE *pProfileFile = fopen(pszFilePath, "rt");
  331. if (pProfileFile == NULL) {
  332. RLckUnlockSH(hResLock);
  334. ErrSetErrorCode(ERR_NO_USER_PRFILE);
  335. return (ERR_NO_USER_PRFILE);
  336. }
  338. char szProfileLine[SVR_PROFILE_LINE_MAX] = "";
  340. while (MscGetConfigLine(szProfileLine, sizeof(szProfileLine) - 1, pProfileFile) != NULL) {
  341. char **ppszStrings = StrGetTabLineStrings(szProfileLine);
  343. if (ppszStrings == NULL)
  344. continue;
  346. int iFieldsCount = StrStringsCount(ppszStrings);
  348. if (iFieldsCount == 2) {
  349. ServerInfoVar *pSIV = SvrAllocVar(ppszStrings[0], ppszStrings[1]);
  351. if (pSIV != NULL)
  352. ListAddTail(hConfigList, (PLISTLINK) pSIV);
  353. }
  355. StrFreeStrings(ppszStrings);
  356. }
  358. fclose(pProfileFile);
  360. RLckUnlockSH(hResLock);
  362. return (0);
  364. }
  366. int SvrGetMessageID(SYS_UINT64 * pullMessageID)
  367. {
  369. char szMsgIDFile[SYS_MAX_PATH] = "";
  371. CfgGetRootPath(szMsgIDFile, sizeof(szMsgIDFile));
  372. StrNCat(szMsgIDFile, MESSAGEID_FILE, sizeof(szMsgIDFile));
  374. char szResLock[SYS_MAX_PATH] = "";
  375. RLCK_HANDLE hResLock = RLckLockEX(CfgGetBasedPath(szMsgIDFile, szResLock,
  376.   sizeof(szResLock)));
  378. if (hResLock == INVALID_RLCK_HANDLE)
  379. return (ErrGetErrorCode());
  381. FILE *pMsgIDFile = fopen(szMsgIDFile, "r+b");
  383. if (pMsgIDFile == NULL) {
  384. if ((pMsgIDFile = fopen(szMsgIDFile, "wb")) == NULL) {
  385. RLckUnlockEX(hResLock);
  387. ErrSetErrorCode(ERR_FILE_CREATE, szMsgIDFile);
  388. return (ERR_FILE_CREATE);
  389. }
  390. *pullMessageID = 1;
  391. } else {
  392. char szMessageID[128] = "";
  394. if ((MscGetString(pMsgIDFile, szMessageID, sizeof(szMessageID) - 1) == NULL) ||
  395.     !isdigit(szMessageID[0])) {
  396. fclose(pMsgIDFile);
  397. RLckUnlockEX(hResLock);
  399. ErrSetErrorCode(ERR_INVALID_FILE, szMsgIDFile);
  400. return (ERR_INVALID_FILE);
  401. }
  402. if (sscanf(szMessageID, SYS_LLU_FMT, pullMessageID) != 1) {
  403. fclose(pMsgIDFile);
  404. RLckUnlockEX(hResLock);
  406. ErrSetErrorCode(ERR_INVALID_FILE, szMsgIDFile);
  407. return (ERR_INVALID_FILE);
  408. }
  409. }
  411. ++*pullMessageID;
  413. fseek(pMsgIDFile, 0, SEEK_SET);
  415. fprintf(pMsgIDFile, SYS_LLU_FMT "rn", *pullMessageID);
  417. fclose(pMsgIDFile);
  419. RLckUnlockEX(hResLock);
  421. return (0);
  423. }
  425. char *SvrGetLogsDir(char *pszLogsPath, int iMaxPath)
  426. {
  428. CfgGetRootPath(pszLogsPath, iMaxPath);
  429. StrNCat(pszLogsPath, SVR_LOGS_DIR, iMaxPath);
  431. return (pszLogsPath);
  433. }
  435. char *SvrGetSpoolDir(char *pszSpoolPath, int iMaxPath)
  436. {
  438. CfgGetRootPath(pszSpoolPath, iMaxPath);
  439. StrNCat(pszSpoolPath, SMTP_SPOOL_DIR, iMaxPath);
  441. return (pszSpoolPath);
  443. }
  445. int SvrConfigVar(char const *pszVarName, char *pszVarValue, int iMaxVarValue,
  446.  SVRCFG_HANDLE hSvrConfig, char const *pszDefault)
  447. {
  449. int iReleaseConfig = 0;
  451. if (hSvrConfig == INVALID_SVRCFG_HANDLE) {
  452. if ((hSvrConfig = SvrGetConfigHandle()) == INVALID_SVRCFG_HANDLE)
  453. return (ErrGetErrorCode());
  455. ++iReleaseConfig;
  456. }
  458. char *pszValue = SvrGetConfigVar(hSvrConfig, pszVarName, pszDefault);
  460. if (pszValue == NULL) {
  461. if (iReleaseConfig)
  462. SvrReleaseConfigHandle(hSvrConfig);
  464. ErrSetErrorCode(ERR_CFG_VAR_NOT_FOUND);
  465. return (ERR_CFG_VAR_NOT_FOUND);
  466. }
  468. strncpy(pszVarValue, pszValue, iMaxVarValue - 1);
  469. pszVarValue[iMaxVarValue - 1] = '';
  471. SysFree(pszValue);
  473. if (iReleaseConfig)
  474. SvrReleaseConfigHandle(hSvrConfig);
  476. return (0);
  478. }
  480. int SvrCheckDiskSpace(unsigned long ulMinSpace)
  481. {
  483. time_t tNow = time(NULL);
  484. static SYS_INT64 FreeSpace = 0;
  485. static time_t tLastCheck = 0;
  487. if (tNow > (tLastCheck + SYS_RES_CHECK_INTERVAL)) {
  488. SYS_INT64 TotalSpace;
  489. char szRootDir[SYS_MAX_PATH] = "";
  491. tLastCheck = tNow;
  493. CfgGetRootPath(szRootDir, sizeof(szRootDir));
  495. if (SysGetDiskSpace(szRootDir, &TotalSpace, &FreeSpace) < 0)
  496. return (ErrGetErrorCode());
  498. }
  500. if (FreeSpace < (SYS_INT64) ulMinSpace) {
  501. ErrSetErrorCode(ERR_LOW_DISK_SPACE);
  502. return (ERR_LOW_DISK_SPACE);
  503. }
  505. return (0);
  507. }
  509. int SvrCheckVirtMemSpace(unsigned long ulMinSpace)
  510. {
  512. time_t tNow = time(NULL);
  513. static SYS_INT64 FreeSpace = 0;
  514. static time_t tLastCheck = 0;
  516. if (tNow > (tLastCheck + SYS_RES_CHECK_INTERVAL)) {
  517. tLastCheck = tNow;
  519. SYS_INT64 RamTotal;
  520. SYS_INT64 RamFree;
  521. SYS_INT64 VirtTotal;
  523. if (SysMemoryInfo(&RamTotal, &RamFree, &VirtTotal, &FreeSpace) < 0)
  524. return (ErrGetErrorCode());
  526. }
  528. if (FreeSpace < (SYS_INT64) ulMinSpace) {
  529. ErrSetErrorCode(ERR_LOW_VM_SPACE);
  530. return (ERR_LOW_VM_SPACE);
  531. }
  533. return (0);
  535. }