The Tor Browser: security/nss/lib/libpkix/pkix/params/pkix

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     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_valparams.c

     6  *

     7  * Validate Params Object Functions

     8  *

     9  */

    11 #include "pkix_valparams.h"

    13 /* --Private-Functions-------------------------------------------- */

    15 /*

    16  * FUNCTION: pkix_ValidateParams_Destroy

    17  * (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)

    18  */

    19 static PKIX_Error *

    20 pkix_ValidateParams_Destroy(

    21         PKIX_PL_Object *object,

    22         void *plContext)

    23 {

    24         PKIX_ValidateParams *params = NULL;

    26         PKIX_ENTER(VALIDATEPARAMS, "pkix_ValidateParams_Destroy");

    27         PKIX_NULLCHECK_ONE(object);

    29         /* Check that this object is a validate params object */

    30         PKIX_CHECK(pkix_CheckType(object, PKIX_VALIDATEPARAMS_TYPE, plContext),

    31                     PKIX_OBJECTNOTVALIDATEPARAMS);

    33         params = (PKIX_ValidateParams *)object;

    35         PKIX_DECREF(params->procParams);

    36         PKIX_DECREF(params->chain);

    38 cleanup:

    40         PKIX_RETURN(VALIDATEPARAMS);

    41 }

    43 /*

    44  * FUNCTION: pkix_ValidateParams_Equals

    45  * (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h)

    46  */

    47 static PKIX_Error *

    48 pkix_ValidateParams_Equals(

    49         PKIX_PL_Object *first,

    50         PKIX_PL_Object *second,

    51         PKIX_Boolean *pResult,

    52         void *plContext)

    53 {

    54         PKIX_UInt32 secondType;

    55         PKIX_Boolean cmpResult;

    56         PKIX_ValidateParams *firstValParams = NULL;

    57         PKIX_ValidateParams *secondValParams = NULL;

    59         PKIX_ENTER(VALIDATEPARAMS, "pkix_ValidateParams_Equals");

    60         PKIX_NULLCHECK_THREE(first, second, pResult);

    62         PKIX_CHECK(pkix_CheckType(first, PKIX_VALIDATEPARAMS_TYPE, plContext),

    63                     PKIX_FIRSTOBJECTNOTVALIDATEPARAMS);

    65         PKIX_CHECK(PKIX_PL_Object_GetType(second, &secondType, plContext),

    66                     PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);

    68         *pResult = PKIX_FALSE;

    70         if (secondType != PKIX_VALIDATEPARAMS_TYPE) goto cleanup;

    72         firstValParams = (PKIX_ValidateParams *)first;

    73         secondValParams = (PKIX_ValidateParams *)second;

    75         PKIX_CHECK(PKIX_PL_Object_Equals

    76                     ((PKIX_PL_Object *)firstValParams->procParams,

    77                     (PKIX_PL_Object *)secondValParams->procParams,

    78                     &cmpResult,

    79                     plContext),

    80                     PKIX_OBJECTEQUALSFAILED);

    82         if (!cmpResult) goto cleanup;

    84         PKIX_CHECK(PKIX_PL_Object_Equals

    85                     ((PKIX_PL_Object *)firstValParams->chain,

    86                     (PKIX_PL_Object *)secondValParams->chain,

    87                     &cmpResult,

    88                     plContext),

    89                     PKIX_OBJECTEQUALSFAILED);

    91         if (!cmpResult) goto cleanup;

    93         *pResult = cmpResult;

    95 cleanup:

    97         PKIX_RETURN(VALIDATEPARAMS);

    98 }

   100 /*

   101  * FUNCTION: pkix_ValidateParams_Hashcode

   102  * (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)

   103  */

   104 static PKIX_Error *

   105 pkix_ValidateParams_Hashcode(

   106         PKIX_PL_Object *object,

   107         PKIX_UInt32 *pHashcode,

   108         void *plContext)

   109 {

   110         PKIX_ValidateParams *valParams = NULL;

   111         PKIX_UInt32 hash = 0;

   112         PKIX_UInt32 procParamsHash = 0;

   113         PKIX_UInt32 chainHash = 0;

   115         PKIX_ENTER(VALIDATEPARAMS, "pkix_ValidateParams_Hashcode");

   116         PKIX_NULLCHECK_TWO(object, pHashcode);

   118         PKIX_CHECK(pkix_CheckType(object, PKIX_VALIDATEPARAMS_TYPE, plContext),

   119                     PKIX_OBJECTNOTVALIDATEPARAMS);

   121         valParams = (PKIX_ValidateParams*)object;

   123         PKIX_CHECK(PKIX_PL_Object_Hashcode

   124                     ((PKIX_PL_Object *)valParams->procParams,

   125                     &procParamsHash,

   126                     plContext),

   127                     PKIX_OBJECTHASHCODEFAILED);

   129         PKIX_CHECK(PKIX_PL_Object_Hashcode

   130                     ((PKIX_PL_Object *)valParams->chain,

   131                     &chainHash,

   132                     plContext),

   133                     PKIX_OBJECTHASHCODEFAILED);

   135         hash = 31 * procParamsHash + chainHash;

   137         *pHashcode = hash;

   139 cleanup:

   141         PKIX_RETURN(VALIDATEPARAMS);

   142 }

   144 /*

   145  * FUNCTION: pkix_ValidateParams_ToString

   146  * (see comments for PKIX_PL_ToStringCallback in pkix_pl_system.h)

   147  */

   148 static PKIX_Error *

   149 pkix_ValidateParams_ToString(

   150         PKIX_PL_Object *object,

   151         PKIX_PL_String **pString,

   152         void *plContext)

   153 {

   154         PKIX_ValidateParams *valParams = NULL;

   155         char *asciiFormat = NULL;

   156         PKIX_PL_String *formatString = NULL;

   157         PKIX_PL_String *valParamsString = NULL;

   159         PKIX_PL_String *procParamsString = NULL;

   160         PKIX_PL_String *chainString = NULL;

   162         PKIX_ENTER(VALIDATEPARAMS, "pkix_ValidateParams_ToString");

   163         PKIX_NULLCHECK_TWO(object, pString);

   165         PKIX_CHECK(pkix_CheckType(object, PKIX_VALIDATEPARAMS_TYPE, plContext),

   166                     PKIX_OBJECTNOTVALIDATEPARAMS);

   168         asciiFormat =

   169                 "[\n"

   170                 "\tProcessing Params: \n"

   171                 "\t********BEGIN PROCESSING PARAMS********\n"

   172                 "\t\t%s\n"

   173                 "\t********END PROCESSING PARAMS********\n"

   174                 "\tChain:    \t\t%s\n"

   175                 "]\n";

   177         PKIX_CHECK(PKIX_PL_String_Create

   178                     (PKIX_ESCASCII,

   179                     asciiFormat,

   180                     0,

   181                     &formatString,

   182                     plContext),

   183                     PKIX_STRINGCREATEFAILED);

   185         valParams = (PKIX_ValidateParams*)object;

   187         PKIX_CHECK(PKIX_PL_Object_ToString

   188                     ((PKIX_PL_Object*)valParams->procParams,

   189                     &procParamsString,

   190                     plContext),

   191                     PKIX_OBJECTTOSTRINGFAILED);

   193         PKIX_CHECK(PKIX_PL_Object_ToString

   194                     ((PKIX_PL_Object *)valParams->chain,

   195                     &chainString,

   196                     plContext),

   197                     PKIX_OBJECTTOSTRINGFAILED);

   199         PKIX_CHECK(PKIX_PL_Sprintf

   200                     (&valParamsString,

   201                     plContext,

   202                     formatString,

   203                     procParamsString,

   204                     chainString),

   205                     PKIX_SPRINTFFAILED);

   207         *pString = valParamsString;

   209 cleanup:

   211         PKIX_DECREF(formatString);

   212         PKIX_DECREF(procParamsString);

   213         PKIX_DECREF(chainString);

   215         PKIX_RETURN(VALIDATEPARAMS);

   216 }

   218 /*

   219  * FUNCTION: pkix_ValidateParams_RegisterSelf

   220  * DESCRIPTION:

   221  *  Registers PKIX_VALIDATEPARAMS_TYPE and its related functions with

   222  *  systemClasses[]

   223  * THREAD SAFETY:

   224  *  Not Thread Safe - for performance and complexity reasons

   225  *

   226  *  Since this function is only called by PKIX_PL_Initialize, which should

   227  *  only be called once, it is acceptable that this function is not

   228  *  thread-safe.

   229  */

   230 PKIX_Error *

   231 pkix_ValidateParams_RegisterSelf(void *plContext)

   232 {

   234         extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES];

   235         pkix_ClassTable_Entry entry;

   237         PKIX_ENTER(VALIDATEPARAMS, "pkix_ValidateParams_RegisterSelf");

   239         entry.description = "ValidateParams";

   240         entry.objCounter = 0;

   241         entry.typeObjectSize = sizeof(PKIX_ValidateParams);

   242         entry.destructor = pkix_ValidateParams_Destroy;

   243         entry.equalsFunction = pkix_ValidateParams_Equals;

   244         entry.hashcodeFunction = pkix_ValidateParams_Hashcode;

   245         entry.toStringFunction = pkix_ValidateParams_ToString;

   246         entry.comparator = NULL;

   247         entry.duplicateFunction = NULL;

   249         systemClasses[PKIX_VALIDATEPARAMS_TYPE] = entry;

   251         PKIX_RETURN(VALIDATEPARAMS);

   252 }

   254 /* --Public-Functions--------------------------------------------- */

   256 /*

   257  * FUNCTION: PKIX_ValidateParams_Create (see comments in pkix_params.h)

   258  */

   259 PKIX_Error *

   260 PKIX_ValidateParams_Create(

   261         PKIX_ProcessingParams *procParams,

   262         PKIX_List *chain,

   263         PKIX_ValidateParams **pParams,

   264         void *plContext)

   265 {

   266         PKIX_ValidateParams *params = NULL;

   268         PKIX_ENTER(VALIDATEPARAMS, "PKIX_ValidateParams_Create");

   269         PKIX_NULLCHECK_THREE(procParams, chain, pParams);

   271         PKIX_CHECK(PKIX_PL_Object_Alloc

   272                     (PKIX_VALIDATEPARAMS_TYPE,

   273                     sizeof (PKIX_ValidateParams),

   274                     (PKIX_PL_Object **)&params,

   275                     plContext),

   276                     PKIX_COULDNOTCREATEVALIDATEPARAMSOBJECT);

   278         /* initialize fields */

   279         PKIX_INCREF(procParams);

   280         params->procParams = procParams;

   282         PKIX_INCREF(chain);

   283         params->chain = chain;

   285         *pParams = params;

   286         params = NULL;

   288 cleanup:

   290         PKIX_DECREF(params);

   292         PKIX_RETURN(VALIDATEPARAMS);

   294 }

   296 /*

   297  * FUNCTION: PKIX_ValidateParams_GetProcessingParams

   298  *      (see comments in pkix_params.h)

   299  */

   300 PKIX_Error *

   301 PKIX_ValidateParams_GetProcessingParams(

   302         PKIX_ValidateParams *valParams,

   303         PKIX_ProcessingParams **pProcParams,

   304         void *plContext)

   305 {

   306         PKIX_ENTER(VALIDATEPARAMS, "PKIX_ValidateParams_GetProcessingParams");

   307         PKIX_NULLCHECK_TWO(valParams, pProcParams);

   309         PKIX_INCREF(valParams->procParams);

   311         *pProcParams = valParams->procParams;

   313 cleanup:

   314         PKIX_RETURN(VALIDATEPARAMS);

   315 }

   317 /*

   318  * FUNCTION: PKIX_ValidateParams_GetCertChain (see comments in pkix_params.h)

   319  */

   320 PKIX_Error *

   321 PKIX_ValidateParams_GetCertChain(

   322         PKIX_ValidateParams *valParams,

   323         PKIX_List **pChain,

   324         void *plContext)

   325 {

   326         PKIX_ENTER(VALIDATEPARAMS, "PKIX_ValidateParams_GetCertChain");

   327         PKIX_NULLCHECK_TWO(valParams, pChain);

   329         PKIX_INCREF(valParams->chain);

   331         *pChain = valParams->chain;

   333 cleanup:

   334         PKIX_RETURN(VALIDATEPARAMS);

   335 }

The Tor Browser / file revision

security/nss/lib/libpkix/pkix/params/pkix_valparams.c@6474c204b198

security/nss/lib/libpkix/pkix/params/pkix_valparams.c