OLD | NEW |
1 /* This Source Code Form is subject to the terms of the Mozilla Public | 1 /* This Source Code Form is subject to the terms of the Mozilla Public |
2 * License, v. 2.0. If a copy of the MPL was not distributed with this | 2 * License, v. 2.0. If a copy of the MPL was not distributed with this |
3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ | 3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ |
4 /* | 4 /* |
5 * pkix_pl_hashtable.c | 5 * pkix_pl_hashtable.c |
6 * | 6 * |
7 * Hashtable Object Functions | 7 * Hashtable Object Functions |
8 * | 8 * |
9 */ | 9 */ |
10 | 10 |
11 #include "pkix_pl_hashtable.h" | 11 #include "pkix_pl_hashtable.h" |
12 | 12 |
13 /* --Private-Structure-------------------------------------------- */ | 13 /* --Private-Structure-------------------------------------------- */ |
14 | 14 |
15 struct PKIX_PL_HashTableStruct { | 15 struct PKIX_PL_HashTableStruct { |
16 pkix_pl_PrimHashTable *primHash; | 16 pkix_pl_PrimHashTable *primHash; |
17 PKIX_PL_Mutex *tableLock; | 17 PKIX_PL_Mutex *tableLock; |
18 PKIX_UInt32 maxEntriesPerBucket; | 18 PKIX_UInt32 maxEntriesPerBucket; |
19 }; | 19 }; |
20 | 20 |
21 /* --Private-Functions-------------------------------------------- */ | 21 /* --Private-Functions-------------------------------------------- */ |
22 | 22 |
23 #define PKIX_MUTEX_UNLOCK(mutex) \ | 23 #define PKIX_MUTEX_UNLOCK(mutex) \ |
24 do { \ | 24 do { \ |
25 if (mutex && lockedMutex == (PKIX_PL_Mutex *)(mutex)) { \ | 25 if (mutex && lockedMutex == (PKIX_PL_Mutex *)(mutex)) { \ |
26 pkixTempResult = \ | 26 pkixTempResult = PKIX_PL_Mutex_Unlock((mutex), plContext); \ |
27 PKIX_PL_Mutex_Unlock((mutex), plContext); \ | 27 PORT_Assert(pkixTempResult == NULL); \ |
28 PORT_Assert(pkixTempResult == NULL); \ | 28 if (pkixTempResult) { \ |
29 if (pkixTempResult) { \ | 29 PKIX_DoAddError(&stdVars, pkixTempResult, plContext); \ |
30 PKIX_DoAddError(&stdVars, pkixTempResult, plContext); \ | 30 pkixTempResult = NULL; \ |
31 pkixTempResult = NULL; \ | 31 } \ |
32 } \ | 32 lockedMutex = NULL; \ |
33 lockedMutex = NULL; \ | 33 } else { \ |
34 } else { \ | 34 PORT_Assert(lockedMutex == NULL); \ |
35 PORT_Assert(lockedMutex == NULL); \ | 35 } \ |
36 }\ | 36 } while (0) |
37 } while (0) | 37 |
38 | 38 #define PKIX_MUTEX_LOCK(mutex) \ |
39 | 39 do { \ |
40 #define PKIX_MUTEX_LOCK(mutex) \ | 40 if (mutex) { \ |
41 do { \ | 41 PORT_Assert(lockedMutex == NULL); \ |
42 if (mutex){ \ | 42 PKIX_CHECK(PKIX_PL_Mutex_Lock((mutex), plContext), \ |
43 PORT_Assert(lockedMutex == NULL); \ | 43 PKIX_MUTEXLOCKFAILED); \ |
44 PKIX_CHECK(PKIX_PL_Mutex_Lock((mutex), plContext), \ | 44 lockedMutex = (mutex); \ |
45 PKIX_MUTEXLOCKFAILED); \ | 45 } \ |
46 lockedMutex = (mutex); \ | 46 } while (0) |
47 } \ | |
48 } while (0) | |
49 | 47 |
50 /* | 48 /* |
51 * FUNCTION: pkix_pl_HashTable_Destroy | 49 * FUNCTION: pkix_pl_HashTable_Destroy |
52 * (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h) | 50 * (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h) |
53 */ | 51 */ |
54 static PKIX_Error * | 52 static PKIX_Error *pkix_pl_HashTable_Destroy(PKIX_PL_Object *object, |
55 pkix_pl_HashTable_Destroy( | 53 void *plContext) { |
56 PKIX_PL_Object *object, | 54 PKIX_PL_HashTable *ht = NULL; |
57 void *plContext) | 55 pkix_pl_HT_Elem *item = NULL; |
58 { | 56 PKIX_UInt32 i; |
59 PKIX_PL_HashTable *ht = NULL; | 57 |
60 pkix_pl_HT_Elem *item = NULL; | 58 PKIX_ENTER(HASHTABLE, "pkix_pl_HashTable_Destroy"); |
61 PKIX_UInt32 i; | 59 PKIX_NULLCHECK_ONE(object); |
62 | 60 |
63 PKIX_ENTER(HASHTABLE, "pkix_pl_HashTable_Destroy"); | 61 PKIX_CHECK(pkix_CheckType(object, PKIX_HASHTABLE_TYPE, plContext), |
64 PKIX_NULLCHECK_ONE(object); | 62 PKIX_OBJECTNOTHASHTABLE); |
65 | 63 |
66 PKIX_CHECK(pkix_CheckType(object, PKIX_HASHTABLE_TYPE, plContext), | 64 ht = (PKIX_PL_HashTable *)object; |
67 PKIX_OBJECTNOTHASHTABLE); | 65 |
68 | 66 /* DecRef every object in the primitive hash table */ |
69 ht = (PKIX_PL_HashTable*) object; | 67 for (i = 0; i < ht->primHash->size; i++) { |
70 | 68 for (item = ht->primHash->buckets[i]; item != NULL; item = item->next) { |
71 /* DecRef every object in the primitive hash table */ | 69 PKIX_DECREF(item->key); |
72 for (i = 0; i < ht->primHash->size; i++) { | 70 PKIX_DECREF(item->value); |
73 for (item = ht->primHash->buckets[i]; | 71 } |
74 item != NULL; | 72 } |
75 item = item->next) { | 73 |
76 PKIX_DECREF(item->key); | 74 PKIX_CHECK(pkix_pl_PrimHashTable_Destroy(ht->primHash, plContext), |
77 PKIX_DECREF(item->value); | 75 PKIX_PRIMHASHTABLEDESTROYFAILED); |
78 } | 76 |
79 } | 77 PKIX_DECREF(ht->tableLock); |
80 | 78 |
81 PKIX_CHECK(pkix_pl_PrimHashTable_Destroy(ht->primHash, plContext), | 79 cleanup: |
82 PKIX_PRIMHASHTABLEDESTROYFAILED); | 80 |
83 | 81 PKIX_RETURN(HASHTABLE); |
84 PKIX_DECREF(ht->tableLock); | |
85 | |
86 cleanup: | |
87 | |
88 PKIX_RETURN(HASHTABLE); | |
89 } | 82 } |
90 | 83 |
91 /* | 84 /* |
92 * FUNCTION: pkix_pl_HashTable_RegisterSelf | 85 * FUNCTION: pkix_pl_HashTable_RegisterSelf |
93 * DESCRIPTION: | 86 * DESCRIPTION: |
94 * Registers PKIX_HASHTABLE_TYPE and its related functions with systemClasses[] | 87 * Registers PKIX_HASHTABLE_TYPE and its related functions with systemClasses[] |
95 * THREAD SAFETY: | 88 * THREAD SAFETY: |
96 * Not Thread Safe - for performance and complexity reasons | 89 * Not Thread Safe - for performance and complexity reasons |
97 * | 90 * |
98 * Since this function is only called by PKIX_PL_Initialize, which should | 91 * Since this function is only called by PKIX_PL_Initialize, which should |
99 * only be called once, it is acceptable that this function is not | 92 * only be called once, it is acceptable that this function is not |
100 * thread-safe. | 93 * thread-safe. |
101 */ | 94 */ |
102 PKIX_Error * | 95 PKIX_Error *pkix_pl_HashTable_RegisterSelf(void *plContext) { |
103 pkix_pl_HashTable_RegisterSelf( | 96 |
104 void *plContext) | 97 extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES]; |
105 { | 98 pkix_ClassTable_Entry entry; |
106 | 99 |
107 extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES]; | 100 PKIX_ENTER(HASHTABLE, "pkix_pl_HashTable_RegisterSelf"); |
108 pkix_ClassTable_Entry entry; | 101 |
109 | 102 entry.description = "HashTable"; |
110 PKIX_ENTER(HASHTABLE, "pkix_pl_HashTable_RegisterSelf"); | 103 entry.objCounter = 0; |
111 | 104 entry.typeObjectSize = sizeof(PKIX_PL_HashTable); |
112 entry.description = "HashTable"; | 105 entry.destructor = pkix_pl_HashTable_Destroy; |
113 entry.objCounter = 0; | 106 entry.equalsFunction = NULL; |
114 entry.typeObjectSize = sizeof(PKIX_PL_HashTable); | 107 entry.hashcodeFunction = NULL; |
115 entry.destructor = pkix_pl_HashTable_Destroy; | 108 entry.toStringFunction = NULL; |
116 entry.equalsFunction = NULL; | 109 entry.comparator = NULL; |
117 entry.hashcodeFunction = NULL; | 110 entry.duplicateFunction = NULL; |
118 entry.toStringFunction = NULL; | 111 |
119 entry.comparator = NULL; | 112 systemClasses[PKIX_HASHTABLE_TYPE] = entry; |
120 entry.duplicateFunction = NULL; | 113 |
121 | 114 PKIX_RETURN(HASHTABLE); |
122 systemClasses[PKIX_HASHTABLE_TYPE] = entry; | |
123 | |
124 PKIX_RETURN(HASHTABLE); | |
125 } | 115 } |
126 | 116 |
127 /* --Public-Functions------------------------------------------------------- */ | 117 /* --Public-Functions------------------------------------------------------- */ |
128 | 118 |
129 /* | 119 /* |
130 * FUNCTION: PKIX_PL_HashTable_Create (see comments in pkix_pl_system.h) | 120 * FUNCTION: PKIX_PL_HashTable_Create (see comments in pkix_pl_system.h) |
131 */ | 121 */ |
132 PKIX_Error * | 122 PKIX_Error *PKIX_PL_HashTable_Create(PKIX_UInt32 numBuckets, |
133 PKIX_PL_HashTable_Create( | 123 PKIX_UInt32 maxEntriesPerBucket, |
134 PKIX_UInt32 numBuckets, | 124 PKIX_PL_HashTable **pResult, |
135 PKIX_UInt32 maxEntriesPerBucket, | 125 void *plContext) { |
136 PKIX_PL_HashTable **pResult, | 126 PKIX_PL_HashTable *hashTable = NULL; |
137 void *plContext) | 127 |
138 { | 128 PKIX_ENTER(HASHTABLE, "PKIX_PL_HashTable_Create"); |
139 PKIX_PL_HashTable *hashTable = NULL; | 129 PKIX_NULLCHECK_ONE(pResult); |
140 | 130 |
141 PKIX_ENTER(HASHTABLE, "PKIX_PL_HashTable_Create"); | 131 if (numBuckets == 0) { |
142 PKIX_NULLCHECK_ONE(pResult); | 132 PKIX_ERROR(PKIX_NUMBUCKETSEQUALSZERO); |
143 | 133 } |
144 if (numBuckets == 0) { | 134 |
145 PKIX_ERROR(PKIX_NUMBUCKETSEQUALSZERO); | 135 /* Allocate a new hashtable */ |
146 } | 136 PKIX_CHECK( |
147 | 137 PKIX_PL_Object_Alloc(PKIX_HASHTABLE_TYPE, sizeof(PKIX_PL_HashTable), |
148 /* Allocate a new hashtable */ | 138 (PKIX_PL_Object **)&hashTable, plContext), |
149 PKIX_CHECK(PKIX_PL_Object_Alloc | 139 PKIX_COULDNOTCREATEHASHTABLEOBJECT); |
150 (PKIX_HASHTABLE_TYPE, | 140 |
151 sizeof (PKIX_PL_HashTable), | 141 /* Create the underlying primitive hash table type */ |
152 (PKIX_PL_Object **)&hashTable, | 142 PKIX_CHECK( |
153 plContext), | 143 pkix_pl_PrimHashTable_Create(numBuckets, &hashTable->primHash, plContext), |
154 PKIX_COULDNOTCREATEHASHTABLEOBJECT); | 144 PKIX_PRIMHASHTABLECREATEFAILED); |
155 | 145 |
156 /* Create the underlying primitive hash table type */ | 146 /* Create a lock for this table */ |
157 PKIX_CHECK(pkix_pl_PrimHashTable_Create | 147 PKIX_CHECK(PKIX_PL_Mutex_Create(&hashTable->tableLock, plContext), |
158 (numBuckets, &hashTable->primHash, plContext), | 148 PKIX_ERRORCREATINGTABLELOCK); |
159 PKIX_PRIMHASHTABLECREATEFAILED); | 149 |
160 | 150 hashTable->maxEntriesPerBucket = maxEntriesPerBucket; |
161 /* Create a lock for this table */ | 151 |
162 PKIX_CHECK(PKIX_PL_Mutex_Create(&hashTable->tableLock, plContext), | 152 *pResult = hashTable; |
163 PKIX_ERRORCREATINGTABLELOCK); | 153 |
164 | 154 cleanup: |
165 hashTable->maxEntriesPerBucket = maxEntriesPerBucket; | 155 |
166 | 156 if (PKIX_ERROR_RECEIVED) { |
167 *pResult = hashTable; | 157 PKIX_DECREF(hashTable); |
168 | 158 } |
169 cleanup: | 159 |
170 | 160 PKIX_RETURN(HASHTABLE); |
171 if (PKIX_ERROR_RECEIVED){ | |
172 PKIX_DECREF(hashTable); | |
173 } | |
174 | |
175 PKIX_RETURN(HASHTABLE); | |
176 } | 161 } |
177 | 162 |
178 /* | 163 /* |
179 * FUNCTION: PKIX_PL_HashTable_Add (see comments in pkix_pl_system.h) | 164 * FUNCTION: PKIX_PL_HashTable_Add (see comments in pkix_pl_system.h) |
180 */ | 165 */ |
181 PKIX_Error * | 166 PKIX_Error *PKIX_PL_HashTable_Add(PKIX_PL_HashTable *ht, PKIX_PL_Object *key, |
182 PKIX_PL_HashTable_Add( | 167 PKIX_PL_Object *value, void *plContext) { |
183 PKIX_PL_HashTable *ht, | 168 PKIX_PL_Mutex *lockedMutex = NULL; |
184 PKIX_PL_Object *key, | 169 PKIX_PL_Object *deletedKey = NULL; |
185 PKIX_PL_Object *value, | 170 PKIX_PL_Object *deletedValue = NULL; |
186 void *plContext) | 171 PKIX_UInt32 hashCode; |
187 { | 172 PKIX_PL_EqualsCallback keyComp; |
188 PKIX_PL_Mutex *lockedMutex = NULL; | 173 PKIX_UInt32 bucketSize = 0; |
189 PKIX_PL_Object *deletedKey = NULL; | 174 |
190 PKIX_PL_Object *deletedValue = NULL; | 175 PKIX_ENTER(HASHTABLE, "PKIX_PL_HashTable_Add"); |
191 PKIX_UInt32 hashCode; | |
192 PKIX_PL_EqualsCallback keyComp; | |
193 PKIX_UInt32 bucketSize = 0; | |
194 | |
195 PKIX_ENTER(HASHTABLE, "PKIX_PL_HashTable_Add"); | |
196 | 176 |
197 #if !defined(PKIX_OBJECT_LEAK_TEST) | 177 #if !defined(PKIX_OBJECT_LEAK_TEST) |
198 PKIX_NULLCHECK_THREE(ht, key, value); | 178 PKIX_NULLCHECK_THREE(ht, key, value); |
199 #else | 179 #else |
200 PKIX_NULLCHECK_TWO(key, value); | 180 PKIX_NULLCHECK_TWO(key, value); |
201 | 181 |
202 if (ht == NULL) { | 182 if (ht == NULL) { |
203 PKIX_RETURN(HASHTABLE); | 183 PKIX_RETURN(HASHTABLE); |
204 } | 184 } |
205 #endif | 185 #endif |
206 /* Insert into primitive hashtable */ | 186 /* Insert into primitive hashtable */ |
207 | 187 |
208 PKIX_CHECK(PKIX_PL_Object_Hashcode(key, &hashCode, plContext), | 188 PKIX_CHECK(PKIX_PL_Object_Hashcode(key, &hashCode, plContext), |
209 PKIX_OBJECTHASHCODEFAILED); | 189 PKIX_OBJECTHASHCODEFAILED); |
210 | 190 |
211 PKIX_CHECK(pkix_pl_Object_RetrieveEqualsCallback | 191 PKIX_CHECK(pkix_pl_Object_RetrieveEqualsCallback(key, &keyComp, plContext), |
212 (key, &keyComp, plContext), | 192 PKIX_OBJECTRETRIEVEEQUALSCALLBACKFAILED); |
213 PKIX_OBJECTRETRIEVEEQUALSCALLBACKFAILED); | 193 |
214 | 194 PKIX_MUTEX_LOCK(ht->tableLock); |
215 PKIX_MUTEX_LOCK(ht->tableLock); | 195 |
216 | 196 PKIX_CHECK(pkix_pl_PrimHashTable_GetBucketSize(ht->primHash, hashCode, |
217 PKIX_CHECK(pkix_pl_PrimHashTable_GetBucketSize | 197 &bucketSize, plContext), |
218 (ht->primHash, | 198 PKIX_PRIMHASHTABLEGETBUCKETSIZEFAILED); |
219 hashCode, | 199 |
220 &bucketSize, | 200 if (ht->maxEntriesPerBucket != 0 && bucketSize >= ht->maxEntriesPerBucket) { |
221 plContext), | 201 /* drop the last one in the bucket */ |
222 PKIX_PRIMHASHTABLEGETBUCKETSIZEFAILED); | 202 PKIX_CHECK(pkix_pl_PrimHashTable_RemoveFIFO( |
223 | 203 ht->primHash, hashCode, (void **)&deletedKey, |
224 if (ht->maxEntriesPerBucket != 0 && | 204 (void **)&deletedValue, plContext), |
225 bucketSize >= ht->maxEntriesPerBucket) { | 205 PKIX_PRIMHASHTABLEGETBUCKETSIZEFAILED); |
226 /* drop the last one in the bucket */ | 206 PKIX_DECREF(deletedKey); |
227 PKIX_CHECK(pkix_pl_PrimHashTable_RemoveFIFO | 207 PKIX_DECREF(deletedValue); |
228 (ht->primHash, | 208 } |
229 hashCode, | 209 |
230 (void **) &deletedKey, | 210 PKIX_CHECK(pkix_pl_PrimHashTable_Add(ht->primHash, (void *)key, (void *)value, |
231 (void **) &deletedValue, | 211 hashCode, keyComp, plContext), |
232 plContext), | 212 PKIX_PRIMHASHTABLEADDFAILED); |
233 PKIX_PRIMHASHTABLEGETBUCKETSIZEFAILED); | 213 |
234 PKIX_DECREF(deletedKey); | 214 PKIX_INCREF(key); |
235 PKIX_DECREF(deletedValue); | 215 PKIX_INCREF(value); |
236 } | 216 PKIX_MUTEX_UNLOCK(ht->tableLock); |
237 | 217 |
238 PKIX_CHECK(pkix_pl_PrimHashTable_Add | 218 /* |
239 (ht->primHash, | 219 * we don't call PKIX_PL_InvalidateCache here b/c we have |
240 (void *)key, | 220 * not implemented toString or hashcode for this Object |
241 (void *)value, | 221 */ |
242 hashCode, | 222 |
243 keyComp, | 223 cleanup: |
244 plContext), | 224 |
245 PKIX_PRIMHASHTABLEADDFAILED); | 225 PKIX_MUTEX_UNLOCK(ht->tableLock); |
246 | 226 |
247 PKIX_INCREF(key); | 227 PKIX_RETURN(HASHTABLE); |
248 PKIX_INCREF(value); | |
249 PKIX_MUTEX_UNLOCK(ht->tableLock); | |
250 | |
251 /* | |
252 * we don't call PKIX_PL_InvalidateCache here b/c we have | |
253 * not implemented toString or hashcode for this Object | |
254 */ | |
255 | |
256 cleanup: | |
257 | |
258 PKIX_MUTEX_UNLOCK(ht->tableLock); | |
259 | |
260 PKIX_RETURN(HASHTABLE); | |
261 } | 228 } |
262 | 229 |
263 /* | 230 /* |
264 * FUNCTION: PKIX_PL_HashTable_Remove (see comments in pkix_pl_system.h) | 231 * FUNCTION: PKIX_PL_HashTable_Remove (see comments in pkix_pl_system.h) |
265 */ | 232 */ |
266 PKIX_Error * | 233 PKIX_Error *PKIX_PL_HashTable_Remove(PKIX_PL_HashTable *ht, PKIX_PL_Object *key, |
267 PKIX_PL_HashTable_Remove( | 234 void *plContext) { |
268 PKIX_PL_HashTable *ht, | 235 PKIX_PL_Mutex *lockedMutex = NULL; |
269 PKIX_PL_Object *key, | 236 PKIX_PL_Object *origKey = NULL; |
270 void *plContext) | 237 PKIX_PL_Object *value = NULL; |
271 { | 238 PKIX_UInt32 hashCode; |
272 PKIX_PL_Mutex *lockedMutex = NULL; | 239 PKIX_PL_EqualsCallback keyComp; |
273 PKIX_PL_Object *origKey = NULL; | 240 |
274 PKIX_PL_Object *value = NULL; | 241 PKIX_ENTER(HASHTABLE, "PKIX_PL_HashTable_Remove"); |
275 PKIX_UInt32 hashCode; | |
276 PKIX_PL_EqualsCallback keyComp; | |
277 | |
278 PKIX_ENTER(HASHTABLE, "PKIX_PL_HashTable_Remove"); | |
279 | 242 |
280 #if !defined(PKIX_OBJECT_LEAK_TEST) | 243 #if !defined(PKIX_OBJECT_LEAK_TEST) |
281 PKIX_NULLCHECK_TWO(ht, key); | 244 PKIX_NULLCHECK_TWO(ht, key); |
282 #else | 245 #else |
283 PKIX_NULLCHECK_ONE(key); | 246 PKIX_NULLCHECK_ONE(key); |
284 | 247 |
285 if (ht == NULL) { | 248 if (ht == NULL) { |
286 PKIX_RETURN(HASHTABLE); | 249 PKIX_RETURN(HASHTABLE); |
287 } | 250 } |
288 #endif | 251 #endif |
289 | 252 |
290 PKIX_CHECK(PKIX_PL_Object_Hashcode(key, &hashCode, plContext), | 253 PKIX_CHECK(PKIX_PL_Object_Hashcode(key, &hashCode, plContext), |
291 PKIX_OBJECTHASHCODEFAILED); | 254 PKIX_OBJECTHASHCODEFAILED); |
292 | 255 |
293 PKIX_CHECK(pkix_pl_Object_RetrieveEqualsCallback | 256 PKIX_CHECK(pkix_pl_Object_RetrieveEqualsCallback(key, &keyComp, plContext), |
294 (key, &keyComp, plContext), | 257 PKIX_OBJECTRETRIEVEEQUALSCALLBACKFAILED); |
295 PKIX_OBJECTRETRIEVEEQUALSCALLBACKFAILED); | 258 |
296 | 259 PKIX_MUTEX_LOCK(ht->tableLock); |
297 PKIX_MUTEX_LOCK(ht->tableLock); | 260 |
298 | 261 /* Remove from primitive hashtable */ |
299 /* Remove from primitive hashtable */ | 262 PKIX_CHECK(pkix_pl_PrimHashTable_Remove(ht->primHash, (void *)key, hashCode, |
300 PKIX_CHECK(pkix_pl_PrimHashTable_Remove | 263 keyComp, (void **)&origKey, |
301 (ht->primHash, | 264 (void **)&value, plContext), |
302 (void *)key, | 265 PKIX_PRIMHASHTABLEREMOVEFAILED); |
303 hashCode, | 266 |
304 keyComp, | 267 PKIX_MUTEX_UNLOCK(ht->tableLock); |
305 (void **)&origKey, | 268 |
306 (void **)&value, | 269 PKIX_DECREF(origKey); |
307 plContext), | 270 PKIX_DECREF(value); |
308 PKIX_PRIMHASHTABLEREMOVEFAILED); | 271 |
309 | 272 /* |
310 PKIX_MUTEX_UNLOCK(ht->tableLock); | 273 * we don't call PKIX_PL_InvalidateCache here b/c we have |
311 | 274 * not implemented toString or hashcode for this Object |
312 PKIX_DECREF(origKey); | 275 */ |
313 PKIX_DECREF(value); | 276 |
314 | 277 cleanup: |
315 /* | 278 |
316 * we don't call PKIX_PL_InvalidateCache here b/c we have | 279 PKIX_MUTEX_UNLOCK(ht->tableLock); |
317 * not implemented toString or hashcode for this Object | 280 |
318 */ | 281 PKIX_RETURN(HASHTABLE); |
319 | |
320 cleanup: | |
321 | |
322 PKIX_MUTEX_UNLOCK(ht->tableLock); | |
323 | |
324 PKIX_RETURN(HASHTABLE); | |
325 } | 282 } |
326 | 283 |
327 /* | 284 /* |
328 * FUNCTION: PKIX_PL_HashTable_Lookup (see comments in pkix_pl_system.h) | 285 * FUNCTION: PKIX_PL_HashTable_Lookup (see comments in pkix_pl_system.h) |
329 */ | 286 */ |
330 PKIX_Error * | 287 PKIX_Error *PKIX_PL_HashTable_Lookup(PKIX_PL_HashTable *ht, PKIX_PL_Object *key, |
331 PKIX_PL_HashTable_Lookup( | 288 PKIX_PL_Object **pResult, |
332 PKIX_PL_HashTable *ht, | 289 void *plContext) { |
333 PKIX_PL_Object *key, | 290 PKIX_PL_Mutex *lockedMutex = NULL; |
334 PKIX_PL_Object **pResult, | 291 PKIX_UInt32 hashCode; |
335 void *plContext) | 292 PKIX_PL_EqualsCallback keyComp; |
336 { | 293 PKIX_PL_Object *result = NULL; |
337 PKIX_PL_Mutex *lockedMutex = NULL; | 294 |
338 PKIX_UInt32 hashCode; | 295 PKIX_ENTER(HASHTABLE, "PKIX_PL_HashTable_Lookup"); |
339 PKIX_PL_EqualsCallback keyComp; | |
340 PKIX_PL_Object *result = NULL; | |
341 | |
342 PKIX_ENTER(HASHTABLE, "PKIX_PL_HashTable_Lookup"); | |
343 | 296 |
344 #if !defined(PKIX_OBJECT_LEAK_TEST) | 297 #if !defined(PKIX_OBJECT_LEAK_TEST) |
345 PKIX_NULLCHECK_THREE(ht, key, pResult); | 298 PKIX_NULLCHECK_THREE(ht, key, pResult); |
346 #else | 299 #else |
347 PKIX_NULLCHECK_TWO(key, pResult); | 300 PKIX_NULLCHECK_TWO(key, pResult); |
348 | 301 |
349 if (ht == NULL) { | 302 if (ht == NULL) { |
350 PKIX_RETURN(HASHTABLE); | 303 PKIX_RETURN(HASHTABLE); |
351 } | 304 } |
352 #endif | 305 #endif |
353 | 306 |
354 PKIX_CHECK(PKIX_PL_Object_Hashcode(key, &hashCode, plContext), | 307 PKIX_CHECK(PKIX_PL_Object_Hashcode(key, &hashCode, plContext), |
355 PKIX_OBJECTHASHCODEFAILED); | 308 PKIX_OBJECTHASHCODEFAILED); |
356 | 309 |
357 PKIX_CHECK(pkix_pl_Object_RetrieveEqualsCallback | 310 PKIX_CHECK(pkix_pl_Object_RetrieveEqualsCallback(key, &keyComp, plContext), |
358 (key, &keyComp, plContext), | 311 PKIX_OBJECTRETRIEVEEQUALSCALLBACKFAILED); |
359 PKIX_OBJECTRETRIEVEEQUALSCALLBACKFAILED); | 312 |
360 | 313 PKIX_MUTEX_LOCK(ht->tableLock); |
361 PKIX_MUTEX_LOCK(ht->tableLock); | 314 |
362 | 315 /* Lookup in primitive hashtable */ |
363 /* Lookup in primitive hashtable */ | 316 PKIX_CHECK(pkix_pl_PrimHashTable_Lookup(ht->primHash, (void *)key, hashCode, |
364 PKIX_CHECK(pkix_pl_PrimHashTable_Lookup | 317 keyComp, (void **)&result, plContext), |
365 (ht->primHash, | 318 PKIX_PRIMHASHTABLELOOKUPFAILED); |
366 (void *)key, | 319 |
367 hashCode, | 320 PKIX_INCREF(result); |
368 keyComp, | 321 PKIX_MUTEX_UNLOCK(ht->tableLock); |
369 (void **)&result, | 322 |
370 plContext), | 323 *pResult = result; |
371 PKIX_PRIMHASHTABLELOOKUPFAILED); | 324 |
372 | 325 cleanup: |
373 PKIX_INCREF(result); | 326 |
374 PKIX_MUTEX_UNLOCK(ht->tableLock); | 327 PKIX_MUTEX_UNLOCK(ht->tableLock); |
375 | 328 |
376 *pResult = result; | 329 PKIX_RETURN(HASHTABLE); |
377 | 330 } |
378 cleanup: | |
379 ········ | |
380 PKIX_MUTEX_UNLOCK(ht->tableLock); | |
381 | |
382 PKIX_RETURN(HASHTABLE); | |
383 } | |
OLD | NEW |