pkix_pl_certpolicymap.c (11544B)
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 }