table.cpp
上传用户:filter2008
上传日期:2013-02-01
资源大小:101k
文件大小:8k
源码类别:

CA认证

开发平台:

C/C++

  1. /****************************************************************************
  2. * library : pkcs_csp.dll
  3. * Purpose : It is a cryptographic service provider which is an independent 
  4. * software module that actually performs cryptography algorithms for 
  5. * authentication, encoding, and encryption.
  6. * This DLL can be interfaced on any PKCS#11 module.  
  7. *
  8. * Copyright (C) 2003 Ilex Syst鑝es Informatiques
  9. *
  10. * This library is free software; you can redistribute it and/or
  11. * modify it under the terms of the GNU Lesser General Public
  12. * License as published by the Free Software Foundation; either
  13. * version 2.1 of the License, or (at your option) any later version.
  14. *
  15. * This library is distributed in the hope that it will be useful,
  16. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18. * Lesser General Public License for more details.
  19. *
  20. * You should have received a copy of the GNU Lesser General Public
  21. * License along with this library; if not, write to the Free Software
  22. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  23. *
  24. * Contact :
  25. * Ilex 
  26. * 51 boulevard Voltaire
  27. * 92600 Asni鑢es-sur-Seine
  28. * pkizy@ilex.fr
  29. *
  30. * Author: Delouvrier Antoine
  31. *
  32. *******************************************************************************/
  33. /*
  34. %----------------------------------------------------------------------------
  35. % PROJECT : CSP_PKCS
  36. %
  37. % MODULE : TableOfHandle
  38. %
  39. % VERSION : 1.00
  40. %
  41. % FILE : table.cpp
  42. %
  43. % TableOfHandle: class allows to manage a table of handle
  44. %----------------------------------------------------------------------------
  45. % Version 1.00
  46. % CPX-31/03/2003-Creation
  47. %----------------------------------------------------------------------------
  48. */
  49. /*
  50. % Libraries ANSI or system
  51. %------------------------------
  52. */
  53. #include <windows.h>
  54. /*
  55. % HEADER Files include
  56. %-----------------------
  57. */
  58. #include "table.h"
  59. /*
  60. %--------------------------------------------------------------------------
  61. % TableOfHandle()
  62. %
  63. % TableOfHandle() constructor
  64. %
  65. %---------------------------------------------------------------------------
  66. */
  67. TableOfHandle::TableOfHandle()
  68. {
  69. //Initialize the table
  70. entryTableUsed = 0;
  71. InitializeCriticalSection(&critical_object);
  72. pTable = new void*[INITIAL_SIZE];
  73. if(!pTable)
  74. {
  75. tableSize = 0;
  76. return;
  77. }
  78. memset(pTable,NO_ENTRY,INITIAL_SIZE*sizeof(void*));
  79. tableSize = INITIAL_SIZE;
  80. }
  81. /*
  82. %--------------------------------------------------------------------------
  83. % ~TableOfHandle()
  84. %
  85. % R鬺e : ~TableOfHandle() destructor 
  86. %
  87. */
  88. TableOfHandle::~TableOfHandle()
  89. {
  90. DeleteCriticalSection(&critical_object);
  91. if(pTable)
  92. delete[] pTable;
  93. }
  94. /*
  95. %--------------------------------------------------------------------------
  96. % AddEntry
  97. %
  98. % Adds a new handle to the table.
  99. %
  100. % Parameters of entry  :
  101. % IN const void * const IN pHandle: The handle to add
  102. %  
  103. % return : bool : true if it was successful, false otherwise.
  104. %---------------------------------------------------------------------------
  105. */
  106. bool TableOfHandle::AddEntry(void * const IN pEntry)
  107. {
  108. EnterCriticalSection(&critical_object);
  109. if(pEntry==(void*)DELETED_ENTRY || pEntry==(void*)NO_ENTRY  )
  110. return false;
  111. // We must extend the size of the table
  112. if(entryTableUsed >= tableSize)
  113. {
  114. if(!ExtendSize())
  115. {
  116. LeaveCriticalSection(&critical_object);
  117. return false;
  118. }
  119. }
  120. // is entry already exist
  121. if(VerifyEntry(pEntry))
  122. {
  123. LeaveCriticalSection(&critical_object);
  124. return true;
  125. }
  126. int i = GetIndex(pEntry);
  127. for(; pTable[i] != (void*)NO_ENTRY && pTable[i] != (void*)DELETED_ENTRY;i = (i + 1) % tableSize);
  128. pTable[i] = pEntry;
  129. ++entryTableUsed;
  130. LeaveCriticalSection(&critical_object);
  131. return true;
  132. }
  133. /*
  134. %--------------------------------------------------------------------------
  135. % RemoveEntry
  136. %
  137. % Removes a handle from the table.
  138. %
  139. % Parameters of entry  :
  140. % IN const void * const IN pHandle: The handle to be removed
  141. %  
  142. % return : const void * const IN pHandle: The handle to be removed
  143. %---------------------------------------------------------------------------
  144. */
  145. void TableOfHandle::RemoveEntry(const void * const IN pEntry)
  146. {
  147. EnterCriticalSection(&critical_object);
  148. if(pEntry==(void*)DELETED_ENTRY || pEntry==(void*)NO_ENTRY  )
  149. return;
  150. int i = GetIndex(pEntry);
  151. int itmp = i;
  152. do
  153. {
  154. if(pTable[i] == pEntry)
  155. {
  156. pTable[i] = (void*)DELETED_ENTRY;
  157.         --entryTableUsed;
  158. break;
  159. }
  160. i = (i + 1)%tableSize;
  161. }while(i != itmp && pTable[i] != (void*)NO_ENTRY);
  162. LeaveCriticalSection(&critical_object);
  163. }
  164. /*
  165. %--------------------------------------------------------------------------
  166. % GetNext
  167. %
  168. % Gets the next item out of the handle table
  169. %
  170. % Parameters of entry  :
  171. % int& i: Where to start looking for the next item.
  172. %
  173. %  
  174. % return : void* : A ptr to the item, if there is one, NULL otherwise
  175. %---------------------------------------------------------------------------
  176. */
  177. void* TableOfHandle::GetNext(int& i)
  178. {
  179. EnterCriticalSection(&critical_object);
  180. if(i < 0)
  181. return NULL;
  182. while(i < tableSize)
  183. {
  184. void* pEntry = pTable[i++];
  185. if(pEntry != (void*)DELETED_ENTRY && pEntry != (void*)NO_ENTRY)
  186. {
  187. LeaveCriticalSection(&critical_object);
  188. return pEntry;
  189. }
  190. }
  191. LeaveCriticalSection(&critical_object);
  192. return NULL;
  193. }
  194. /*
  195. %--------------------------------------------------------------------------
  196. % VerifyEntry()
  197. %
  198. % Verify the entry specified
  199. %
  200. % Parameters of entry  :
  201. % IN const void * const IN pHandle: The handle to be checked for validity
  202. %  
  203. % return : bool : true if checked, false otherwise.
  204. %---------------------------------------------------------------------------
  205. */
  206. bool TableOfHandle::VerifyEntry(const void * const IN pEntry)
  207. {
  208. if(0 == entryTableUsed)
  209. return false;
  210. EnterCriticalSection(&critical_object);
  211. if(pEntry == (void*)DELETED_ENTRY|| pEntry == (void*)NO_ENTRY)
  212. {
  213. LeaveCriticalSection(&critical_object);
  214. return false;
  215. }
  216. int i = GetIndex(pEntry);
  217. int itmp = i;
  218. bool result = false;
  219. do
  220. {
  221. if(pTable[i] == pEntry)
  222. result = true;
  223. i = (i + 1)%tableSize;
  224. }while(i != itmp && pTable[i] != (void*)NO_ENTRY);
  225. LeaveCriticalSection(&critical_object);
  226. return result;
  227. }
  228. /****************************************************************************/
  229. /* */
  230. /* PRIVATE */
  231. /* */
  232. /****************************************************************************/
  233. /*
  234. %--------------------------------------------------------------------------
  235. % GetIndex()
  236. %
  237. % Get the index of the handle item in the hashtable.
  238. %
  239. % Parameters of entry  :
  240. % IN void * const IN pHandle: The handle to find the index of.
  241. %  
  242. % return  : int : the initial index of the item in the hashtable.
  243. %---------------------------------------------------------------------------
  244. */
  245. int TableOfHandle::GetIndex(const void * const IN pEntry)
  246. {
  247. return ((int)pEntry >> 2) % tableSize;
  248. }
  249. /*
  250. %--------------------------------------------------------------------------
  251. % ExtendSize
  252. %
  253. %   Extend the size of the table 
  254. %  
  255. % return : bool : Returns true if the table could be extended.
  256. %---------------------------------------------------------------------------
  257. */
  258. bool TableOfHandle::ExtendSize()
  259. {
  260. int oldTableSize = tableSize;
  261. tableSize = (int)(tableSize*EXTEND_FACTOR);
  262. void** pTmpHandleTable = new void*[tableSize];
  263. if(!pTmpHandleTable)
  264. {
  265. tableSize = oldTableSize;
  266. return false;
  267. }
  268. entryTableUsed = 0;
  269. memset(pTmpHandleTable, NO_ENTRY, tableSize*sizeof(void*));
  270. void** pOldHandleTable = pTable;
  271. pTable = pTmpHandleTable;
  272. for(int i = 0; i< oldTableSize; ++i)
  273. AddEntry(pOldHandleTable[i]);
  274. delete [] pOldHandleTable;
  275. return true;
  276. }