mirror of
https://github.com/rn10950/RetroZilla.git
synced 2024-11-14 03:30:17 +01:00
834 lines
24 KiB
C
834 lines
24 KiB
C
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the
|
|
* License.
|
|
*
|
|
* The Original Code is the PKIX-C library.
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* Sun Microsystems, Inc.
|
|
* Portions created by the Initial Developer are
|
|
* Copyright 2004-2007 Sun Microsystems, Inc. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
* Sun Microsystems, Inc.
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
* the provisions above, a recipient may use your version of this file under
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
/*
|
|
* pkix_comcrlselparams.c
|
|
*
|
|
* ComCRLSelParams Function Definitions
|
|
*
|
|
*/
|
|
|
|
#include "pkix_comcrlselparams.h"
|
|
|
|
/* --ComCRLSelParams-Private-Functions------------------------------------ */
|
|
|
|
/*
|
|
* FUNCTION: pkix_ComCrlSelParams_Destroy
|
|
* (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
|
|
*/
|
|
static PKIX_Error *
|
|
pkix_ComCRLSelParams_Destroy(
|
|
PKIX_PL_Object *object,
|
|
void *plContext)
|
|
{
|
|
PKIX_ComCRLSelParams *params = NULL;
|
|
|
|
PKIX_ENTER(COMCRLSELPARAMS, "pkix_ComCRLSelParams_Destroy");
|
|
PKIX_NULLCHECK_ONE(object);
|
|
|
|
PKIX_CHECK(pkix_CheckType
|
|
(object, PKIX_COMCRLSELPARAMS_TYPE, plContext),
|
|
PKIX_OBJECTNOTCOMCRLSELPARAMS);
|
|
|
|
params = (PKIX_ComCRLSelParams *)object;
|
|
|
|
PKIX_DECREF(params->issuerNames);
|
|
PKIX_DECREF(params->cert);
|
|
PKIX_DECREF(params->date);
|
|
PKIX_DECREF(params->maxCRLNumber);
|
|
PKIX_DECREF(params->minCRLNumber);
|
|
|
|
cleanup:
|
|
|
|
PKIX_RETURN(COMCRLSELPARAMS);
|
|
}
|
|
|
|
/*
|
|
* FUNCTION: pkix_ComCRLSelParams_ToString_Helper
|
|
* DESCRIPTION:
|
|
*
|
|
* Helper function that creates a string representation of ComCRLSelParams
|
|
* pointed to by "crlParams" and stores the result at "pString".
|
|
*
|
|
* PARAMETERS
|
|
* "crlParams"
|
|
* Address of ComCRLSelParams whose string representation is desired.
|
|
* Must be non-NULL.
|
|
* "pString"
|
|
* Address of object pointer's destination. Must be non-NULL.
|
|
* "plContext" - Platform-specific context pointer.
|
|
*
|
|
* THREAD SAFETY:
|
|
* Conditionally Thread Safe
|
|
* (see Thread Safety Definitions in Programmer's Guide)
|
|
*
|
|
* RETURNS:
|
|
* Returns NULL if the function succeeds.
|
|
* Returns a CRLEntry Error if the function fails in a non-fatal way.
|
|
* Returns a Fatal Error if the function fails in an unrecoverable way.
|
|
*/
|
|
static PKIX_Error *
|
|
pkix_ComCRLSelParams_ToString_Helper(
|
|
PKIX_ComCRLSelParams *crlParams,
|
|
PKIX_PL_String **pString,
|
|
void *plContext)
|
|
{
|
|
PKIX_PL_String *crlIssuerNamesString = NULL;
|
|
PKIX_PL_String *crlDateString = NULL;
|
|
PKIX_PL_String *crlMaxCRLNumberString = NULL;
|
|
PKIX_PL_String *crlMinCRLNumberString = NULL;
|
|
PKIX_PL_String *crlCertString = NULL;
|
|
PKIX_PL_String *crlParamsString = NULL;
|
|
char *asciiFormat = NULL;
|
|
PKIX_PL_String *formatString = NULL;
|
|
|
|
PKIX_ENTER(COMCRLSELPARAMS, "pkix_ComCRLSelParams_ToString_Helper");
|
|
PKIX_NULLCHECK_TWO(crlParams, pString);
|
|
|
|
asciiFormat =
|
|
"\n\t[\n"
|
|
"\tIssuerNames: %s\n"
|
|
"\tDate: %s\n"
|
|
"\tmaxCRLNumber: %s\n"
|
|
"\tminCRLNumber: %s\n"
|
|
"\tCertificate: %s\n"
|
|
"\t]\n";
|
|
|
|
PKIX_CHECK(PKIX_PL_String_Create
|
|
(PKIX_ESCASCII,
|
|
asciiFormat,
|
|
0,
|
|
&formatString,
|
|
plContext),
|
|
PKIX_STRINGCREATEFAILED);
|
|
|
|
PKIX_TOSTRING
|
|
(crlParams->issuerNames, &crlIssuerNamesString, plContext,
|
|
PKIX_LISTTOSTRINGFAILED);
|
|
|
|
PKIX_TOSTRING(crlParams->date, &crlDateString, plContext,
|
|
PKIX_DATETOSTRINGFAILED);
|
|
|
|
PKIX_TOSTRING
|
|
(crlParams->maxCRLNumber, &crlMaxCRLNumberString, plContext,
|
|
PKIX_BIGINTTOSTRINGFAILED);
|
|
|
|
PKIX_TOSTRING
|
|
(crlParams->minCRLNumber, &crlMinCRLNumberString, plContext,
|
|
PKIX_BIGINTTOSTRINGFAILED);
|
|
|
|
PKIX_TOSTRING(crlParams->cert, &crlCertString, plContext,
|
|
PKIX_CERTTOSTRINGFAILED);
|
|
|
|
PKIX_CHECK(PKIX_PL_Sprintf
|
|
(&crlParamsString,
|
|
plContext,
|
|
formatString,
|
|
crlIssuerNamesString,
|
|
crlDateString,
|
|
crlMaxCRLNumberString,
|
|
crlMinCRLNumberString,
|
|
crlCertString),
|
|
PKIX_SPRINTFFAILED);
|
|
|
|
*pString = crlParamsString;
|
|
|
|
cleanup:
|
|
|
|
PKIX_DECREF(crlIssuerNamesString);
|
|
PKIX_DECREF(crlDateString);
|
|
PKIX_DECREF(crlMaxCRLNumberString);
|
|
PKIX_DECREF(crlMinCRLNumberString);
|
|
PKIX_DECREF(crlCertString);
|
|
PKIX_DECREF(formatString);
|
|
|
|
PKIX_RETURN(COMCRLSELPARAMS);
|
|
}
|
|
|
|
/*
|
|
* FUNCTION: pkix_ComCRLSelParams_ToString
|
|
* (see comments for PKIX_PL_ToStringCallback in pkix_pl_system.h)
|
|
*/
|
|
static PKIX_Error *
|
|
pkix_ComCRLSelParams_ToString(
|
|
PKIX_PL_Object *object,
|
|
PKIX_PL_String **pString,
|
|
void *plContext)
|
|
{
|
|
PKIX_PL_String *crlParamsString = NULL;
|
|
PKIX_ComCRLSelParams *crlParams = NULL;
|
|
|
|
PKIX_ENTER(COMCRLSELPARAMS, "pkix_ComCRLSelParams_ToString");
|
|
PKIX_NULLCHECK_TWO(object, pString);
|
|
|
|
PKIX_CHECK(pkix_CheckType(object, PKIX_COMCRLSELPARAMS_TYPE, plContext),
|
|
PKIX_OBJECTNOTCOMCRLSELPARAMS);
|
|
|
|
crlParams = (PKIX_ComCRLSelParams *) object;
|
|
|
|
PKIX_CHECK(pkix_ComCRLSelParams_ToString_Helper
|
|
(crlParams, &crlParamsString, plContext),
|
|
PKIX_COMCRLSELPARAMSTOSTRINGHELPERFAILED);
|
|
|
|
*pString = crlParamsString;
|
|
|
|
cleanup:
|
|
|
|
PKIX_RETURN(COMCRLSELPARAMS);
|
|
}
|
|
|
|
/*
|
|
* FUNCTION: pkix_ComCRLSelParams_Hashcode
|
|
* (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)
|
|
*/
|
|
static PKIX_Error *
|
|
pkix_ComCRLSelParams_Hashcode(
|
|
PKIX_PL_Object *object,
|
|
PKIX_UInt32 *pHashcode,
|
|
void *plContext)
|
|
{
|
|
PKIX_ComCRLSelParams *crlParams = NULL;
|
|
PKIX_UInt32 namesHash = 0;
|
|
PKIX_UInt32 certHash = 0;
|
|
PKIX_UInt32 dateHash = 0;
|
|
PKIX_UInt32 maxCRLNumberHash = 0;
|
|
PKIX_UInt32 minCRLNumberHash = 0;
|
|
PKIX_UInt32 hash = 0;
|
|
|
|
PKIX_ENTER(COMCRLSELPARAMS, "pkix_ComCRLSelParams_Hashcode");
|
|
PKIX_NULLCHECK_TWO(object, pHashcode);
|
|
|
|
PKIX_CHECK(pkix_CheckType(object, PKIX_COMCRLSELPARAMS_TYPE, plContext),
|
|
PKIX_OBJECTNOTCOMCRLSELPARAMS);
|
|
|
|
crlParams = (PKIX_ComCRLSelParams *)object;
|
|
|
|
PKIX_HASHCODE(crlParams->issuerNames, &namesHash, plContext,
|
|
PKIX_OBJECTHASHCODEFAILED);
|
|
|
|
PKIX_HASHCODE(crlParams->cert, &certHash, plContext,
|
|
PKIX_OBJECTHASHCODEFAILED);
|
|
|
|
PKIX_HASHCODE(crlParams->date, &dateHash, plContext,
|
|
PKIX_OBJECTHASHCODEFAILED);
|
|
|
|
PKIX_HASHCODE(crlParams->maxCRLNumber, &maxCRLNumberHash, plContext,
|
|
PKIX_OBJECTHASHCODEFAILED);
|
|
|
|
PKIX_HASHCODE(crlParams->minCRLNumber, &minCRLNumberHash, plContext,
|
|
PKIX_OBJECTHASHCODEFAILED);
|
|
|
|
|
|
hash = (((namesHash << 3) + certHash) << 3) + dateHash;
|
|
hash = (hash << 3) + maxCRLNumberHash + minCRLNumberHash;
|
|
|
|
*pHashcode = hash;
|
|
|
|
cleanup:
|
|
|
|
PKIX_RETURN(COMCRLSELPARAMS);
|
|
}
|
|
|
|
/*
|
|
* FUNCTION: pkix_ComCRLSelParams_Equals
|
|
* (see comments for PKIX_PL_Equals_Callback in pkix_pl_system.h)
|
|
*/
|
|
static PKIX_Error *
|
|
pkix_ComCRLSelParams_Equals(
|
|
PKIX_PL_Object *firstObject,
|
|
PKIX_PL_Object *secondObject,
|
|
PKIX_Boolean *pResult,
|
|
void *plContext)
|
|
{
|
|
PKIX_ComCRLSelParams *firstCrlParams = NULL;
|
|
PKIX_ComCRLSelParams *secondCrlParams = NULL;
|
|
PKIX_UInt32 secondType;
|
|
PKIX_Boolean cmpResult = PKIX_FALSE;
|
|
|
|
PKIX_ENTER(COMCRLSELPARAMS, "pkix_ComCRLSelParams_Equals");
|
|
PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult);
|
|
|
|
/* test that firstObject is a ComCRLSelParams */
|
|
PKIX_CHECK(pkix_CheckType
|
|
(firstObject, PKIX_COMCRLSELPARAMS_TYPE, plContext),
|
|
PKIX_FIRSTOBJECTNOTCOMCRLSELPARAMS);
|
|
|
|
firstCrlParams = (PKIX_ComCRLSelParams *)firstObject;
|
|
secondCrlParams = (PKIX_ComCRLSelParams *)secondObject;
|
|
|
|
/*
|
|
* Since we know firstObject is a ComCRLSelParams, if both references
|
|
* are identical, they must be equal
|
|
*/
|
|
if (firstCrlParams == secondCrlParams){
|
|
*pResult = PKIX_TRUE;
|
|
goto cleanup;
|
|
}
|
|
|
|
/*
|
|
* If secondComCRLSelParams isn't a ComCRLSelParams, we don't
|
|
* throw an error. We simply return a Boolean result of FALSE
|
|
*/
|
|
*pResult = PKIX_FALSE;
|
|
PKIX_CHECK(PKIX_PL_Object_GetType
|
|
((PKIX_PL_Object *)secondCrlParams, &secondType, plContext),
|
|
PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
|
|
|
|
if (secondType != PKIX_COMCRLSELPARAMS_TYPE) {
|
|
goto cleanup;
|
|
}
|
|
|
|
/* Compare Issuer Names */
|
|
PKIX_EQUALS
|
|
(firstCrlParams->issuerNames,
|
|
secondCrlParams->issuerNames,
|
|
&cmpResult,
|
|
plContext,
|
|
PKIX_LISTEQUALSFAILED);
|
|
|
|
if (cmpResult != PKIX_TRUE) {
|
|
goto cleanup;
|
|
}
|
|
|
|
/* Compare Date */
|
|
PKIX_EQUALS
|
|
(firstCrlParams->date,
|
|
secondCrlParams->date,
|
|
&cmpResult,
|
|
plContext,
|
|
PKIX_DATEEQUALSFAILED);
|
|
|
|
if (cmpResult != PKIX_TRUE) {
|
|
goto cleanup;
|
|
}
|
|
|
|
/* Compare Max CRL Number */
|
|
PKIX_EQUALS
|
|
(firstCrlParams->maxCRLNumber,
|
|
secondCrlParams->maxCRLNumber,
|
|
&cmpResult,
|
|
plContext,
|
|
PKIX_BIGINTEQUALSFAILED);
|
|
|
|
if (cmpResult != PKIX_TRUE) {
|
|
goto cleanup;
|
|
}
|
|
|
|
/* Compare Min CRL Number */
|
|
PKIX_EQUALS
|
|
(firstCrlParams->minCRLNumber,
|
|
secondCrlParams->minCRLNumber,
|
|
&cmpResult,
|
|
plContext,
|
|
PKIX_BIGINTEQUALSFAILED);
|
|
|
|
if (cmpResult != PKIX_TRUE) {
|
|
goto cleanup;
|
|
}
|
|
|
|
/* Compare Cert */
|
|
PKIX_EQUALS
|
|
(firstCrlParams->cert,
|
|
secondCrlParams->cert,
|
|
&cmpResult,
|
|
plContext,
|
|
PKIX_CERTEQUALSFAILED);
|
|
|
|
*pResult = cmpResult;
|
|
|
|
cleanup:
|
|
|
|
PKIX_RETURN(COMCRLSELPARAMS);
|
|
}
|
|
|
|
/*
|
|
* FUNCTION: pkix_ComCRLSelParams_Duplicate
|
|
* (see comments for PKIX_PL_Duplicate_Callback in pkix_pl_system.h)
|
|
*/
|
|
static PKIX_Error *
|
|
pkix_ComCRLSelParams_Duplicate(
|
|
PKIX_PL_Object *object,
|
|
PKIX_PL_Object **pNewObject,
|
|
void *plContext)
|
|
{
|
|
PKIX_ComCRLSelParams *old;
|
|
PKIX_ComCRLSelParams *new;
|
|
|
|
PKIX_ENTER(COMCRLSELPARAMS, "pkix_ComCRLSelParams_Duplicate");
|
|
PKIX_NULLCHECK_TWO(object, pNewObject);
|
|
|
|
PKIX_CHECK(pkix_CheckType(object, PKIX_COMCRLSELPARAMS_TYPE, plContext),
|
|
PKIX_OBJECTNOTCOMCRLSELPARAMS);
|
|
|
|
old = (PKIX_ComCRLSelParams *)object;
|
|
|
|
PKIX_CHECK(PKIX_PL_Object_Alloc
|
|
(PKIX_COMCRLSELPARAMS_TYPE,
|
|
(PKIX_UInt32)(sizeof (PKIX_ComCRLSelParams)),
|
|
(PKIX_PL_Object **)&new,
|
|
plContext),
|
|
PKIX_OBJECTALLOCFAILED);
|
|
|
|
PKIX_DUPLICATE(old->cert, &new->cert, plContext,
|
|
PKIX_OBJECTDUPLICATECERTFAILED);
|
|
|
|
PKIX_DUPLICATE(old->issuerNames, &new->issuerNames, plContext,
|
|
PKIX_OBJECTDUPLICATEISSUERNAMESFAILED);
|
|
|
|
PKIX_DUPLICATE(old->date, &new->date, plContext,
|
|
PKIX_OBJECTDUPLICATEDATEFAILED);
|
|
|
|
PKIX_DUPLICATE(old->maxCRLNumber, &new->maxCRLNumber, plContext,
|
|
PKIX_OBJECTDUPLICATEMAXCRLNUMBERFAILED);
|
|
|
|
PKIX_DUPLICATE(old->minCRLNumber, &new->minCRLNumber, plContext,
|
|
PKIX_OBJECTDUPLICATEMINCRLNUMBERFAILED);
|
|
|
|
*pNewObject = (PKIX_PL_Object *)new;
|
|
|
|
cleanup:
|
|
|
|
if (PKIX_ERROR_RECEIVED){
|
|
PKIX_DECREF(new);
|
|
}
|
|
|
|
PKIX_RETURN(COMCRLSELPARAMS);
|
|
}
|
|
|
|
/*
|
|
* FUNCTION: pkix_ComCrlSelParams_RegisterSelf
|
|
* DESCRIPTION:
|
|
* Registers PKIX_COMCRLSELPARAMS_TYPE and its related functions with
|
|
* systemClasses[]
|
|
* THREAD SAFETY:
|
|
* Not Thread Safe - for performance and complexity reasons
|
|
*
|
|
* Since this function is only called by PKIX_PL_Initialize, which should
|
|
* only be called once, it is acceptable that this function is not
|
|
* thread-safe.
|
|
*/
|
|
PKIX_Error *
|
|
pkix_ComCRLSelParams_RegisterSelf(void *plContext)
|
|
{
|
|
extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES];
|
|
pkix_ClassTable_Entry entry;
|
|
|
|
PKIX_ENTER(COMCRLSELPARAMS, "pkix_ComCRLSelParams_RegisterSelf");
|
|
|
|
entry.description = "ComCRLSelParams";
|
|
entry.objCounter = 0;
|
|
entry.typeObjectSize = sizeof(PKIX_ComCRLSelParams);
|
|
entry.destructor = pkix_ComCRLSelParams_Destroy;
|
|
entry.equalsFunction = pkix_ComCRLSelParams_Equals;
|
|
entry.hashcodeFunction = pkix_ComCRLSelParams_Hashcode;
|
|
entry.toStringFunction = pkix_ComCRLSelParams_ToString;
|
|
entry.comparator = NULL;
|
|
entry.duplicateFunction = pkix_ComCRLSelParams_Duplicate;
|
|
|
|
systemClasses[PKIX_COMCRLSELPARAMS_TYPE] = entry;
|
|
|
|
PKIX_RETURN(COMCRLSELPARAMS);
|
|
}
|
|
|
|
/* --ComCRLSelParams-Public-Functions------------------------------------- */
|
|
|
|
/*
|
|
* FUNCTION: PKIX_ComCRLSelParams_Create (see comments in pkix_crlsel.h)
|
|
*/
|
|
PKIX_Error *
|
|
PKIX_ComCRLSelParams_Create(
|
|
PKIX_ComCRLSelParams **pParams,
|
|
void *plContext)
|
|
{
|
|
PKIX_ComCRLSelParams *params = NULL;
|
|
|
|
PKIX_ENTER(COMCRLSELPARAMS, "PKIX_ComCRLSelParams_Create");
|
|
PKIX_NULLCHECK_ONE(pParams);
|
|
|
|
PKIX_CHECK(PKIX_PL_Object_Alloc
|
|
(PKIX_COMCRLSELPARAMS_TYPE,
|
|
sizeof (PKIX_ComCRLSelParams),
|
|
(PKIX_PL_Object **)¶ms,
|
|
plContext),
|
|
PKIX_COULDNOTCREATECOMMONCRLSELECTORPARAMSOBJECT);
|
|
|
|
/* initialize fields */
|
|
params->issuerNames = NULL;
|
|
params->cert = NULL;
|
|
params->date = NULL;
|
|
params->nistPolicyEnabled = PKIX_TRUE;
|
|
params->maxCRLNumber = NULL;
|
|
params->minCRLNumber = NULL;
|
|
|
|
*pParams = params;
|
|
|
|
cleanup:
|
|
|
|
PKIX_RETURN(COMCRLSELPARAMS);
|
|
}
|
|
|
|
/*
|
|
* FUNCTION: PKIX_ComCRLSelParams_GetIssuerNames (see comments in pkix_crlsel.h)
|
|
*/
|
|
PKIX_Error *
|
|
PKIX_ComCRLSelParams_GetIssuerNames(
|
|
PKIX_ComCRLSelParams *params,
|
|
PKIX_List **pIssuerNames,
|
|
void *plContext)
|
|
{
|
|
PKIX_ENTER(COMCRLSELPARAMS, "PKIX_ComCRLSelParams_GetIssuerNames");
|
|
PKIX_NULLCHECK_TWO(params, pIssuerNames);
|
|
|
|
PKIX_INCREF(params->issuerNames);
|
|
|
|
*pIssuerNames = params->issuerNames;
|
|
|
|
cleanup:
|
|
PKIX_RETURN(COMCRLSELPARAMS);
|
|
}
|
|
|
|
/*
|
|
* FUNCTION: PKIX_ComCRLSelParams_SetIssuerNames (see comments in pkix_crlsel.h)
|
|
*/
|
|
PKIX_Error *
|
|
PKIX_ComCRLSelParams_SetIssuerNames(
|
|
PKIX_ComCRLSelParams *params,
|
|
PKIX_List *names,
|
|
void *plContext)
|
|
{
|
|
PKIX_ENTER(COMCRLSELPARAMS, "PKIX_ComCRLSelParams_SetIssuerNames");
|
|
PKIX_NULLCHECK_ONE(params); /* allows null for names from spec */
|
|
|
|
PKIX_DECREF(params->issuerNames);
|
|
|
|
PKIX_INCREF(names); /* if NULL, allows to reset for no action */
|
|
|
|
params->issuerNames = names;
|
|
|
|
PKIX_CHECK(PKIX_PL_Object_InvalidateCache
|
|
((PKIX_PL_Object *)params, plContext),
|
|
PKIX_OBJECTINVALIDATECACHEFAILED);
|
|
|
|
cleanup:
|
|
|
|
PKIX_RETURN(COMCRLSELPARAMS);
|
|
}
|
|
|
|
/*
|
|
* FUNCTION: PKIX_ComCRLSelParams_AddIssuerName (see comments in pkix_crlsel.h)
|
|
*/
|
|
PKIX_Error *
|
|
PKIX_ComCRLSelParams_AddIssuerName(
|
|
PKIX_ComCRLSelParams *params,
|
|
PKIX_PL_X500Name *name,
|
|
void *plContext)
|
|
{
|
|
PKIX_List *list = NULL;
|
|
|
|
PKIX_ENTER(COMCRLSELPARAMS, "PKIX_ComCRLSelParams_AddIssuerName");
|
|
PKIX_NULLCHECK_ONE(params);
|
|
|
|
if (name != NULL) {
|
|
|
|
if (params->issuerNames == NULL) {
|
|
|
|
PKIX_CHECK(PKIX_List_Create(&list, plContext),
|
|
PKIX_LISTCREATEFAILED);
|
|
params->issuerNames = list;
|
|
}
|
|
|
|
PKIX_CHECK(PKIX_List_AppendItem
|
|
(params->issuerNames, (PKIX_PL_Object *)name, plContext),
|
|
PKIX_LISTAPPENDITEMFAILED);
|
|
|
|
PKIX_CHECK(PKIX_PL_Object_InvalidateCache
|
|
((PKIX_PL_Object *)params, plContext),
|
|
PKIX_OBJECTINVALIDATECACHEFAILED);
|
|
|
|
}
|
|
|
|
cleanup:
|
|
|
|
PKIX_RETURN(COMCRLSELPARAMS);
|
|
}
|
|
|
|
|
|
/*
|
|
* FUNCTION: PKIX_ComCRLSelParams_GetCertificateChecking
|
|
* (see comments in pkix_crlsel.h)
|
|
*/
|
|
PKIX_Error *
|
|
PKIX_ComCRLSelParams_GetCertificateChecking(
|
|
PKIX_ComCRLSelParams *params,
|
|
PKIX_PL_Cert **pCert,
|
|
void *plContext)
|
|
{
|
|
PKIX_ENTER(COMCRLSELPARAMS,
|
|
"PKIX_ComCRLSelParams_GetCertificateChecking");
|
|
PKIX_NULLCHECK_TWO(params, pCert);
|
|
|
|
PKIX_INCREF(params->cert);
|
|
|
|
*pCert = params->cert;
|
|
|
|
cleanup:
|
|
PKIX_RETURN(COMCRLSELPARAMS);
|
|
}
|
|
|
|
/*
|
|
* FUNCTION: PKIX_ComCRLSelParams_SetCertificateChecking
|
|
* (see comments in pkix_crlsel.h)
|
|
*/
|
|
PKIX_Error *
|
|
PKIX_ComCRLSelParams_SetCertificateChecking(
|
|
PKIX_ComCRLSelParams *params,
|
|
PKIX_PL_Cert *cert,
|
|
void *plContext)
|
|
{
|
|
PKIX_ENTER(COMCRLSELPARAMS,
|
|
"PKIX_ComCRLSelParams_SetCertificateChecking");
|
|
PKIX_NULLCHECK_ONE(params); /* allows cert to be NULL from spec */
|
|
|
|
PKIX_DECREF(params->cert);
|
|
|
|
PKIX_INCREF(cert);
|
|
|
|
params->cert = cert;
|
|
|
|
PKIX_CHECK(PKIX_PL_Object_InvalidateCache
|
|
((PKIX_PL_Object *)params, plContext),
|
|
PKIX_OBJECTINVALIDATECACHEFAILED);
|
|
|
|
cleanup:
|
|
|
|
PKIX_RETURN(COMCRLSELPARAMS);
|
|
}
|
|
|
|
|
|
/*
|
|
* FUNCTION: PKIX_ComCRLSelParams_GetDateAndTime (see comments in pkix_crlsel.h)
|
|
*/
|
|
PKIX_Error *
|
|
PKIX_ComCRLSelParams_GetDateAndTime(
|
|
PKIX_ComCRLSelParams *params,
|
|
PKIX_PL_Date **pDate,
|
|
void *plContext)
|
|
{
|
|
PKIX_ENTER(COMCRLSELPARAMS,
|
|
"PKIX_ComCRLSelParams_GetDateAndTime");
|
|
PKIX_NULLCHECK_TWO(params, pDate);
|
|
|
|
PKIX_INCREF(params->date);
|
|
|
|
*pDate = params->date;
|
|
|
|
cleanup:
|
|
PKIX_RETURN(COMCRLSELPARAMS);
|
|
}
|
|
|
|
/*
|
|
* FUNCTION: PKIX_ComCRLSelParams_SetDateAndTime (see comments in pkix_crlsel.h)
|
|
*/
|
|
PKIX_Error *
|
|
PKIX_ComCRLSelParams_SetDateAndTime(
|
|
PKIX_ComCRLSelParams *params,
|
|
PKIX_PL_Date *date,
|
|
void *plContext)
|
|
{
|
|
PKIX_ENTER(COMCRLSELPARAMS,
|
|
"PKIX_ComCRLSelParams_SetDateAndTime");
|
|
PKIX_NULLCHECK_ONE(params); /* allows date to be NULL from spec */
|
|
|
|
PKIX_DECREF (params->date);
|
|
|
|
PKIX_INCREF(date);
|
|
|
|
params->date = date;
|
|
|
|
PKIX_CHECK(PKIX_PL_Object_InvalidateCache
|
|
((PKIX_PL_Object *)params, plContext),
|
|
PKIX_OBJECTINVALIDATECACHEFAILED);
|
|
|
|
cleanup:
|
|
|
|
PKIX_RETURN(COMCRLSELPARAMS);
|
|
}
|
|
|
|
/*
|
|
* FUNCTION: PKIX_ComCRLSelParams_GetDateAndTime (see comments in pkix_crlsel.h)
|
|
*/
|
|
PKIX_Error *
|
|
PKIX_ComCRLSelParams_GetNISTPolicyEnabled(
|
|
PKIX_ComCRLSelParams *params,
|
|
PKIX_Boolean *pEnabled,
|
|
void *plContext)
|
|
{
|
|
PKIX_ENTER(COMCRLSELPARAMS,
|
|
"PKIX_ComCRLSelParams_GetNISTPolicyEnabled");
|
|
PKIX_NULLCHECK_TWO(params, pEnabled);
|
|
|
|
*pEnabled = params->nistPolicyEnabled;
|
|
|
|
PKIX_RETURN(COMCRLSELPARAMS);
|
|
}
|
|
|
|
/*
|
|
* FUNCTION: PKIX_ComCRLSelParams_SetDateAndTime (see comments in pkix_crlsel.h)
|
|
*/
|
|
PKIX_Error *
|
|
PKIX_ComCRLSelParams_SetNISTPolicyEnabled(
|
|
PKIX_ComCRLSelParams *params,
|
|
PKIX_Boolean enabled,
|
|
void *plContext)
|
|
{
|
|
PKIX_ENTER(COMCRLSELPARAMS,
|
|
"PKIX_ComCRLSelParams_SetNISTPolicyEnabled");
|
|
PKIX_NULLCHECK_ONE(params); /* allows date to be NULL from spec */
|
|
|
|
params->nistPolicyEnabled = enabled;
|
|
|
|
PKIX_CHECK(PKIX_PL_Object_InvalidateCache
|
|
((PKIX_PL_Object *)params, plContext),
|
|
PKIX_OBJECTINVALIDATECACHEFAILED);
|
|
|
|
cleanup:
|
|
|
|
PKIX_RETURN(COMCRLSELPARAMS);
|
|
}
|
|
|
|
/*
|
|
* FUNCTION: PKIX_ComCRLSelParams_GetMaxCRLNumber
|
|
* (see comments in pkix_crlsel.h)
|
|
*/
|
|
PKIX_Error *
|
|
PKIX_ComCRLSelParams_GetMaxCRLNumber(
|
|
PKIX_ComCRLSelParams *params,
|
|
PKIX_PL_BigInt **pMaxCRLNumber,
|
|
void *plContext)
|
|
{
|
|
PKIX_ENTER(COMCRLSELPARAMS,
|
|
"PKIX_ComCRLSelParams_GetMaxCRLNumber");
|
|
PKIX_NULLCHECK_TWO(params, pMaxCRLNumber);
|
|
|
|
PKIX_INCREF(params->maxCRLNumber);
|
|
|
|
*pMaxCRLNumber = params->maxCRLNumber;
|
|
|
|
cleanup:
|
|
PKIX_RETURN(COMCRLSELPARAMS);
|
|
}
|
|
|
|
/*
|
|
* FUNCTION: PKIX_ComCRLSelParams_SetMaxCRLNumber
|
|
* (see comments in pkix_crlsel.h)
|
|
*/
|
|
PKIX_Error *
|
|
PKIX_ComCRLSelParams_SetMaxCRLNumber(
|
|
PKIX_ComCRLSelParams *params,
|
|
PKIX_PL_BigInt *maxCRLNumber,
|
|
void *plContext)
|
|
{
|
|
PKIX_ENTER(COMCRLSELPARAMS,
|
|
"PKIX_ComCRLSelParams_SetMaxCRLNumber");
|
|
PKIX_NULLCHECK_ONE(params); /* maxCRLNumber can be NULL - from spec */
|
|
|
|
PKIX_DECREF(params->maxCRLNumber);
|
|
|
|
PKIX_INCREF(maxCRLNumber);
|
|
|
|
params->maxCRLNumber = maxCRLNumber;
|
|
|
|
PKIX_CHECK(PKIX_PL_Object_InvalidateCache
|
|
((PKIX_PL_Object *)params, plContext),
|
|
PKIX_OBJECTINVALIDATECACHEFAILED);
|
|
|
|
cleanup:
|
|
|
|
PKIX_RETURN(COMCRLSELPARAMS);
|
|
}
|
|
|
|
|
|
/*
|
|
* FUNCTION: PKIX_ComCRLSelParams_GetMinCRLNumber
|
|
* (see comments in pkix_crlsel.h)
|
|
*/
|
|
PKIX_Error *
|
|
PKIX_ComCRLSelParams_GetMinCRLNumber(
|
|
PKIX_ComCRLSelParams *params,
|
|
PKIX_PL_BigInt **pMinCRLNumber,
|
|
void *plContext)
|
|
{
|
|
PKIX_ENTER(COMCRLSELPARAMS,
|
|
"PKIX_ComCRLSelParams_GetMinCRLNumber");
|
|
PKIX_NULLCHECK_TWO(params, pMinCRLNumber);
|
|
|
|
PKIX_INCREF(params->minCRLNumber);
|
|
|
|
*pMinCRLNumber = params->minCRLNumber;
|
|
|
|
cleanup:
|
|
PKIX_RETURN(COMCRLSELPARAMS);
|
|
}
|
|
|
|
/*
|
|
* FUNCTION: PKIX_ComCRLSelParams_SetMinCRLNumber
|
|
* (see comments in pkix_crlsel.h)
|
|
*/
|
|
PKIX_Error *
|
|
PKIX_ComCRLSelParams_SetMinCRLNumber(
|
|
PKIX_ComCRLSelParams *params,
|
|
PKIX_PL_BigInt *minCRLNumber,
|
|
void *plContext)
|
|
{
|
|
PKIX_ENTER(COMCRLSELPARAMS,
|
|
"PKIX_ComCRLSelParams_SetMinCRLNumber");
|
|
PKIX_NULLCHECK_ONE(params); /* minCRLNumber can be NULL - from spec */
|
|
|
|
PKIX_DECREF(params->minCRLNumber);
|
|
|
|
PKIX_INCREF(minCRLNumber);
|
|
|
|
params->minCRLNumber = minCRLNumber;
|
|
|
|
PKIX_CHECK(PKIX_PL_Object_InvalidateCache
|
|
((PKIX_PL_Object *)params, plContext),
|
|
PKIX_OBJECTINVALIDATECACHEFAILED);
|
|
|
|
cleanup:
|
|
|
|
PKIX_RETURN(COMCRLSELPARAMS);
|
|
}
|