| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ | |
| 4 /* | |
| 5 * pkix_valresult.c | |
| 6 * | |
| 7 * ValidateResult Object Functions | |
| 8 * | |
| 9 */ | |
| 10 | |
| 11 #include "pkix_valresult.h" | |
| 12 | |
| 13 /* --Private-Functions-------------------------------------------- */ | |
| 14 | |
| 15 /* | |
| 16 * FUNCTION: pkix_ValidateResult_Destroy | |
| 17 * (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h) | |
| 18 */ | |
| 19 static PKIX_Error * | |
| 20 pkix_ValidateResult_Destroy( | |
| 21 PKIX_PL_Object *object, | |
| 22 void *plContext) | |
| 23 { | |
| 24 PKIX_ValidateResult *result = NULL; | |
| 25 | |
| 26 PKIX_ENTER(VALIDATERESULT, "pkix_ValidateResult_Destroy"); | |
| 27 PKIX_NULLCHECK_ONE(object); | |
| 28 | |
| 29 /* Check that this object is a validate result object */ | |
| 30 PKIX_CHECK(pkix_CheckType(object, PKIX_VALIDATERESULT_TYPE, plContext), | |
| 31 PKIX_OBJECTNOTVALIDATERESULT); | |
| 32 | |
| 33 result = (PKIX_ValidateResult *)object; | |
| 34 | |
| 35 PKIX_DECREF(result->anchor); | |
| 36 PKIX_DECREF(result->pubKey); | |
| 37 PKIX_DECREF(result->policyTree); | |
| 38 | |
| 39 cleanup: | |
| 40 | |
| 41 PKIX_RETURN(VALIDATERESULT); | |
| 42 } | |
| 43 | |
| 44 /* | |
| 45 * FUNCTION: pkix_ValidateResult_Equals | |
| 46 * (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h) | |
| 47 */ | |
| 48 static PKIX_Error * | |
| 49 pkix_ValidateResult_Equals( | |
| 50 PKIX_PL_Object *first, | |
| 51 PKIX_PL_Object *second, | |
| 52 PKIX_Boolean *pResult, | |
| 53 void *plContext) | |
| 54 { | |
| 55 PKIX_UInt32 secondType; | |
| 56 PKIX_Boolean cmpResult; | |
| 57 PKIX_ValidateResult *firstValResult = NULL; | |
| 58 PKIX_ValidateResult *secondValResult = NULL; | |
| 59 PKIX_TrustAnchor *firstAnchor = NULL; | |
| 60 PKIX_TrustAnchor *secondAnchor = NULL; | |
| 61 PKIX_PolicyNode *firstTree = NULL; | |
| 62 PKIX_PolicyNode *secondTree = NULL; | |
| 63 | |
| 64 PKIX_ENTER(VALIDATERESULT, "pkix_ValidateResult_Equals"); | |
| 65 PKIX_NULLCHECK_THREE(first, second, pResult); | |
| 66 | |
| 67 PKIX_CHECK(pkix_CheckType(first, PKIX_VALIDATERESULT_TYPE, plContext), | |
| 68 PKIX_FIRSTOBJECTNOTVALIDATERESULT); | |
| 69 | |
| 70 PKIX_CHECK(PKIX_PL_Object_GetType(second, &secondType, plContext), | |
| 71 PKIX_COULDNOTGETTYPEOFSECONDARGUMENT); | |
| 72 | |
| 73 *pResult = PKIX_FALSE; | |
| 74 | |
| 75 if (secondType != PKIX_VALIDATERESULT_TYPE) goto cleanup; | |
| 76 | |
| 77 firstValResult = (PKIX_ValidateResult *)first; | |
| 78 secondValResult = (PKIX_ValidateResult *)second; | |
| 79 | |
| 80 PKIX_CHECK(PKIX_PL_Object_Equals | |
| 81 ((PKIX_PL_Object *)firstValResult->pubKey, | |
| 82 (PKIX_PL_Object *)secondValResult->pubKey, | |
| 83 &cmpResult, | |
| 84 plContext), | |
| 85 PKIX_OBJECTEQUALSFAILED); | |
| 86 | |
| 87 if (!cmpResult) goto cleanup; | |
| 88 | |
| 89 firstAnchor = firstValResult->anchor; | |
| 90 secondAnchor = secondValResult->anchor; | |
| 91 | |
| 92 if ((firstAnchor != NULL) && (secondAnchor != NULL)) { | |
| 93 PKIX_CHECK(PKIX_PL_Object_Equals | |
| 94 ((PKIX_PL_Object *)firstAnchor, | |
| 95 (PKIX_PL_Object *)secondAnchor, | |
| 96 &cmpResult, | |
| 97 plContext), | |
| 98 PKIX_OBJECTEQUALSFAILED); | |
| 99 } else { | |
| 100 cmpResult = (firstAnchor == secondAnchor); | |
| 101 } | |
| 102 | |
| 103 if (!cmpResult) goto cleanup; | |
| 104 | |
| 105 firstTree = firstValResult->policyTree; | |
| 106 secondTree = secondValResult->policyTree; | |
| 107 | |
| 108 if ((firstTree != NULL) && (secondTree != NULL)) { | |
| 109 PKIX_CHECK(PKIX_PL_Object_Equals | |
| 110 ((PKIX_PL_Object *)firstTree, | |
| 111 (PKIX_PL_Object *)secondTree, | |
| 112 &cmpResult, | |
| 113 plContext), | |
| 114 PKIX_OBJECTEQUALSFAILED); | |
| 115 } else { | |
| 116 cmpResult = (firstTree == secondTree); | |
| 117 } | |
| 118 | |
| 119 *pResult = cmpResult; | |
| 120 | |
| 121 cleanup: | |
| 122 | |
| 123 PKIX_RETURN(VALIDATERESULT); | |
| 124 } | |
| 125 | |
| 126 /* | |
| 127 * FUNCTION: pkix_ValidateResult_Hashcode | |
| 128 * (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h) | |
| 129 */ | |
| 130 static PKIX_Error * | |
| 131 pkix_ValidateResult_Hashcode( | |
| 132 PKIX_PL_Object *object, | |
| 133 PKIX_UInt32 *pHashcode, | |
| 134 void *plContext) | |
| 135 { | |
| 136 PKIX_ValidateResult *valResult = NULL; | |
| 137 PKIX_UInt32 hash = 0; | |
| 138 PKIX_UInt32 pubKeyHash = 0; | |
| 139 PKIX_UInt32 anchorHash = 0; | |
| 140 PKIX_UInt32 policyTreeHash = 0; | |
| 141 | |
| 142 PKIX_ENTER(VALIDATERESULT, "pkix_ValidateResult_Hashcode"); | |
| 143 PKIX_NULLCHECK_TWO(object, pHashcode); | |
| 144 | |
| 145 PKIX_CHECK(pkix_CheckType(object, PKIX_VALIDATERESULT_TYPE, plContext), | |
| 146 PKIX_OBJECTNOTVALIDATERESULT); | |
| 147 | |
| 148 valResult = (PKIX_ValidateResult*)object; | |
| 149 | |
| 150 PKIX_CHECK(PKIX_PL_Object_Hashcode | |
| 151 ((PKIX_PL_Object *)valResult->pubKey, &pubKeyHash, plContext), | |
| 152 PKIX_OBJECTHASHCODEFAILED); | |
| 153 | |
| 154 if (valResult->anchor) { | |
| 155 PKIX_CHECK(PKIX_PL_Object_Hashcode | |
| 156 ((PKIX_PL_Object *)valResult->anchor, | |
| 157 &anchorHash, | |
| 158 plContext), | |
| 159 PKIX_OBJECTHASHCODEFAILED); | |
| 160 } | |
| 161 | |
| 162 if (valResult->policyTree) { | |
| 163 PKIX_CHECK(PKIX_PL_Object_Hashcode | |
| 164 ((PKIX_PL_Object *)valResult->policyTree, | |
| 165 &policyTreeHash, | |
| 166 plContext), | |
| 167 PKIX_OBJECTHASHCODEFAILED); | |
| 168 } | |
| 169 | |
| 170 hash = 31*(31 * pubKeyHash + anchorHash) + policyTreeHash; | |
| 171 | |
| 172 *pHashcode = hash; | |
| 173 | |
| 174 cleanup: | |
| 175 | |
| 176 PKIX_RETURN(VALIDATERESULT); | |
| 177 } | |
| 178 | |
| 179 /* | |
| 180 * FUNCTION: pkix_ValidateResult_ToString | |
| 181 * (see comments for PKIX_PL_ToStringCallback in pkix_pl_system.h) | |
| 182 */ | |
| 183 static PKIX_Error * | |
| 184 pkix_ValidateResult_ToString( | |
| 185 PKIX_PL_Object *object, | |
| 186 PKIX_PL_String **pString, | |
| 187 void *plContext) | |
| 188 { | |
| 189 PKIX_ValidateResult *valResult = NULL; | |
| 190 PKIX_PL_String *formatString = NULL; | |
| 191 PKIX_PL_String *valResultString = NULL; | |
| 192 | |
| 193 PKIX_TrustAnchor *anchor = NULL; | |
| 194 PKIX_PL_PublicKey *pubKey = NULL; | |
| 195 PKIX_PolicyNode *policyTree = NULL; | |
| 196 | |
| 197 PKIX_PL_String *anchorString = NULL; | |
| 198 PKIX_PL_String *pubKeyString = NULL; | |
| 199 PKIX_PL_String *treeString = NULL; | |
| 200 char *asciiNullString = "(null)"; | |
| 201 char *asciiFormat = | |
| 202 "[\n" | |
| 203 "\tTrustAnchor: \t\t%s" | |
| 204 "\tPubKey: \t\t%s\n" | |
| 205 "\tPolicyTree: \t\t%s\n" | |
| 206 "]\n"; | |
| 207 | |
| 208 PKIX_ENTER(VALIDATERESULT, "pkix_ValidateResult_ToString"); | |
| 209 PKIX_NULLCHECK_TWO(object, pString); | |
| 210 | |
| 211 PKIX_CHECK(pkix_CheckType(object, PKIX_VALIDATERESULT_TYPE, plContext), | |
| 212 PKIX_OBJECTNOTVALIDATERESULT); | |
| 213 | |
| 214 PKIX_CHECK(PKIX_PL_String_Create | |
| 215 (PKIX_ESCASCII, asciiFormat, 0, &formatString, plContext), | |
| 216 PKIX_STRINGCREATEFAILED); | |
| 217 | |
| 218 valResult = (PKIX_ValidateResult*)object; | |
| 219 | |
| 220 anchor = valResult->anchor; | |
| 221 | |
| 222 if (anchor) { | |
| 223 PKIX_CHECK(PKIX_PL_Object_ToString | |
| 224 ((PKIX_PL_Object *)anchor, &anchorString, plContext), | |
| 225 PKIX_OBJECTTOSTRINGFAILED); | |
| 226 } else { | |
| 227 PKIX_CHECK(PKIX_PL_String_Create | |
| 228 (PKIX_ESCASCII, | |
| 229 asciiNullString, | |
| 230 0, | |
| 231 &anchorString, | |
| 232 plContext), | |
| 233 PKIX_STRINGCREATEFAILED); | |
| 234 } | |
| 235 | |
| 236 pubKey = valResult->pubKey; | |
| 237 | |
| 238 PKIX_CHECK(PKIX_PL_Object_ToString | |
| 239 ((PKIX_PL_Object *)pubKey, &pubKeyString, plContext), | |
| 240 PKIX_OBJECTTOSTRINGFAILED); | |
| 241 | |
| 242 policyTree = valResult->policyTree; | |
| 243 | |
| 244 if (policyTree) { | |
| 245 PKIX_CHECK(PKIX_PL_Object_ToString | |
| 246 ((PKIX_PL_Object *)policyTree, &treeString, plContext), | |
| 247 PKIX_OBJECTTOSTRINGFAILED); | |
| 248 } else { | |
| 249 PKIX_CHECK(PKIX_PL_String_Create | |
| 250 (PKIX_ESCASCII, | |
| 251 asciiNullString, | |
| 252 0, | |
| 253 &treeString, | |
| 254 plContext), | |
| 255 PKIX_STRINGCREATEFAILED); | |
| 256 } | |
| 257 | |
| 258 PKIX_CHECK(PKIX_PL_Sprintf | |
| 259 (&valResultString, | |
| 260 plContext, | |
| 261 formatString, | |
| 262 anchorString, | |
| 263 pubKeyString, | |
| 264 treeString), | |
| 265 PKIX_SPRINTFFAILED); | |
| 266 | |
| 267 *pString = valResultString; | |
| 268 | |
| 269 cleanup: | |
| 270 | |
| 271 PKIX_DECREF(formatString); | |
| 272 PKIX_DECREF(anchorString); | |
| 273 PKIX_DECREF(pubKeyString); | |
| 274 PKIX_DECREF(treeString); | |
| 275 | |
| 276 PKIX_RETURN(VALIDATERESULT); | |
| 277 } | |
| 278 | |
| 279 /* | |
| 280 * FUNCTION: pkix_ValidateResult_RegisterSelf | |
| 281 * DESCRIPTION: | |
| 282 * Registers PKIX_VALIDATERESULT_TYPE and its related functions with | |
| 283 * systemClasses[] | |
| 284 * THREAD SAFETY: | |
| 285 * Not Thread Safe - for performance and complexity reasons | |
| 286 * | |
| 287 * Since this function is only called by PKIX_PL_Initialize, which should | |
| 288 * only be called once, it is acceptable that this function is not | |
| 289 * thread-safe. | |
| 290 */ | |
| 291 PKIX_Error * | |
| 292 pkix_ValidateResult_RegisterSelf(void *plContext) | |
| 293 { | |
| 294 | |
| 295 extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES]; | |
| 296 pkix_ClassTable_Entry entry; | |
| 297 | |
| 298 PKIX_ENTER(VALIDATERESULT, "pkix_ValidateResult_RegisterSelf"); | |
| 299 | |
| 300 entry.description = "ValidateResult"; | |
| 301 entry.objCounter = 0; | |
| 302 entry.typeObjectSize = sizeof(PKIX_ValidateResult); | |
| 303 entry.destructor = pkix_ValidateResult_Destroy; | |
| 304 entry.equalsFunction = pkix_ValidateResult_Equals; | |
| 305 entry.hashcodeFunction = pkix_ValidateResult_Hashcode; | |
| 306 entry.toStringFunction = pkix_ValidateResult_ToString; | |
| 307 entry.comparator = NULL; | |
| 308 entry.duplicateFunction = pkix_duplicateImmutable; | |
| 309 | |
| 310 systemClasses[PKIX_VALIDATERESULT_TYPE] = entry; | |
| 311 | |
| 312 PKIX_RETURN(VALIDATERESULT); | |
| 313 } | |
| 314 | |
| 315 /* | |
| 316 * FUNCTION: pkix_ValidateResult_Create | |
| 317 * DESCRIPTION: | |
| 318 * | |
| 319 * Creates a new ValidateResult Object using the PublicKey pointed to by | |
| 320 * "pubKey", the TrustAnchor pointed to by "anchor", and the PolicyNode | |
| 321 * pointed to by "policyTree", and stores it at "pResult". | |
| 322 * | |
| 323 * PARAMETERS | |
| 324 * "pubKey" | |
| 325 * PublicKey of the desired ValidateResult. Must be non-NULL. | |
| 326 * "anchor" | |
| 327 * TrustAnchor of the desired Validateresult. May be NULL. | |
| 328 * "policyTree" | |
| 329 * PolicyNode of the desired ValidateResult; may be NULL | |
| 330 * "pResult" | |
| 331 * Address where object pointer will be stored. Must be non-NULL. | |
| 332 * "plContext" | |
| 333 * Platform-specific context pointer. | |
| 334 * THREAD SAFETY: | |
| 335 * Thread Safe (see Thread Safety Definitions in Programmer's Guide) | |
| 336 * RETURNS: | |
| 337 * Returns NULL if the function succeeds. | |
| 338 * Returns a Fatal Error if the function fails in an unrecoverable way. | |
| 339 */ | |
| 340 PKIX_Error * | |
| 341 pkix_ValidateResult_Create( | |
| 342 PKIX_PL_PublicKey *pubKey, | |
| 343 PKIX_TrustAnchor *anchor, | |
| 344 PKIX_PolicyNode *policyTree, | |
| 345 PKIX_ValidateResult **pResult, | |
| 346 void *plContext) | |
| 347 { | |
| 348 PKIX_ValidateResult *result = NULL; | |
| 349 | |
| 350 PKIX_ENTER(VALIDATERESULT, "pkix_ValidateResult_Create"); | |
| 351 PKIX_NULLCHECK_TWO(pubKey, pResult); | |
| 352 | |
| 353 PKIX_CHECK(PKIX_PL_Object_Alloc | |
| 354 (PKIX_VALIDATERESULT_TYPE, | |
| 355 sizeof (PKIX_ValidateResult), | |
| 356 (PKIX_PL_Object **)&result, | |
| 357 plContext), | |
| 358 PKIX_COULDNOTCREATEVALIDATERESULTOBJECT); | |
| 359 | |
| 360 /* initialize fields */ | |
| 361 | |
| 362 PKIX_INCREF(pubKey); | |
| 363 result->pubKey = pubKey; | |
| 364 | |
| 365 PKIX_INCREF(anchor); | |
| 366 result->anchor = anchor; | |
| 367 | |
| 368 PKIX_INCREF(policyTree); | |
| 369 result->policyTree = policyTree; | |
| 370 | |
| 371 *pResult = result; | |
| 372 result = NULL; | |
| 373 | |
| 374 cleanup: | |
| 375 | |
| 376 PKIX_DECREF(result); | |
| 377 | |
| 378 PKIX_RETURN(VALIDATERESULT); | |
| 379 | |
| 380 } | |
| 381 | |
| 382 /* --Public-Functions--------------------------------------------- */ | |
| 383 | |
| 384 /* | |
| 385 * FUNCTION: PKIX_ValidateResult_GetPublicKey | |
| 386 * (see comments in pkix_result.h) | |
| 387 */ | |
| 388 PKIX_Error * | |
| 389 PKIX_ValidateResult_GetPublicKey( | |
| 390 PKIX_ValidateResult *result, | |
| 391 PKIX_PL_PublicKey **pPublicKey, | |
| 392 void *plContext) | |
| 393 { | |
| 394 PKIX_ENTER(VALIDATERESULT, "PKIX_ValidateResult_GetPublicKey"); | |
| 395 PKIX_NULLCHECK_TWO(result, pPublicKey); | |
| 396 | |
| 397 PKIX_INCREF(result->pubKey); | |
| 398 *pPublicKey = result->pubKey; | |
| 399 | |
| 400 cleanup: | |
| 401 PKIX_RETURN(VALIDATERESULT); | |
| 402 } | |
| 403 | |
| 404 /* | |
| 405 * FUNCTION: PKIX_ValidateResult_GetTrustAnchor | |
| 406 * (see comments in pkix_result.h) | |
| 407 */ | |
| 408 PKIX_Error * | |
| 409 PKIX_ValidateResult_GetTrustAnchor( | |
| 410 PKIX_ValidateResult *result, | |
| 411 PKIX_TrustAnchor **pTrustAnchor, | |
| 412 void *plContext) | |
| 413 { | |
| 414 PKIX_ENTER(VALIDATERESULT, "PKIX_ValidateResult_GetTrustAnchor"); | |
| 415 PKIX_NULLCHECK_TWO(result, pTrustAnchor); | |
| 416 | |
| 417 PKIX_INCREF(result->anchor); | |
| 418 *pTrustAnchor = result->anchor; | |
| 419 | |
| 420 cleanup: | |
| 421 PKIX_RETURN(VALIDATERESULT); | |
| 422 } | |
| 423 | |
| 424 /* | |
| 425 * FUNCTION: PKIX_ValidateResult_GetPolicyTree | |
| 426 * (see comments in pkix_result.h) | |
| 427 */ | |
| 428 PKIX_Error * | |
| 429 PKIX_ValidateResult_GetPolicyTree( | |
| 430 PKIX_ValidateResult *result, | |
| 431 PKIX_PolicyNode **pPolicyTree, | |
| 432 void *plContext) | |
| 433 { | |
| 434 PKIX_ENTER(VALIDATERESULT, "PKIX_ValidateResult_GetPolicyTree"); | |
| 435 PKIX_NULLCHECK_TWO(result, pPolicyTree); | |
| 436 | |
| 437 PKIX_INCREF(result->policyTree); | |
| 438 (*pPolicyTree) = result->policyTree; | |
| 439 | |
| 440 cleanup: | |
| 441 PKIX_RETURN(VALIDATERESULT); | |
| 442 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2078763002:
Delete bundled copy of NSS and replace with README. (Closed)
Base URL: https://chromium.googlesource.com/chromium/deps/nss@master