| 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_certpolicyinfo.c | |
| 6 * | |
| 7 * CertPolicyInfo Type Functions | |
| 8 * | |
| 9 */ | |
| 10 | |
| 11 #include "pkix_pl_certpolicyinfo.h" | |
| 12 | |
| 13 /* | |
| 14 * FUNCTION: pkix_pl_CertPolicyInfo_Create | |
| 15 * DESCRIPTION: | |
| 16 * | |
| 17 * Creates a new CertPolicyInfo Object using the OID pointed to by "oid" and | |
| 18 * the List of CertPolicyQualifiers pointed to by "qualifiers", and stores it | |
| 19 * at "pObject". If a non-NULL list is provided, the caller is expected to | |
| 20 * have already set it to be immutable. The caller may provide an empty List, | |
| 21 * but a NULL List is preferable so a user does not need to call | |
| 22 * List_GetLength to get the number of qualifiers. | |
| 23 * | |
| 24 * PARAMETERS | |
| 25 * "oid" | |
| 26 * OID of the desired PolicyInfo ID; must be non-NULL | |
| 27 * "qualifiers" | |
| 28 * List of CertPolicyQualifiers; may be NULL or empty | |
| 29 * "pObject" | |
| 30 * Address where object pointer will be stored. Must be non-NULL. | |
| 31 * "plContext" | |
| 32 * Platform-specific context pointer. | |
| 33 * THREAD SAFETY: | |
| 34 * Thread Safe (see Thread Safety Definitions in Programmer's Guide) | |
| 35 * RETURNS: | |
| 36 * Returns NULL if the function succeeds. | |
| 37 * Returns a Fatal Error if the function fails in an unrecoverable way. | |
| 38 */ | |
| 39 PKIX_Error * | |
| 40 pkix_pl_CertPolicyInfo_Create( | |
| 41 PKIX_PL_OID *oid, | |
| 42 PKIX_List *qualifiers, | |
| 43 PKIX_PL_CertPolicyInfo **pObject, | |
| 44 void *plContext) | |
| 45 { | |
| 46 PKIX_PL_CertPolicyInfo *policyInfo = NULL; | |
| 47 | |
| 48 PKIX_ENTER(CERTPOLICYINFO, "pkix_pl_CertPolicyInfo_Create"); | |
| 49 | |
| 50 PKIX_NULLCHECK_TWO(oid, pObject); | |
| 51 | |
| 52 PKIX_CHECK(PKIX_PL_Object_Alloc | |
| 53 (PKIX_CERTPOLICYINFO_TYPE, | |
| 54 sizeof (PKIX_PL_CertPolicyInfo), | |
| 55 (PKIX_PL_Object **)&policyInfo, | |
| 56 plContext), | |
| 57 PKIX_COULDNOTCREATECERTPOLICYINFOOBJECT); | |
| 58 | |
| 59 PKIX_INCREF(oid); | |
| 60 policyInfo->cpID = oid; | |
| 61 | |
| 62 PKIX_INCREF(qualifiers); | |
| 63 policyInfo->policyQualifiers = qualifiers; | |
| 64 | |
| 65 *pObject = policyInfo; | |
| 66 policyInfo = NULL; | |
| 67 | |
| 68 cleanup: | |
| 69 PKIX_DECREF(policyInfo); | |
| 70 | |
| 71 PKIX_RETURN(CERTPOLICYINFO); | |
| 72 } | |
| 73 | |
| 74 /* | |
| 75 * FUNCTION: pkix_pl_CertPolicyInfo_Destroy | |
| 76 * (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h) | |
| 77 */ | |
| 78 static PKIX_Error * | |
| 79 pkix_pl_CertPolicyInfo_Destroy( | |
| 80 PKIX_PL_Object *object, | |
| 81 void *plContext) | |
| 82 { | |
| 83 PKIX_PL_CertPolicyInfo *certPI = NULL; | |
| 84 | |
| 85 PKIX_ENTER(CERTPOLICYINFO, "pkix_pl_CertPolicyInfo_Destroy"); | |
| 86 | |
| 87 PKIX_NULLCHECK_ONE(object); | |
| 88 | |
| 89 PKIX_CHECK(pkix_CheckType(object, PKIX_CERTPOLICYINFO_TYPE, plContext), | |
| 90 PKIX_OBJECTNOTCERTPOLICYINFO); | |
| 91 | |
| 92 certPI = (PKIX_PL_CertPolicyInfo*)object; | |
| 93 | |
| 94 PKIX_DECREF(certPI->cpID); | |
| 95 PKIX_DECREF(certPI->policyQualifiers); | |
| 96 | |
| 97 cleanup: | |
| 98 | |
| 99 PKIX_RETURN(CERTPOLICYINFO); | |
| 100 } | |
| 101 | |
| 102 /* | |
| 103 * FUNCTION: pkix_pl_CertPolicyInfo_ToString | |
| 104 * (see comments for PKIX_PL_ToStringCallback in pkix_pl_system.h) | |
| 105 */ | |
| 106 static PKIX_Error * | |
| 107 pkix_pl_CertPolicyInfo_ToString( | |
| 108 PKIX_PL_Object *object, | |
| 109 PKIX_PL_String **pString, | |
| 110 void *plContext) | |
| 111 { | |
| 112 PKIX_PL_CertPolicyInfo *certPI = NULL; | |
| 113 PKIX_PL_String *oidString = NULL; | |
| 114 PKIX_PL_String *listString = NULL; | |
| 115 PKIX_PL_String *format = NULL; | |
| 116 PKIX_PL_String *outString = NULL; | |
| 117 | |
| 118 PKIX_ENTER(CERTPOLICYINFO, "pkix_pl_CertPolicyInfo_ToString"); | |
| 119 | |
| 120 PKIX_NULLCHECK_TWO(object, pString); | |
| 121 | |
| 122 PKIX_CHECK(pkix_CheckType(object, PKIX_CERTPOLICYINFO_TYPE, plContext), | |
| 123 PKIX_OBJECTNOTCERTPOLICYINFO); | |
| 124 | |
| 125 certPI = (PKIX_PL_CertPolicyInfo *)object; | |
| 126 | |
| 127 PKIX_NULLCHECK_ONE(certPI->cpID); | |
| 128 | |
| 129 PKIX_TOSTRING | |
| 130 (certPI->cpID, | |
| 131 &oidString, | |
| 132 plContext, | |
| 133 PKIX_OIDTOSTRINGFAILED); | |
| 134 | |
| 135 PKIX_TOSTRING | |
| 136 (certPI->policyQualifiers, | |
| 137 &listString, | |
| 138 plContext, | |
| 139 PKIX_LISTTOSTRINGFAILED); | |
| 140 | |
| 141 /* Put them together in the form OID[Qualifiers] */ | |
| 142 PKIX_CHECK(PKIX_PL_String_Create | |
| 143 (PKIX_ESCASCII, "%s[%s]", 0, &format, plContext), | |
| 144 PKIX_ERRORINSTRINGCREATE); | |
| 145 | |
| 146 PKIX_CHECK(PKIX_PL_Sprintf | |
| 147 (&outString, plContext, format, oidString, listString), | |
| 148 PKIX_ERRORINSPRINTF); | |
| 149 | |
| 150 *pString = outString; | |
| 151 | |
| 152 cleanup: | |
| 153 | |
| 154 PKIX_DECREF(oidString); | |
| 155 PKIX_DECREF(listString); | |
| 156 PKIX_DECREF(format); | |
| 157 PKIX_RETURN(CERTPOLICYINFO); | |
| 158 } | |
| 159 | |
| 160 /* | |
| 161 * FUNCTION: pkix_pl_CertPolicyInfo_Hashcode | |
| 162 * (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h) | |
| 163 */ | |
| 164 static PKIX_Error * | |
| 165 pkix_pl_CertPolicyInfo_Hashcode( | |
| 166 PKIX_PL_Object *object, | |
| 167 PKIX_UInt32 *pHashcode, | |
| 168 void *plContext) | |
| 169 { | |
| 170 PKIX_PL_CertPolicyInfo *certPI = NULL; | |
| 171 PKIX_UInt32 oidHash = 0; | |
| 172 PKIX_UInt32 listHash = 0; | |
| 173 | |
| 174 PKIX_ENTER(CERTPOLICYINFO, "pkix_pl_CertPolicyInfo_Hashcode"); | |
| 175 | |
| 176 PKIX_NULLCHECK_TWO(object, pHashcode); | |
| 177 | |
| 178 PKIX_CHECK(pkix_CheckType(object, PKIX_CERTPOLICYINFO_TYPE, plContext), | |
| 179 PKIX_OBJECTNOTCERTPOLICYINFO); | |
| 180 | |
| 181 certPI = (PKIX_PL_CertPolicyInfo *)object; | |
| 182 | |
| 183 PKIX_NULLCHECK_ONE(certPI->cpID); | |
| 184 | |
| 185 PKIX_HASHCODE | |
| 186 (certPI->cpID, | |
| 187 &oidHash, | |
| 188 plContext, | |
| 189 PKIX_ERRORINOIDHASHCODE); | |
| 190 | |
| 191 PKIX_HASHCODE | |
| 192 (certPI->policyQualifiers, | |
| 193 &listHash, | |
| 194 plContext, | |
| 195 PKIX_ERRORINLISTHASHCODE); | |
| 196 | |
| 197 *pHashcode = (31 * oidHash) + listHash; | |
| 198 | |
| 199 cleanup: | |
| 200 | |
| 201 PKIX_RETURN(CERTPOLICYINFO); | |
| 202 } | |
| 203 | |
| 204 | |
| 205 /* | |
| 206 * FUNCTION: pkix_pl_CertPolicyInfo_Equals | |
| 207 * (see comments for PKIX_PL_Equals_Callback in pkix_pl_system.h) | |
| 208 */ | |
| 209 static PKIX_Error * | |
| 210 pkix_pl_CertPolicyInfo_Equals( | |
| 211 PKIX_PL_Object *firstObject, | |
| 212 PKIX_PL_Object *secondObject, | |
| 213 PKIX_Boolean *pResult, | |
| 214 void *plContext) | |
| 215 { | |
| 216 PKIX_PL_CertPolicyInfo *firstCPI = NULL; | |
| 217 PKIX_PL_CertPolicyInfo *secondCPI = NULL; | |
| 218 PKIX_UInt32 secondType = 0; | |
| 219 PKIX_Boolean compare = PKIX_FALSE; | |
| 220 | |
| 221 PKIX_ENTER(CERTPOLICYINFO, "pkix_pl_CertPolicyInfo_Equals"); | |
| 222 PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult); | |
| 223 | |
| 224 /* test that firstObject is a CertPolicyInfo */ | |
| 225 PKIX_CHECK(pkix_CheckType | |
| 226 (firstObject, PKIX_CERTPOLICYINFO_TYPE, plContext), | |
| 227 PKIX_FIRSTOBJECTNOTCERTPOLICYINFO); | |
| 228 | |
| 229 /* | |
| 230 * Since we know firstObject is a CertPolicyInfo, | |
| 231 * if both references are identical, they must be equal | |
| 232 */ | |
| 233 if (firstObject == secondObject){ | |
| 234 *pResult = PKIX_TRUE; | |
| 235 goto cleanup; | |
| 236 } | |
| 237 | |
| 238 /* | |
| 239 * If secondObject isn't a CertPolicyInfo, we | |
| 240 * don't throw an error. We simply return FALSE. | |
| 241 */ | |
| 242 PKIX_CHECK(PKIX_PL_Object_GetType | |
| 243 (secondObject, &secondType, plContext), | |
| 244 PKIX_COULDNOTGETTYPEOFSECONDARGUMENT); | |
| 245 if (secondType != PKIX_CERTPOLICYINFO_TYPE) { | |
| 246 *pResult = PKIX_FALSE; | |
| 247 goto cleanup; | |
| 248 } | |
| 249 | |
| 250 firstCPI = (PKIX_PL_CertPolicyInfo *)firstObject; | |
| 251 secondCPI = (PKIX_PL_CertPolicyInfo *)secondObject; | |
| 252 | |
| 253 /* | |
| 254 * Compare the value of the OID components | |
| 255 */ | |
| 256 | |
| 257 PKIX_NULLCHECK_TWO(firstCPI->cpID, secondCPI->cpID); | |
| 258 | |
| 259 PKIX_EQUALS | |
| 260 (firstCPI->cpID, | |
| 261 secondCPI->cpID, | |
| 262 &compare, | |
| 263 plContext, | |
| 264 PKIX_OIDEQUALSFAILED); | |
| 265 | |
| 266 /* | |
| 267 * If the OIDs did not match, we don't need to | |
| 268 * compare the Lists. If the OIDs did match, | |
| 269 * the return value is the value of the | |
| 270 * List comparison. | |
| 271 */ | |
| 272 if (compare) { | |
| 273 PKIX_EQUALS | |
| 274 (firstCPI->policyQualifiers, | |
| 275 secondCPI->policyQualifiers, | |
| 276 &compare, | |
| 277 plContext, | |
| 278 PKIX_LISTEQUALSFAILED); | |
| 279 } | |
| 280 | |
| 281 *pResult = compare; | |
| 282 | |
| 283 cleanup: | |
| 284 | |
| 285 PKIX_RETURN(CERTPOLICYINFO); | |
| 286 } | |
| 287 | |
| 288 /* | |
| 289 * FUNCTION: pkix_pl_CertPolicyInfo_RegisterSelf | |
| 290 * DESCRIPTION: | |
| 291 * Registers PKIX_CERTPOLICYINFO_TYPE and its related | |
| 292 * functions with systemClasses[] | |
| 293 * THREAD SAFETY: | |
| 294 * Not Thread Safe - for performance and complexity reasons | |
| 295 * | |
| 296 * Since this function is only called by PKIX_PL_Initialize, | |
| 297 * which should only be called once, it is acceptable that | |
| 298 * this function is not thread-safe. | |
| 299 */ | |
| 300 PKIX_Error * | |
| 301 pkix_pl_CertPolicyInfo_RegisterSelf(void *plContext) | |
| 302 { | |
| 303 extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES]; | |
| 304 pkix_ClassTable_Entry entry; | |
| 305 | |
| 306 PKIX_ENTER(CERTPOLICYINFO, "pkix_pl_CertPolicyInfo_RegisterSelf"); | |
| 307 | |
| 308 entry.description = "CertPolicyInfo"; | |
| 309 entry.objCounter = 0; | |
| 310 entry.typeObjectSize = sizeof(PKIX_PL_CertPolicyInfo); | |
| 311 entry.destructor = pkix_pl_CertPolicyInfo_Destroy; | |
| 312 entry.equalsFunction = pkix_pl_CertPolicyInfo_Equals; | |
| 313 entry.hashcodeFunction = pkix_pl_CertPolicyInfo_Hashcode; | |
| 314 entry.toStringFunction = pkix_pl_CertPolicyInfo_ToString; | |
| 315 entry.comparator = NULL; | |
| 316 entry.duplicateFunction = pkix_duplicateImmutable; | |
| 317 | |
| 318 systemClasses[PKIX_CERTPOLICYINFO_TYPE] = entry; | |
| 319 | |
| 320 PKIX_RETURN(CERTPOLICYINFO); | |
| 321 } | |
| 322 | |
| 323 /* --Public-CertPolicyInfo-Functions------------------------- */ | |
| 324 | |
| 325 /* | |
| 326 * FUNCTION: PKIX_PL_CertPolicyInfo_GetPolicyId | |
| 327 * (see comments in pkix_pl_pki.h) | |
| 328 */ | |
| 329 PKIX_Error * | |
| 330 PKIX_PL_CertPolicyInfo_GetPolicyId( | |
| 331 PKIX_PL_CertPolicyInfo *policyInfo, | |
| 332 PKIX_PL_OID **pPolicyId, | |
| 333 void *plContext) | |
| 334 { | |
| 335 PKIX_ENTER(CERTPOLICYINFO, "PKIX_PL_CertPolicyInfo_GetPolicyId"); | |
| 336 | |
| 337 PKIX_NULLCHECK_TWO(policyInfo, pPolicyId); | |
| 338 | |
| 339 PKIX_INCREF(policyInfo->cpID); | |
| 340 | |
| 341 *pPolicyId = policyInfo->cpID; | |
| 342 | |
| 343 cleanup: | |
| 344 PKIX_RETURN(CERTPOLICYINFO); | |
| 345 } | |
| 346 | |
| 347 /* | |
| 348 * FUNCTION: PKIX_PL_CertPolicyInfo_GetPolQualifiers | |
| 349 * (see comments in pkix_pl_pki.h) | |
| 350 */ | |
| 351 PKIX_Error * | |
| 352 PKIX_PL_CertPolicyInfo_GetPolQualifiers( | |
| 353 PKIX_PL_CertPolicyInfo *policyInfo, | |
| 354 PKIX_List **pQuals, | |
| 355 void *plContext) | |
| 356 { | |
| 357 PKIX_ENTER(CERTPOLICYINFO, "PKIX_PL_CertPolicyInfo_GetPolQualifiers"); | |
| 358 | |
| 359 PKIX_NULLCHECK_TWO(policyInfo, pQuals); | |
| 360 | |
| 361 PKIX_INCREF(policyInfo->policyQualifiers); | |
| 362 | |
| 363 /* | |
| 364 * This List is created in PKIX_PL_Cert_DecodePolicyInfo | |
| 365 * and is set immutable immediately after being created. | |
| 366 */ | |
| 367 *pQuals = policyInfo->policyQualifiers; | |
| 368 | |
| 369 cleanup: | |
| 370 PKIX_RETURN(CERTPOLICYINFO); | |
| 371 } | |
| 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