| 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_pl_certpolicymap.c | |
| 6 * | |
| 7 * CertPolicyMap Type Functions | |
| 8 * | |
| 9 */ | |
| 10 | |
| 11 #include "pkix_pl_certpolicymap.h" | |
| 12 | |
| 13 /* | |
| 14 * FUNCTION: pkix_pl_CertPolicyMap_Create | |
| 15 * DESCRIPTION: | |
| 16 * | |
| 17 * Creates a new CertPolicyMap Object pairing the OID given by | |
| 18 * "issuerDomainPolicy" with the OID given by "subjectDomainPolicy", and | |
| 19 * stores the result at "pCertPolicyMap". | |
| 20 * | |
| 21 * PARAMETERS | |
| 22 * "issuerDomainPolicy" | |
| 23 * Address of the OID of the IssuerDomainPolicy. Must be non-NULL. | |
| 24 * "subjectDomainPolicy" | |
| 25 * Address of the OID of the SubjectDomainPolicy. Must be non-NULL. | |
| 26 * "pCertPolicyMap" | |
| 27 * Address where CertPolicyMap pointer will be stored. Must be non-NULL. | |
| 28 * "plContext" | |
| 29 * Platform-specific context pointer. | |
| 30 * THREAD SAFETY: | |
| 31 * Thread Safe (see Thread Safety Definitions in Programmer's Guide) | |
| 32 * RETURNS: | |
| 33 * Returns NULL if the function succeeds. | |
| 34 * Returns a CertPolicyMap Error if the function fails in a non-fatal way. | |
| 35 * Returns a Fatal Error if the function fails in an unrecoverable way. | |
| 36 */ | |
| 37 PKIX_Error * | |
| 38 pkix_pl_CertPolicyMap_Create( | |
| 39 PKIX_PL_OID *issuerDomainPolicy, | |
| 40 PKIX_PL_OID *subjectDomainPolicy, | |
| 41 PKIX_PL_CertPolicyMap **pCertPolicyMap, | |
| 42 void *plContext) | |
| 43 { | |
| 44 PKIX_PL_CertPolicyMap *policyMap = NULL; | |
| 45 | |
| 46 PKIX_ENTER(CERTPOLICYMAP, "pkix_pl_CertPolicyMap_Create"); | |
| 47 | |
| 48 PKIX_NULLCHECK_THREE | |
| 49 (issuerDomainPolicy, subjectDomainPolicy, pCertPolicyMap); | |
| 50 | |
| 51 PKIX_CHECK(PKIX_PL_Object_Alloc | |
| 52 (PKIX_CERTPOLICYMAP_TYPE, | |
| 53 sizeof (PKIX_PL_CertPolicyMap), | |
| 54 (PKIX_PL_Object **)&policyMap, | |
| 55 plContext), | |
| 56 PKIX_COULDNOTCREATECERTPOLICYMAPOBJECT); | |
| 57 | |
| 58 PKIX_INCREF(issuerDomainPolicy); | |
| 59 policyMap->issuerDomainPolicy = issuerDomainPolicy; | |
| 60 | |
| 61 PKIX_INCREF(subjectDomainPolicy); | |
| 62 policyMap->subjectDomainPolicy = subjectDomainPolicy; | |
| 63 | |
| 64 *pCertPolicyMap = policyMap; | |
| 65 policyMap = NULL; | |
| 66 | |
| 67 cleanup: | |
| 68 PKIX_DECREF(policyMap); | |
| 69 | |
| 70 PKIX_RETURN(CERTPOLICYMAP); | |
| 71 } | |
| 72 | |
| 73 /* | |
| 74 * FUNCTION: pkix_pl_CertPolicyMap_Destroy | |
| 75 * (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h) | |
| 76 */ | |
| 77 static PKIX_Error * | |
| 78 pkix_pl_CertPolicyMap_Destroy( | |
| 79 PKIX_PL_Object *object, | |
| 80 void *plContext) | |
| 81 { | |
| 82 PKIX_PL_CertPolicyMap *certMap = NULL; | |
| 83 | |
| 84 PKIX_ENTER(CERTPOLICYMAP, "pkix_pl_CertPolicyMap_Destroy"); | |
| 85 | |
| 86 PKIX_NULLCHECK_ONE(object); | |
| 87 | |
| 88 PKIX_CHECK(pkix_CheckType(object, PKIX_CERTPOLICYMAP_TYPE, plContext), | |
| 89 PKIX_OBJECTNOTCERTPOLICYMAP); | |
| 90 | |
| 91 certMap = (PKIX_PL_CertPolicyMap*)object; | |
| 92 | |
| 93 PKIX_DECREF(certMap->issuerDomainPolicy); | |
| 94 PKIX_DECREF(certMap->subjectDomainPolicy); | |
| 95 | |
| 96 cleanup: | |
| 97 | |
| 98 PKIX_RETURN(CERTPOLICYMAP); | |
| 99 } | |
| 100 | |
| 101 /* | |
| 102 * FUNCTION: pkix_pl_CertPolicyMap_ToString | |
| 103 * (see comments for PKIX_PL_ToStringCallback in pkix_pl_system.h) | |
| 104 */ | |
| 105 static PKIX_Error * | |
| 106 pkix_pl_CertPolicyMap_ToString( | |
| 107 PKIX_PL_Object *object, | |
| 108 PKIX_PL_String **pString, | |
| 109 void *plContext) | |
| 110 { | |
| 111 PKIX_PL_CertPolicyMap *certMap = NULL; | |
| 112 PKIX_PL_String *format = NULL; | |
| 113 PKIX_PL_String *outString = NULL; | |
| 114 PKIX_PL_String *issuerString = NULL; | |
| 115 PKIX_PL_String *subjectString = NULL; | |
| 116 | |
| 117 PKIX_ENTER(CERTPOLICYMAP, "pkix_pl_CertPolicyMap_ToString"); | |
| 118 | |
| 119 PKIX_NULLCHECK_TWO(object, pString); | |
| 120 | |
| 121 PKIX_CHECK(pkix_CheckType(object, PKIX_CERTPOLICYMAP_TYPE, plContext), | |
| 122 PKIX_OBJECTNOTCERTPOLICYMAP); | |
| 123 | |
| 124 certMap = (PKIX_PL_CertPolicyMap *)object; | |
| 125 | |
| 126 PKIX_TOSTRING | |
| 127 (certMap->issuerDomainPolicy, | |
| 128 &issuerString, | |
| 129 plContext, | |
| 130 PKIX_OBJECTTOSTRINGFAILED); | |
| 131 | |
| 132 PKIX_TOSTRING | |
| 133 (certMap->subjectDomainPolicy, | |
| 134 &subjectString, | |
| 135 plContext, | |
| 136 PKIX_OBJECTTOSTRINGFAILED); | |
| 137 | |
| 138 /* Put them together in the form issuerPolicy=>subjectPolicy */ | |
| 139 PKIX_CHECK(PKIX_PL_String_Create | |
| 140 (PKIX_ESCASCII, "%s=>%s", 0, &format, plContext), | |
| 141 PKIX_ERRORINSTRINGCREATE); | |
| 142 | |
| 143 PKIX_CHECK(PKIX_PL_Sprintf | |
| 144 (&outString, plContext, format, issuerString, subjectString), | |
| 145 PKIX_ERRORINSPRINTF); | |
| 146 | |
| 147 *pString = outString; | |
| 148 | |
| 149 cleanup: | |
| 150 PKIX_DECREF(format); | |
| 151 PKIX_DECREF(issuerString); | |
| 152 PKIX_DECREF(subjectString); | |
| 153 | |
| 154 PKIX_RETURN(CERTPOLICYMAP); | |
| 155 } | |
| 156 | |
| 157 /* | |
| 158 * FUNCTION: pkix_pl_CertPolicyMap_Hashcode | |
| 159 * (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h) | |
| 160 */ | |
| 161 static PKIX_Error * | |
| 162 pkix_pl_CertPolicyMap_Hashcode( | |
| 163 PKIX_PL_Object *object, | |
| 164 PKIX_UInt32 *pHashcode, | |
| 165 void *plContext) | |
| 166 { | |
| 167 PKIX_UInt32 issuerHash = 0; | |
| 168 PKIX_UInt32 subjectHash = 0; | |
| 169 PKIX_PL_CertPolicyMap *certMap = NULL; | |
| 170 | |
| 171 PKIX_ENTER(CERTPOLICYMAP, "pkix_pl_CertPolicyMap_Hashcode"); | |
| 172 | |
| 173 PKIX_NULLCHECK_TWO(object, pHashcode); | |
| 174 | |
| 175 PKIX_CHECK(pkix_CheckType(object, PKIX_CERTPOLICYMAP_TYPE, plContext), | |
| 176 PKIX_OBJECTNOTCERTPOLICYMAP); | |
| 177 | |
| 178 certMap = (PKIX_PL_CertPolicyMap *)object; | |
| 179 | |
| 180 PKIX_HASHCODE | |
| 181 (certMap->issuerDomainPolicy, | |
| 182 &issuerHash, | |
| 183 plContext, | |
| 184 PKIX_OBJECTHASHCODEFAILED); | |
| 185 | |
| 186 PKIX_HASHCODE | |
| 187 (certMap->subjectDomainPolicy, | |
| 188 &subjectHash, | |
| 189 plContext, | |
| 190 PKIX_OBJECTHASHCODEFAILED); | |
| 191 | |
| 192 *pHashcode = issuerHash*31 + subjectHash; | |
| 193 | |
| 194 cleanup: | |
| 195 | |
| 196 PKIX_RETURN(CERTPOLICYMAP); | |
| 197 } | |
| 198 | |
| 199 /* | |
| 200 * FUNCTION: pkix_pl_CertPolicyMap_Equals | |
| 201 * (see comments for PKIX_PL_Equals_Callback in pkix_pl_system.h) | |
| 202 */ | |
| 203 static PKIX_Error * | |
| 204 pkix_pl_CertPolicyMap_Equals( | |
| 205 PKIX_PL_Object *firstObject, | |
| 206 PKIX_PL_Object *secondObject, | |
| 207 PKIX_Boolean *pResult, | |
| 208 void *plContext) | |
| 209 { | |
| 210 PKIX_PL_CertPolicyMap *firstCertMap = NULL; | |
| 211 PKIX_PL_CertPolicyMap *secondCertMap = NULL; | |
| 212 PKIX_UInt32 secondType = 0; | |
| 213 PKIX_Boolean compare = PKIX_FALSE; | |
| 214 | |
| 215 PKIX_ENTER(CERTPOLICYMAP, "pkix_pl_CertPolicyMap_Equals"); | |
| 216 PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult); | |
| 217 | |
| 218 /* test that firstObject is a CertPolicyMap */ | |
| 219 PKIX_CHECK(pkix_CheckType | |
| 220 (firstObject, PKIX_CERTPOLICYMAP_TYPE, plContext), | |
| 221 PKIX_FIRSTOBJECTNOTCERTPOLICYMAP); | |
| 222 | |
| 223 /* | |
| 224 * Since we know firstObject is a CertPolicyMap, | |
| 225 * if both references are identical, they must be equal | |
| 226 */ | |
| 227 if (firstObject == secondObject){ | |
| 228 *pResult = PKIX_TRUE; | |
| 229 goto cleanup; | |
| 230 } | |
| 231 | |
| 232 /* | |
| 233 * If secondObject isn't a CertPolicyMap, we | |
| 234 * don't throw an error. We simply return FALSE. | |
| 235 */ | |
| 236 PKIX_CHECK(PKIX_PL_Object_GetType | |
| 237 (secondObject, &secondType, plContext), | |
| 238 PKIX_COULDNOTGETTYPEOFSECONDARGUMENT); | |
| 239 if (secondType != PKIX_CERTPOLICYMAP_TYPE) { | |
| 240 *pResult = PKIX_FALSE; | |
| 241 goto cleanup; | |
| 242 } | |
| 243 | |
| 244 firstCertMap = (PKIX_PL_CertPolicyMap *)firstObject; | |
| 245 secondCertMap = (PKIX_PL_CertPolicyMap *)secondObject; | |
| 246 | |
| 247 PKIX_EQUALS | |
| 248 (firstCertMap->issuerDomainPolicy, | |
| 249 secondCertMap->issuerDomainPolicy, | |
| 250 &compare, | |
| 251 plContext, | |
| 252 PKIX_OBJECTEQUALSFAILED); | |
| 253 | |
| 254 if (compare) { | |
| 255 PKIX_EQUALS | |
| 256 (firstCertMap->subjectDomainPolicy, | |
| 257 secondCertMap->subjectDomainPolicy, | |
| 258 &compare, | |
| 259 plContext, | |
| 260 PKIX_OBJECTEQUALSFAILED); | |
| 261 } | |
| 262 | |
| 263 *pResult = compare; | |
| 264 | |
| 265 cleanup: | |
| 266 | |
| 267 PKIX_RETURN(CERTPOLICYMAP); | |
| 268 } | |
| 269 | |
| 270 /* | |
| 271 * FUNCTION: pkix_pl_CertPolicyMap_Duplicate | |
| 272 * (see comments for PKIX_PL_Duplicate_Callback in pkix_pl_system.h) | |
| 273 */ | |
| 274 static PKIX_Error * | |
| 275 pkix_pl_CertPolicyMap_Duplicate( | |
| 276 PKIX_PL_Object *object, | |
| 277 PKIX_PL_Object **pNewObject, | |
| 278 void *plContext) | |
| 279 { | |
| 280 PKIX_PL_CertPolicyMap *original = NULL; | |
| 281 PKIX_PL_CertPolicyMap *copy = NULL; | |
| 282 | |
| 283 PKIX_ENTER(CERTPOLICYMAP, "pkix_pl_CertPolicyMap_Duplicate"); | |
| 284 | |
| 285 PKIX_NULLCHECK_TWO(object, pNewObject); | |
| 286 | |
| 287 PKIX_CHECK(pkix_CheckType | |
| 288 (object, PKIX_CERTPOLICYMAP_TYPE, plContext), | |
| 289 PKIX_OBJECTARGUMENTNOTPOLICYMAP); | |
| 290 | |
| 291 original = (PKIX_PL_CertPolicyMap *)object; | |
| 292 | |
| 293 PKIX_CHECK(pkix_pl_CertPolicyMap_Create | |
| 294 (original->issuerDomainPolicy, | |
| 295 original->subjectDomainPolicy, | |
| 296 ©, | |
| 297 plContext), | |
| 298 PKIX_CERTPOLICYMAPCREATEFAILED); | |
| 299 | |
| 300 *pNewObject = (PKIX_PL_Object *)copy; | |
| 301 | |
| 302 cleanup: | |
| 303 | |
| 304 PKIX_RETURN(CERTPOLICYMAP); | |
| 305 } | |
| 306 | |
| 307 /* | |
| 308 * FUNCTION: pkix_pl_CertPolicyMap_RegisterSelf | |
| 309 * DESCRIPTION: | |
| 310 * Registers PKIX_CERTPOLICYMAP_TYPE and its related | |
| 311 * functions with systemClasses[] | |
| 312 * THREAD SAFETY: | |
| 313 * Not Thread Safe - for performance and complexity reasons | |
| 314 * | |
| 315 * Since this function is only called by PKIX_PL_Initialize, | |
| 316 * which should only be called once, it is acceptable that | |
| 317 * this function is not thread-safe. | |
| 318 */ | |
| 319 PKIX_Error * | |
| 320 pkix_pl_CertPolicyMap_RegisterSelf(void *plContext) | |
| 321 { | |
| 322 extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES]; | |
| 323 pkix_ClassTable_Entry entry; | |
| 324 | |
| 325 PKIX_ENTER(CERTPOLICYMAP, "pkix_pl_CertPolicyMap_RegisterSelf"); | |
| 326 | |
| 327 entry.description = "CertPolicyMap"; | |
| 328 entry.objCounter = 0; | |
| 329 entry.typeObjectSize = sizeof(PKIX_PL_CertPolicyMap); | |
| 330 entry.destructor = pkix_pl_CertPolicyMap_Destroy; | |
| 331 entry.equalsFunction = pkix_pl_CertPolicyMap_Equals; | |
| 332 entry.hashcodeFunction = pkix_pl_CertPolicyMap_Hashcode; | |
| 333 entry.toStringFunction = pkix_pl_CertPolicyMap_ToString; | |
| 334 entry.comparator = NULL; | |
| 335 entry.duplicateFunction = pkix_pl_CertPolicyMap_Duplicate; | |
| 336 | |
| 337 systemClasses[PKIX_CERTPOLICYMAP_TYPE] = entry; | |
| 338 | |
| 339 PKIX_RETURN(CERTPOLICYMAP); | |
| 340 } | |
| 341 | |
| 342 /* --Public-CertPolicyMap-Functions------------------------- */ | |
| 343 | |
| 344 /* | |
| 345 * FUNCTION: PKIX_PL_CertPolicyMap_GetIssuerDomainPolicy | |
| 346 * (see comments in pkix_pl_pki.h) | |
| 347 */ | |
| 348 PKIX_Error * | |
| 349 PKIX_PL_CertPolicyMap_GetIssuerDomainPolicy( | |
| 350 PKIX_PL_CertPolicyMap *policyMapping, | |
| 351 PKIX_PL_OID **pIssuerDomainPolicy, | |
| 352 void *plContext) | |
| 353 { | |
| 354 PKIX_ENTER | |
| 355 (CERTPOLICYMAP, "PKIX_PL_CertPolicyMap_GetIssuerDomainPolicy"); | |
| 356 | |
| 357 PKIX_NULLCHECK_TWO(policyMapping, pIssuerDomainPolicy); | |
| 358 | |
| 359 PKIX_INCREF(policyMapping->issuerDomainPolicy); | |
| 360 *pIssuerDomainPolicy = policyMapping->issuerDomainPolicy; | |
| 361 | |
| 362 cleanup: | |
| 363 PKIX_RETURN(CERTPOLICYMAP); | |
| 364 } | |
| 365 | |
| 366 /* | |
| 367 * FUNCTION: PKIX_PL_CertPolicyMap_GetSubjectDomainPolicy | |
| 368 * (see comments in pkix_pl_pki.h) | |
| 369 */ | |
| 370 PKIX_Error * | |
| 371 PKIX_PL_CertPolicyMap_GetSubjectDomainPolicy( | |
| 372 PKIX_PL_CertPolicyMap *policyMapping, | |
| 373 PKIX_PL_OID **pSubjectDomainPolicy, | |
| 374 void *plContext) | |
| 375 { | |
| 376 PKIX_ENTER | |
| 377 (CERTPOLICYMAP, "PKIX_PL_CertPolicyMap_GetSubjectDomainPolicy"); | |
| 378 | |
| 379 PKIX_NULLCHECK_TWO(policyMapping, pSubjectDomainPolicy); | |
| 380 | |
| 381 PKIX_INCREF(policyMapping->subjectDomainPolicy); | |
| 382 *pSubjectDomainPolicy = policyMapping->subjectDomainPolicy; | |
| 383 | |
| 384 cleanup: | |
| 385 PKIX_RETURN(CERTPOLICYMAP); | |
| 386 } | |
| 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