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

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

Email服务器

开发平台：

Visual C++

ResLocks.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 "BuffSock.h"
  29. #include "MiscUtils.h"
  30. #include "MessQueue.h"
  31. #include "MailConfig.h"
  32. #include "MailSvr.h"
  34. #define STD_WAIT_GATES              37
  35. #define STD_RES_HASH_SIZE           251
  36. #define STD_RLCK_HASH_INIT          9677
  38. struct ResWaitGate {
  39. SYS_SEMAPHORE hSemaphore;
  40. int iWaitingProcesses;
  41. int iHashSize;
  42. SysListHead *pResList;
  43. };
  45. struct ResLockEntry {
  46. SysListHead LLink;
  47. int iShLocks;
  48. int iExLocks;
  49. char szName[1];
  50. };
  52. struct ResLocator {
  53. int iWaitGate;
  54. int iResIdx;
  55. };
  57. static SYS_UINT32 RLckHashString(char const *pData, SYS_UINT32 uHashInit = STD_RLCK_HASH_INIT);
  58. static void RLckGetResLocator(char const *pszResourceName, ResLocator * pRL);
  59. static ResLockEntry *RLckGetEntry(ResLocator const *pRL, char const *pszResourceName);
  60. static int RLckRemoveEntry(ResLocator const *pRL, ResLockEntry * pRLE);
  61. static ResLockEntry *RLckAllocEntry(char const *pszResourceName);
  62. static int RLckFreeEntry(ResLockEntry * pRLE);
  63. static int RLckTryLockEX(ResLocator const *pRL, char const *pszResourceName);
  64. static int RLckDoUnlockEX(ResLocator const *pRL, char const *pszResourceName);
  65. static int RLckTryLockSH(ResLocator const *pRL, char const *pszResourceName);
  66. static int RLckDoUnlockSH(ResLocator const *pRL, char const *pszResourceName);
  67. static RLCK_HANDLE RLckLock(char const *pszResourceName,
  68.     int (*pLockProc) (ResLocator const *, char const *));
  69. static int RLckUnlock(RLCK_HANDLE hLock, int (*pUnlockProc) (ResLocator const *, char const *));
  71. static SYS_MUTEX hRLMutex = SYS_INVALID_MUTEX;
  72. static ResWaitGate RLGates[STD_WAIT_GATES];
  74. int RLckInitLockers(void)
  75. {
  76. ///////////////////////////////////////////////////////////////////////////////
  77. //  Create resource locking mutex
  78. ///////////////////////////////////////////////////////////////////////////////
  79. if ((hRLMutex = SysCreateMutex()) == SYS_INVALID_MUTEX)
  80. return (ErrGetErrorCode());
  82. ///////////////////////////////////////////////////////////////////////////////
  83. //  Initialize wait gates
  84. ///////////////////////////////////////////////////////////////////////////////
  85. for (int ii = 0; ii < STD_WAIT_GATES; ii++) {
  86. if ((RLGates[ii].hSemaphore = SysCreateSemaphore(0,
  87.  SYS_DEFAULT_MAXCOUNT)) ==
  88.     SYS_INVALID_SEMAPHORE) {
  89. ErrorPush();
  91. for (--ii; ii >= 0; ii--) {
  92. SysFree(RLGates[ii].pResList);
  93. SysCloseSemaphore(RLGates[ii].hSemaphore);
  94. }
  96. SysCloseMutex(hRLMutex);
  97. return (ErrorPop());
  98. }
  100. RLGates[ii].iWaitingProcesses = 0;
  101. RLGates[ii].iHashSize = STD_RES_HASH_SIZE;
  103. if ((RLGates[ii].pResList = (SysListHead *)
  104.      SysAlloc(RLGates[ii].iHashSize * sizeof(SysListHead))) == NULL) {
  105. ErrorPush();
  107. SysCloseSemaphore(RLGates[ii].hSemaphore);
  108. for (--ii; ii >= 0; ii--) {
  109. SysFree(RLGates[ii].pResList);
  110. SysCloseSemaphore(RLGates[ii].hSemaphore);
  111. }
  113. SysCloseMutex(hRLMutex);
  114. return (ErrorPop());
  115. }
  117. for (int jj = 0; jj < RLGates[ii].iHashSize; jj++)
  118. SYS_INIT_LIST_HEAD(&RLGates[ii].pResList[jj]);
  119. }
  121. return (0);
  123. }
  125. int RLckCleanupLockers(void)
  126. {
  128. SysLockMutex(hRLMutex, SYS_INFINITE_TIMEOUT);
  130. for (int ii = 0; ii < STD_WAIT_GATES; ii++) {
  131. for (int jj = 0; jj < RLGates[ii].iHashSize; jj++) {
  132. SysListHead *pHead = &RLGates[ii].pResList[jj];
  133. SysListHead *pLLink;
  135. while ((pLLink = SYS_LIST_FIRST(pHead)) != NULL) {
  136. ResLockEntry *pRLE = SYS_LIST_ENTRY(pLLink, ResLockEntry, LLink);
  138. SYS_LIST_DEL(&pRLE->LLink);
  140. RLckFreeEntry(pRLE);
  141. }
  142. }
  144. SysFree(RLGates[ii].pResList);
  145. SysCloseSemaphore(RLGates[ii].hSemaphore);
  146. }
  148. SysUnlockMutex(hRLMutex);
  150. SysCloseMutex(hRLMutex);
  152. return (0);
  154. }
  156. static SYS_UINT32 RLckHashString(char const *pData, SYS_UINT32 uHashInit)
  157. {
  159. SYS_UINT32 uHashVal = uHashInit;
  161. while (*pData) {
  162. uHashVal += (uHashVal << 5);
  163. uHashVal ^= (SYS_UINT32) ToLower(*pData);
  164. pData++;
  165. }
  167. return (uHashVal);
  169. }
  171. static void RLckGetResLocator(char const *pszResourceName, ResLocator * pRL)
  172. {
  174. SYS_UINT32 uResHash = RLckHashString(pszResourceName);
  176. pRL->iWaitGate = (int) (uResHash % STD_WAIT_GATES);
  177. pRL->iResIdx = (int) (uResHash % (SYS_UINT32) RLGates[pRL->iWaitGate].iHashSize);
  179. }
  181. static ResLockEntry *RLckGetEntry(ResLocator const *pRL, char const *pszResourceName)
  182. {
  184. SysListHead *pHead = &RLGates[pRL->iWaitGate].pResList[pRL->iResIdx];
  185. SysListHead *pLLink;
  187. SYS_LIST_FOR_EACH(pLLink, pHead) {
  188. ResLockEntry *pRLE = SYS_LIST_ENTRY(pLLink, ResLockEntry, LLink);
  190. if (stricmp(pszResourceName, pRLE->szName) == 0)
  191. return (pRLE);
  193. }
  195. ErrSetErrorCode(ERR_LOCK_ENTRY_NOT_FOUND);
  197. return (NULL);
  199. }
  201. static int RLckRemoveEntry(ResLocator const *pRL, ResLockEntry * pRLE)
  202. {
  204. SysListHead *pHead = &RLGates[pRL->iWaitGate].pResList[pRL->iResIdx];
  205. SysListHead *pLLink;
  207. SYS_LIST_FOR_EACH(pLLink, pHead) {
  208. ResLockEntry *pCurrRLE = SYS_LIST_ENTRY(pLLink, ResLockEntry, LLink);
  210. if (pCurrRLE == pRLE) {
  211. SYS_LIST_DEL(&pRLE->LLink);
  213. RLckFreeEntry(pRLE);
  215. return (0);
  216. }
  217. }
  219. ErrSetErrorCode(ERR_LOCK_ENTRY_NOT_FOUND);
  220. return (ERR_LOCK_ENTRY_NOT_FOUND);
  222. }
  224. static ResLockEntry *RLckAllocEntry(char const *pszResourceName)
  225. {
  227. ResLockEntry *pRLE = (ResLockEntry *) SysAlloc(sizeof(ResLockEntry) +
  228.        strlen(pszResourceName));
  230. if (pRLE == NULL)
  231. return (NULL);
  233. SYS_INIT_LIST_LINK(&pRLE->LLink);
  234. pRLE->iShLocks = 0;
  235. pRLE->iExLocks = 0;
  236. strcpy(pRLE->szName, pszResourceName);
  238. return (pRLE);
  240. }
  242. static int RLckFreeEntry(ResLockEntry * pRLE)
  243. {
  245. SysFree(pRLE);
  247. return (0);
  249. }
  251. static int RLckTryLockEX(ResLocator const *pRL, char const *pszResourceName)
  252. {
  254. ResLockEntry *pRLE = RLckGetEntry(pRL, pszResourceName);
  256. if (pRLE == NULL) {
  257. SysListHead *pHead = &RLGates[pRL->iWaitGate].pResList[pRL->iResIdx];
  259. if ((pRLE = RLckAllocEntry(pszResourceName)) == NULL)
  260. return (ErrGetErrorCode());
  262. pRLE->iExLocks = 1;
  264. ///////////////////////////////////////////////////////////////////////////////
  265. //  Insert new entry in resource list
  266. ///////////////////////////////////////////////////////////////////////////////
  267. SYS_LIST_ADDH(&pRLE->LLink, pHead);
  269. } else {
  270. if ((pRLE->iExLocks > 0) || (pRLE->iShLocks > 0)) {
  271. ErrSetErrorCode(ERR_LOCKED_RESOURCE);
  272. return (ERR_LOCKED_RESOURCE);
  273. }
  275. pRLE->iExLocks = 1;
  276. }
  278. return (0);
  280. }
  282. static int RLckDoUnlockEX(ResLocator const *pRL, char const *pszResourceName)
  283. {
  285. ResLockEntry *pRLE = RLckGetEntry(pRL, pszResourceName);
  287. if ((pRLE == NULL) || (pRLE->iExLocks == 0)) {
  288. ErrSetErrorCode(ERR_RESOURCE_NOT_LOCKED);
  289. return (ERR_RESOURCE_NOT_LOCKED);
  290. }
  292. pRLE->iExLocks = 0;
  294. ///////////////////////////////////////////////////////////////////////////////
  295. //  Remove entry from list and delete entry memory
  296. ///////////////////////////////////////////////////////////////////////////////
  297. if (RLckRemoveEntry(pRL, pRLE) < 0)
  298. return (ErrGetErrorCode());
  300. ///////////////////////////////////////////////////////////////////////////////
  301. //  Release waiting processes
  302. ///////////////////////////////////////////////////////////////////////////////
  303. if (RLGates[pRL->iWaitGate].iWaitingProcesses > 0) {
  304. SysReleaseSemaphore(RLGates[pRL->iWaitGate].hSemaphore,
  305.     RLGates[pRL->iWaitGate].iWaitingProcesses);
  307. RLGates[pRL->iWaitGate].iWaitingProcesses = 0;
  308. }
  310. return (0);
  312. }
  314. static int RLckTryLockSH(ResLocator const *pRL, char const *pszResourceName)
  315. {
  317. ResLockEntry *pRLE = RLckGetEntry(pRL, pszResourceName);
  319. if (pRLE == NULL) {
  320. SysListHead *pHead = &RLGates[pRL->iWaitGate].pResList[pRL->iResIdx];
  322. if ((pRLE = RLckAllocEntry(pszResourceName)) == NULL)
  323. return (ErrGetErrorCode());
  325. pRLE->iShLocks = 1;
  327. ///////////////////////////////////////////////////////////////////////////////
  328. //  Insert new entry in resource list
  329. ///////////////////////////////////////////////////////////////////////////////
  330. SYS_LIST_ADDH(&pRLE->LLink, pHead);
  332. } else {
  333. if (pRLE->iExLocks > 0) {
  334. ErrSetErrorCode(ERR_LOCKED_RESOURCE);
  335. return (ERR_LOCKED_RESOURCE);
  336. }
  338. ++pRLE->iShLocks;
  339. }
  341. return (0);
  343. }
  345. static int RLckDoUnlockSH(ResLocator const *pRL, char const *pszResourceName)
  346. {
  348. ResLockEntry *pRLE = RLckGetEntry(pRL, pszResourceName);
  350. if ((pRLE == NULL) || (pRLE->iShLocks == 0)) {
  351. ErrSetErrorCode(ERR_RESOURCE_NOT_LOCKED);
  352. return (ERR_RESOURCE_NOT_LOCKED);
  353. }
  355. if (--pRLE->iShLocks == 0) {
  356. ///////////////////////////////////////////////////////////////////////////////
  357. //  Remove entry from list and delete entry heap memory
  358. ///////////////////////////////////////////////////////////////////////////////
  359. if (RLckRemoveEntry(pRL, pRLE) < 0)
  360. return (ErrGetErrorCode());
  362. ///////////////////////////////////////////////////////////////////////////////
  363. //  Release waiting processes
  364. ///////////////////////////////////////////////////////////////////////////////
  365. if (RLGates[pRL->iWaitGate].iWaitingProcesses > 0) {
  366. SysReleaseSemaphore(RLGates[pRL->iWaitGate].hSemaphore,
  367.     RLGates[pRL->iWaitGate].iWaitingProcesses);
  369. RLGates[pRL->iWaitGate].iWaitingProcesses = 0;
  370. }
  371. }
  373. return (0);
  375. }
  377. static RLCK_HANDLE RLckLock(char const *pszResourceName,
  378.     int (*pLockProc) (ResLocator const *, char const *))
  379. {
  381. ResLocator RL;
  383. RLckGetResLocator(pszResourceName, &RL);
  385. for (;;) {
  386. ///////////////////////////////////////////////////////////////////////////////
  387. //  Lock resources list access
  388. ///////////////////////////////////////////////////////////////////////////////
  389. if (SysLockMutex(hRLMutex, SYS_INFINITE_TIMEOUT) < 0)
  390. return (INVALID_RLCK_HANDLE);
  392. int iLockResult = pLockProc(&RL, pszResourceName);
  394. if (iLockResult == ERR_LOCKED_RESOURCE) {
  395. SYS_SEMAPHORE SemID = RLGates[RL.iWaitGate].hSemaphore;
  397. ++RLGates[RL.iWaitGate].iWaitingProcesses;
  399. SysUnlockMutex(hRLMutex);
  401. if (SysWaitSemaphore(SemID, SYS_INFINITE_TIMEOUT) < 0)
  402. return (INVALID_RLCK_HANDLE);
  404. } else if (iLockResult == 0) {
  405. SysUnlockMutex(hRLMutex);
  407. break;
  408. } else {
  409. SysUnlockMutex(hRLMutex);
  411. return (INVALID_RLCK_HANDLE);
  412. }
  413. }
  415. return ((RLCK_HANDLE) SysStrDup(pszResourceName));
  417. }
  419. static int RLckUnlock(RLCK_HANDLE hLock, int (*pUnlockProc) (ResLocator const *, char const *))
  420. {
  422. char *pszResourceName = (char *) hLock;
  423. ResLocator RL;
  425. RLckGetResLocator(pszResourceName, &RL);
  427. ///////////////////////////////////////////////////////////////////////////////
  428. //  Lock resources list access
  429. ///////////////////////////////////////////////////////////////////////////////
  430. if (SysLockMutex(hRLMutex, SYS_INFINITE_TIMEOUT) < 0)
  431. return (ErrGetErrorCode());
  433. if (pUnlockProc(&RL, pszResourceName) < 0) {
  434. ErrorPush();
  435. SysUnlockMutex(hRLMutex);
  436. SysFree(pszResourceName);
  437. return (ErrorPop());
  438. }
  440. SysUnlockMutex(hRLMutex);
  442. SysFree(pszResourceName);
  444. return (0);
  446. }
  448. RLCK_HANDLE RLckLockEX(char const *pszResourceName)
  449. {
  451. return (RLckLock(pszResourceName, RLckTryLockEX));
  453. }
  455. int RLckUnlockEX(RLCK_HANDLE hLock)
  456. {
  458. return (RLckUnlock(hLock, RLckDoUnlockEX));
  460. }
  462. RLCK_HANDLE RLckLockSH(char const *pszResourceName)
  463. {
  465. return (RLckLock(pszResourceName, RLckTryLockSH));
  467. }
  469. int RLckUnlockSH(RLCK_HANDLE hLock)
  470. {
  472. return (RLckUnlock(hLock, RLckDoUnlockSH));
  474. }