wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-10-01 04:47:31 +09:00
Code Issues Projects Releases Packages Wiki Activity

import FIREFOX_52_6_0esr_RELEASE from mozilla-esr52 hg repo

Browse source
This commit is contained in:
Roy Tam 2018-01-19 03:59:58 +08:00
commit dcd9973243
150858 changed files with 23884658 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

48
security/nss/lib/libpkix/pkix/params/Makefile Normal file
View file

@ -0,0 +1,48 @@
#! gmake
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
#######################################################################
# (1) Include initial platform-independent assignments (MANDATORY). #
#######################################################################
include manifest.mn
#######################################################################
# (2) Include "global" configuration information. (OPTIONAL) #
#######################################################################
include $(CORE_DEPTH)/coreconf/config.mk
#######################################################################
# (3) Include "component" configuration information. (OPTIONAL) #
#######################################################################
#######################################################################
# (4) Include "local" platform-dependent assignments (OPTIONAL). #
#######################################################################
include config.mk
#######################################################################
# (5) Execute "global" rules. (OPTIONAL) #
#######################################################################
include $(CORE_DEPTH)/coreconf/rules.mk
#######################################################################
# (6) Execute "component" rules. (OPTIONAL) #
#######################################################################
#######################################################################
# (7) Execute "local" rules. (OPTIONAL). #
#######################################################################
export:: private_export

15
security/nss/lib/libpkix/pkix/params/config.mk Normal file
View file

@ -0,0 +1,15 @@
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
#
# Override TARGETS variable so that only static libraries
# are specifed as dependencies within rules.mk.
#
TARGETS = $(LIBRARY)
SHARED_LIBRARY =
IMPORT_LIBRARY =
PROGRAM =

28
security/nss/lib/libpkix/pkix/params/exports.gyp Normal file
View file

@ -0,0 +1,28 @@
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
{
'includes': [
'../../../../coreconf/config.gypi'
],
'targets': [
{
'target_name': 'lib_libpkix_pkix_params_exports',
'type': 'none',
'copies': [
{
'files': [
'pkix_procparams.h',
'pkix_resourcelimits.h',
'pkix_trustanchor.h',
'pkix_valparams.h'
],
'destination': '<(nss_private_dist_dir)/<(module)'
}
]
}
],
'variables': {
'module': 'nss'
}
}

27
security/nss/lib/libpkix/pkix/params/manifest.mn Normal file
View file

@ -0,0 +1,27 @@
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
CORE_DEPTH = ../../../..
EXPORTS = \
$(NULL)
PRIVATE_EXPORTS = \
pkix_procparams.h \
pkix_trustanchor.h \
pkix_valparams.h \
pkix_resourcelimits.h \
$(NULL)
MODULE = nss
CSRCS = \
pkix_trustanchor.c \
pkix_procparams.c \
pkix_valparams.c \
pkix_resourcelimits.c \
$(NULL)
LIBRARY_NAME = pkixparams

26
security/nss/lib/libpkix/pkix/params/params.gyp Normal file
View file

@ -0,0 +1,26 @@
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
{
'includes': [
'../../../../coreconf/config.gypi'
],
'targets': [
{
'target_name': 'pkixparams',
'type': 'static_library',
'sources': [
'pkix_procparams.c',
'pkix_resourcelimits.c',
'pkix_trustanchor.c',
'pkix_valparams.c'
],
'dependencies': [
'<(DEPTH)/exports.gyp:nss_exports'
]
}
],
'variables': {
'module': 'nss'
}
}

1417
security/nss/lib/libpkix/pkix/params/pkix_procparams.c Normal file
View file

File diff suppressed because it is too large Load diff

50
security/nss/lib/libpkix/pkix/params/pkix_procparams.h Normal file
View file

@ -0,0 +1,50 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/*
* pkix_procparams.h
*
* ProcessingParams Object Type Definition
*
*/
#ifndef _PKIX_PROCESSINGPARAMS_H
#define _PKIX_PROCESSINGPARAMS_H
#include "pkix_tools.h"
#ifdef __cplusplus
extern "C" {
#endif
struct PKIX_ProcessingParamsStruct {
PKIX_List *trustAnchors; /* Never NULL */
PKIX_List *hintCerts; /* user-supplied partial chain, may be NULL */
PKIX_CertSelector *constraints;
PKIX_PL_Date *date;
PKIX_List *initialPolicies; /* list of PKIX_PL_OID */
PKIX_Boolean initialPolicyMappingInhibit;
PKIX_Boolean initialAnyPolicyInhibit;
PKIX_Boolean initialExplicitPolicy;
PKIX_Boolean qualifiersRejected;
PKIX_List *certChainCheckers;
PKIX_List *certStores;
PKIX_Boolean isCrlRevocationCheckingEnabled;
PKIX_Boolean isCrlRevocationCheckingEnabledWithNISTPolicy;
PKIX_RevocationChecker *revChecker;
PKIX_ResourceLimits *resourceLimits;
PKIX_Boolean useAIAForCertFetching;
PKIX_Boolean qualifyTargetCert;
PKIX_Boolean useOnlyTrustAnchors;
};
/* see source file for function documentation */
PKIX_Error *pkix_ProcessingParams_RegisterSelf(void *plContext);
#ifdef __cplusplus
}
#endif
#endif /* _PKIX_PROCESSINGPARAMS_H */

433
security/nss/lib/libpkix/pkix/params/pkix_resourcelimits.c Normal file
View file

@ -0,0 +1,433 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/*
* pkix_resourcelimits.c
*
* Resourcelimits Params Object Functions
*
*/
#include "pkix_resourcelimits.h"
/* --Private-Functions-------------------------------------------- */
/*
* FUNCTION: pkix_ResourceLimits_Destroy
* (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_ResourceLimits_Destroy(
PKIX_PL_Object *object,
void *plContext)
{
PKIX_ResourceLimits *rLimits = NULL;
PKIX_ENTER(RESOURCELIMITS, "pkix_ResourceLimits_Destroy");
PKIX_NULLCHECK_ONE(object);
/* Check that this object is a ResourceLimits object */
PKIX_CHECK(pkix_CheckType(object, PKIX_RESOURCELIMITS_TYPE, plContext),
PKIX_OBJECTNOTRESOURCELIMITS);
rLimits = (PKIX_ResourceLimits *)object;
rLimits->maxTime = 0;
rLimits->maxFanout = 0;
rLimits->maxDepth = 0;
rLimits->maxCertsNumber = 0;
rLimits->maxCrlsNumber = 0;
cleanup:
PKIX_RETURN(RESOURCELIMITS);
}
/*
* FUNCTION: pkix_ResourceLimits_Equals
* (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_ResourceLimits_Equals(
PKIX_PL_Object *first,
PKIX_PL_Object *second,
PKIX_Boolean *pResult,
void *plContext)
{
PKIX_UInt32 secondType;
PKIX_Boolean cmpResult;
PKIX_ResourceLimits *firstRLimits = NULL;
PKIX_ResourceLimits *secondRLimits = NULL;
PKIX_ENTER(RESOURCELIMITS, "pkix_ResourceLimits_Equals");
PKIX_NULLCHECK_THREE(first, second, pResult);
PKIX_CHECK(pkix_CheckType(first, PKIX_RESOURCELIMITS_TYPE, plContext),
PKIX_FIRSTOBJECTNOTRESOURCELIMITS);
PKIX_CHECK(PKIX_PL_Object_GetType(second, &secondType, plContext),
PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
*pResult = PKIX_FALSE;
if (secondType != PKIX_RESOURCELIMITS_TYPE) goto cleanup;
firstRLimits = (PKIX_ResourceLimits *)first;
secondRLimits = (PKIX_ResourceLimits *)second;
cmpResult = (firstRLimits->maxTime == secondRLimits->maxTime) &&
(firstRLimits->maxFanout == secondRLimits->maxFanout) &&
(firstRLimits->maxDepth == secondRLimits->maxDepth) &&
(firstRLimits->maxCertsNumber ==
secondRLimits->maxCertsNumber) &&
(firstRLimits->maxCrlsNumber ==
secondRLimits->maxCrlsNumber);
*pResult = cmpResult;
cleanup:
PKIX_RETURN(RESOURCELIMITS);
}
/*
* FUNCTION: pkix_ResourceLimits_Hashcode
* (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_ResourceLimits_Hashcode(
PKIX_PL_Object *object,
PKIX_UInt32 *pHashcode,
void *plContext)
{
PKIX_ResourceLimits *rLimits = NULL;
PKIX_UInt32 hash = 0;
PKIX_ENTER(RESOURCELIMITS, "pkix_ResourceLimits_Hashcode");
PKIX_NULLCHECK_TWO(object, pHashcode);
PKIX_CHECK(pkix_CheckType(object, PKIX_RESOURCELIMITS_TYPE, plContext),
PKIX_OBJECTNOTRESOURCELIMITS);
rLimits = (PKIX_ResourceLimits*)object;
hash = 31 * rLimits->maxTime + (rLimits->maxFanout << 1) +
(rLimits->maxDepth << 2) + (rLimits->maxCertsNumber << 3) +
rLimits->maxCrlsNumber;
*pHashcode = hash;
cleanup:
PKIX_RETURN(RESOURCELIMITS);
}
/*
* FUNCTION: pkix_ResourceLimits_ToString
* (see comments for PKIX_PL_ToStringCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_ResourceLimits_ToString(
PKIX_PL_Object *object,
PKIX_PL_String **pString,
void *plContext)
{
PKIX_ResourceLimits *rLimits = NULL;
char *asciiFormat = NULL;
PKIX_PL_String *formatString = NULL;
PKIX_PL_String *rLimitsString = NULL;
PKIX_ENTER(RESOURCELIMITS, "pkix_ResourceLimits_ToString");
PKIX_NULLCHECK_TWO(object, pString);
PKIX_CHECK(pkix_CheckType(object, PKIX_RESOURCELIMITS_TYPE, plContext),
PKIX_OBJECTNOTRESOURCELIMITS);
/* maxCertsNumber and maxCrlsNumber are not supported */
asciiFormat =
"[\n"
"\tMaxTime: \t\t%d\n"
"\tMaxFanout: \t\t%d\n"
"\tMaxDepth: \t\t%d\n"
"]\n";
PKIX_CHECK(PKIX_PL_String_Create
(PKIX_ESCASCII,
asciiFormat,
0,
&formatString,
plContext),
PKIX_STRINGCREATEFAILED);
rLimits = (PKIX_ResourceLimits*)object;
PKIX_CHECK(PKIX_PL_Sprintf
(&rLimitsString,
plContext,
formatString,
rLimits->maxTime,
rLimits->maxFanout,
rLimits->maxDepth),
PKIX_SPRINTFFAILED);
*pString = rLimitsString;
cleanup:
PKIX_DECREF(formatString);
PKIX_RETURN(RESOURCELIMITS);
}
/*
* FUNCTION: pkix_ResourceLimits_RegisterSelf
* DESCRIPTION:
* Registers PKIX_RESOURCELIMITS_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_ResourceLimits_RegisterSelf(void *plContext)
{
extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES];
pkix_ClassTable_Entry entry;
PKIX_ENTER(RESOURCELIMITS, "pkix_ResourceLimits_RegisterSelf");
entry.description = "ResourceLimits";
entry.objCounter = 0;
entry.typeObjectSize = sizeof(PKIX_ResourceLimits);
entry.destructor = pkix_ResourceLimits_Destroy;
entry.equalsFunction = pkix_ResourceLimits_Equals;
entry.hashcodeFunction = pkix_ResourceLimits_Hashcode;
entry.toStringFunction = pkix_ResourceLimits_ToString;
entry.comparator = NULL;
entry.duplicateFunction = NULL;
systemClasses[PKIX_RESOURCELIMITS_TYPE] = entry;
PKIX_RETURN(RESOURCELIMITS);
}
/* --Public-Functions--------------------------------------------- */
/*
* FUNCTION: PKIX_ResourceLimits_Create (see comments in pkix_params.h)
*/
PKIX_Error *
PKIX_ResourceLimits_Create(
PKIX_ResourceLimits **pResourceLimits,
void *plContext)
{
PKIX_ResourceLimits *rLimits = NULL;
PKIX_ENTER(RESOURCELIMITS, "PKIX_ResourceLimits_Create");
PKIX_NULLCHECK_ONE(pResourceLimits);
PKIX_CHECK(PKIX_PL_Object_Alloc
(PKIX_RESOURCELIMITS_TYPE,
sizeof (PKIX_ResourceLimits),
(PKIX_PL_Object **)&rLimits,
plContext),
PKIX_COULDNOTCREATERESOURCELIMITOBJECT);
/* initialize fields */
rLimits->maxTime = 0;
rLimits->maxFanout = 0;
rLimits->maxDepth = 0;
rLimits->maxCertsNumber = 0;
rLimits->maxCrlsNumber = 0;
*pResourceLimits = rLimits;
cleanup:
PKIX_RETURN(RESOURCELIMITS);
}
/*
* FUNCTION: PKIX_ResourceLimits_GetMaxTime
* (see comments in pkix_params.h)
*/
PKIX_Error *
PKIX_ResourceLimits_GetMaxTime(
PKIX_ResourceLimits *rLimits,
PKIX_UInt32 *pMaxTime,
void *plContext)
{
PKIX_ENTER(RESOURCELIMITS, "PKIX_ResourceLimits_GetMaxTime");
PKIX_NULLCHECK_TWO(rLimits, pMaxTime);
*pMaxTime = rLimits->maxTime;
PKIX_RETURN(RESOURCELIMITS);
}
/*
* FUNCTION: PKIX_ResourceLimits_SetMaxTime
* (see comments in pkix_params.h)
*/
PKIX_Error *
PKIX_ResourceLimits_SetMaxTime(
PKIX_ResourceLimits *rLimits,
PKIX_UInt32 maxTime,
void *plContext)
{
PKIX_ENTER(RESOURCELIMITS, "PKIX_ResourceLimits_SetMaxTime");
PKIX_NULLCHECK_ONE(rLimits);
rLimits->maxTime = maxTime;
PKIX_RETURN(RESOURCELIMITS);
}
/*
* FUNCTION: PKIX_ResourceLimits_GetMaxFanout
* (see comments in pkix_params.h)
*/
PKIX_Error *
PKIX_ResourceLimits_GetMaxFanout(
PKIX_ResourceLimits *rLimits,
PKIX_UInt32 *pMaxFanout,
void *plContext)
{
PKIX_ENTER(RESOURCELIMITS, "PKIX_ResourceLimits_GetMaxFanout");
PKIX_NULLCHECK_TWO(rLimits, pMaxFanout);
*pMaxFanout = rLimits->maxFanout;
PKIX_RETURN(RESOURCELIMITS);
}
/*
* FUNCTION: PKIX_ResourceLimits_SetMaxFanout
* (see comments in pkix_params.h)
*/
PKIX_Error *
PKIX_ResourceLimits_SetMaxFanout(
PKIX_ResourceLimits *rLimits,
PKIX_UInt32 maxFanout,
void *plContext)
{
PKIX_ENTER(RESOURCELIMITS, "PKIX_ResourceLimits_SetMaxFanout");
PKIX_NULLCHECK_ONE(rLimits);
rLimits->maxFanout = maxFanout;
PKIX_RETURN(RESOURCELIMITS);
}
/*
* FUNCTION: PKIX_ResourceLimits_GetMaxDepth
* (see comments in pkix_params.h)
*/
PKIX_Error *
PKIX_ResourceLimits_GetMaxDepth(
PKIX_ResourceLimits *rLimits,
PKIX_UInt32 *pMaxDepth,
void *plContext)
{
PKIX_ENTER(RESOURCELIMITS, "PKIX_ResourceLimits_GetMaxDepth");
PKIX_NULLCHECK_TWO(rLimits, pMaxDepth);
*pMaxDepth = rLimits->maxDepth;
PKIX_RETURN(RESOURCELIMITS);
}
/*
* FUNCTION: PKIX_ResourceLimits_SetMaxDepth
* (see comments in pkix_params.h)
*/
PKIX_Error *
PKIX_ResourceLimits_SetMaxDepth(
PKIX_ResourceLimits *rLimits,
PKIX_UInt32 maxDepth,
void *plContext)
{
PKIX_ENTER(RESOURCELIMITS, "PKIX_ResourceLimits_SetMaxDepth");
PKIX_NULLCHECK_ONE(rLimits);
rLimits->maxDepth = maxDepth;
PKIX_RETURN(RESOURCELIMITS);
}
/*
* FUNCTION: PKIX_ResourceLimits_GetMaxNumberOfCerts
* (see comments in pkix_params.h)
*/
PKIX_Error *
PKIX_ResourceLimits_GetMaxNumberOfCerts(
PKIX_ResourceLimits *rLimits,
PKIX_UInt32 *pMaxNumber,
void *plContext)
{
PKIX_ENTER(RESOURCELIMITS, "PKIX_ResourceLimits_GetMaxNumberOfCerts");
PKIX_NULLCHECK_TWO(rLimits, pMaxNumber);
*pMaxNumber = rLimits->maxCertsNumber;
PKIX_RETURN(RESOURCELIMITS);
}
/*
* FUNCTION: PKIX_ResourceLimits_SetMaxNumberOfCerts
* (see comments in pkix_params.h)
*/
PKIX_Error *
PKIX_ResourceLimits_SetMaxNumberOfCerts(
PKIX_ResourceLimits *rLimits,
PKIX_UInt32 maxNumber,
void *plContext)
{
PKIX_ENTER(RESOURCELIMITS, "PKIX_ResourceLimits_SetMaxNumberOfCerts");
PKIX_NULLCHECK_ONE(rLimits);
rLimits->maxCertsNumber = maxNumber;
PKIX_RETURN(RESOURCELIMITS);
}
/*
* FUNCTION: PKIX_ResourceLimits_GetMaxNumberOfCRLs
* (see comments in pkix_params.h)
*/
PKIX_Error *
PKIX_ResourceLimits_GetMaxNumberOfCRLs(
PKIX_ResourceLimits *rLimits,
PKIX_UInt32 *pMaxNumber,
void *plContext)
{
PKIX_ENTER(RESOURCELIMITS, "PKIX_ResourceLimits_GetMaxNumberOfCRLs");
PKIX_NULLCHECK_TWO(rLimits, pMaxNumber);
*pMaxNumber = rLimits->maxCrlsNumber;
PKIX_RETURN(RESOURCELIMITS);
}
/*
* FUNCTION: PKIX_ResourceLimits_SetMaxNumberOfCRLs
* (see comments in pkix_params.h)
*/
PKIX_Error *
PKIX_ResourceLimits_SetMaxNumberOfCRLs(
PKIX_ResourceLimits *rLimits,
PKIX_UInt32 maxNumber,
void *plContext)
{
PKIX_ENTER(RESOURCELIMITS, "PKIX_ResourceLimits_SetMaxNumberOfCRLs");
PKIX_NULLCHECK_ONE(rLimits);
rLimits->maxCrlsNumber = maxNumber;
PKIX_RETURN(RESOURCELIMITS);
}

36
security/nss/lib/libpkix/pkix/params/pkix_resourcelimits.h Normal file
View file

@ -0,0 +1,36 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/*
* pkix_resourcelimits.h
*
* ResourceLimits Object Type Definition
*
*/
#ifndef _PKIX_RESOURCELIMITS_H
#define _PKIX_RESOURCELIMITS_H
#include "pkix_tools.h"
#ifdef __cplusplus
extern "C" {
#endif
struct PKIX_ResourceLimitsStruct {
PKIX_UInt32 maxTime;
PKIX_UInt32 maxFanout;
PKIX_UInt32 maxDepth;
PKIX_UInt32 maxCertsNumber;
PKIX_UInt32 maxCrlsNumber;
};
/* see source file for function documentation */
PKIX_Error *pkix_ResourceLimits_RegisterSelf(void *plContext);
#ifdef __cplusplus
}
#endif
#endif /* _PKIX_RESOURCELIMITS_H */

525
security/nss/lib/libpkix/pkix/params/pkix_trustanchor.c Normal file
View file

@ -0,0 +1,525 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/*
* pkix_trustanchor.c
*
* TrustAnchor Object Functions
*
*/
#include "pkix_trustanchor.h"
/* --Private-Functions-------------------------------------------- */
/*
* FUNCTION: pkix_TrustAnchor_Destroy
* (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_TrustAnchor_Destroy(
PKIX_PL_Object *object,
void *plContext)
{
PKIX_TrustAnchor *anchor = NULL;
PKIX_ENTER(TRUSTANCHOR, "pkix_TrustAnchor_Destroy");
PKIX_NULLCHECK_ONE(object);
/* Check that this object is a trust anchor */
PKIX_CHECK(pkix_CheckType(object, PKIX_TRUSTANCHOR_TYPE, plContext),
PKIX_OBJECTNOTTRUSTANCHOR);
anchor = (PKIX_TrustAnchor *)object;
PKIX_DECREF(anchor->trustedCert);
PKIX_DECREF(anchor->caName);
PKIX_DECREF(anchor->caPubKey);
PKIX_DECREF(anchor->nameConstraints);
cleanup:
PKIX_RETURN(TRUSTANCHOR);
}
/*
* FUNCTION: pkix_TrustAnchor_Equals
* (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_TrustAnchor_Equals(
PKIX_PL_Object *first,
PKIX_PL_Object *second,
PKIX_Boolean *pResult,
void *plContext)
{
PKIX_UInt32 secondType;
PKIX_Boolean cmpResult;
PKIX_TrustAnchor *firstAnchor = NULL;
PKIX_TrustAnchor *secondAnchor = NULL;
PKIX_PL_Cert *firstCert = NULL;
PKIX_PL_Cert *secondCert = NULL;
PKIX_ENTER(TRUSTANCHOR, "pkix_TrustAnchor_Equals");
PKIX_NULLCHECK_THREE(first, second, pResult);
PKIX_CHECK(pkix_CheckType(first, PKIX_TRUSTANCHOR_TYPE, plContext),
PKIX_FIRSTOBJECTNOTTRUSTANCHOR);
PKIX_CHECK(PKIX_PL_Object_GetType(second, &secondType, plContext),
PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
*pResult = PKIX_FALSE;
if (secondType != PKIX_TRUSTANCHOR_TYPE) goto cleanup;
firstAnchor = (PKIX_TrustAnchor *)first;
secondAnchor = (PKIX_TrustAnchor *)second;
firstCert = firstAnchor->trustedCert;
secondCert = secondAnchor->trustedCert;
if ((firstCert && !secondCert) || (!firstCert && secondCert)){
goto cleanup;
}
if (firstCert && secondCert){
PKIX_CHECK(PKIX_PL_Object_Equals
((PKIX_PL_Object *)firstCert,
(PKIX_PL_Object *)secondCert,
&cmpResult,
plContext),
PKIX_OBJECTEQUALSFAILED);
} else {
PKIX_CHECK(PKIX_PL_Object_Equals
((PKIX_PL_Object *)firstAnchor->caName,
(PKIX_PL_Object *)secondAnchor->caName,
&cmpResult,
plContext),
PKIX_OBJECTEQUALSFAILED);
if (!cmpResult) goto cleanup;
PKIX_CHECK(PKIX_PL_Object_Equals
((PKIX_PL_Object *)firstAnchor->caPubKey,
(PKIX_PL_Object *)secondAnchor->caPubKey,
&cmpResult,
plContext),
PKIX_OBJECTEQUALSFAILED);
if (!cmpResult) goto cleanup;
PKIX_EQUALS
(firstAnchor->nameConstraints,
secondAnchor->nameConstraints,
&cmpResult,
plContext,
PKIX_OBJECTEQUALSFAILED);
if (!cmpResult) goto cleanup;
}
*pResult = cmpResult;
cleanup:
PKIX_RETURN(TRUSTANCHOR);
}
/*
* FUNCTION: pkix_TrustAnchor_Hashcode
* (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_TrustAnchor_Hashcode(
PKIX_PL_Object *object,
PKIX_UInt32 *pHashcode,
void *plContext)
{
PKIX_TrustAnchor *anchor = NULL;
PKIX_PL_Cert *cert = NULL;
PKIX_UInt32 hash = 0;
PKIX_UInt32 certHash = 0;
PKIX_UInt32 nameHash = 0;
PKIX_UInt32 pubKeyHash = 0;
PKIX_UInt32 ncHash = 0;
PKIX_ENTER(TRUSTANCHOR, "pkix_TrustAnchor_Hashcode");
PKIX_NULLCHECK_TWO(object, pHashcode);
PKIX_CHECK(pkix_CheckType(object, PKIX_TRUSTANCHOR_TYPE, plContext),
PKIX_OBJECTNOTTRUSTANCHOR);
anchor = (PKIX_TrustAnchor*)object;
cert = anchor->trustedCert;
if (cert){
PKIX_CHECK(PKIX_PL_Object_Hashcode
((PKIX_PL_Object *)cert,
&certHash,
plContext),
PKIX_OBJECTHASHCODEFAILED);
hash = certHash;
} else {
PKIX_CHECK(PKIX_PL_Object_Hashcode
((PKIX_PL_Object *)anchor->caName,
&nameHash,
plContext),
PKIX_OBJECTHASHCODEFAILED);
PKIX_CHECK(PKIX_PL_Object_Hashcode
((PKIX_PL_Object *)anchor->caPubKey,
&pubKeyHash,
plContext),
PKIX_OBJECTHASHCODEFAILED);
PKIX_HASHCODE(anchor->nameConstraints, &ncHash, plContext,
PKIX_OBJECTHASHCODEFAILED);
hash = 31 * nameHash + pubKeyHash + ncHash;
}
*pHashcode = hash;
cleanup:
PKIX_RETURN(TRUSTANCHOR);
}
/*
* FUNCTION: pkix_TrustAnchor_ToString
* (see comments for PKIX_PL_ToStringCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_TrustAnchor_ToString(
PKIX_PL_Object *object,
PKIX_PL_String **pString,
void *plContext)
{
PKIX_TrustAnchor *anchor = NULL;
char *asciiFormat = NULL;
PKIX_PL_String *formatString = NULL;
PKIX_PL_String *anchorString = NULL;
PKIX_PL_String *certString = NULL;
PKIX_PL_String *nameString = NULL;
PKIX_PL_String *pubKeyString = NULL;
PKIX_PL_String *nameConstraintsString = NULL;
PKIX_ENTER(TRUSTANCHOR, "pkix_TrustAnchor_ToString");
PKIX_NULLCHECK_TWO(object, pString);
PKIX_CHECK(pkix_CheckType(object, PKIX_TRUSTANCHOR_TYPE, plContext),
PKIX_OBJECTNOTTRUSTANCHOR);
anchor = (PKIX_TrustAnchor*)object;
if (anchor->trustedCert){
asciiFormat =
"[\n"
"\tTrusted Cert: %s\n"
"]\n";
PKIX_CHECK(PKIX_PL_String_Create
(PKIX_ESCASCII,
asciiFormat,
0,
&formatString,
plContext),
PKIX_STRINGCREATEFAILED);
PKIX_CHECK(PKIX_PL_Object_ToString
((PKIX_PL_Object *)anchor->trustedCert,
&certString,
plContext),
PKIX_OBJECTTOSTRINGFAILED);
PKIX_CHECK(PKIX_PL_Sprintf
(&anchorString,
plContext,
formatString,
certString),
PKIX_SPRINTFFAILED);
} else {
asciiFormat =
"[\n"
"\tTrusted CA Name: %s\n"
"\tTrusted CA PublicKey: %s\n"
"\tInitial Name Constraints:%s\n"
"]\n";
PKIX_CHECK(PKIX_PL_String_Create
(PKIX_ESCASCII,
asciiFormat,
0,
&formatString,
plContext),
PKIX_STRINGCREATEFAILED);
PKIX_CHECK(PKIX_PL_Object_ToString
((PKIX_PL_Object *)anchor->caName,
&nameString,
plContext),
PKIX_OBJECTTOSTRINGFAILED);
PKIX_CHECK(PKIX_PL_Object_ToString
((PKIX_PL_Object *)anchor->caPubKey,
&pubKeyString,
plContext),
PKIX_OBJECTTOSTRINGFAILED);
PKIX_TOSTRING
(anchor->nameConstraints,
&nameConstraintsString,
plContext,
PKIX_OBJECTTOSTRINGFAILED);
PKIX_CHECK(PKIX_PL_Sprintf
(&anchorString,
plContext,
formatString,
nameString,
pubKeyString,
nameConstraintsString),
PKIX_SPRINTFFAILED);
}
*pString = anchorString;
cleanup:
PKIX_DECREF(formatString);
PKIX_DECREF(certString);
PKIX_DECREF(nameString);
PKIX_DECREF(pubKeyString);
PKIX_DECREF(nameConstraintsString);
PKIX_RETURN(TRUSTANCHOR);
}
/*
* FUNCTION: pkix_TrustAnchor_RegisterSelf
* DESCRIPTION:
* Registers PKIX_TRUSTANCHOR_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_TrustAnchor_RegisterSelf(void *plContext)
{
extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES];
pkix_ClassTable_Entry entry;
PKIX_ENTER(TRUSTANCHOR, "pkix_TrustAnchor_RegisterSelf");
entry.description = "TrustAnchor";
entry.objCounter = 0;
entry.typeObjectSize = sizeof(PKIX_TrustAnchor);
entry.destructor = pkix_TrustAnchor_Destroy;
entry.equalsFunction = pkix_TrustAnchor_Equals;
entry.hashcodeFunction = pkix_TrustAnchor_Hashcode;
entry.toStringFunction = pkix_TrustAnchor_ToString;
entry.comparator = NULL;
entry.duplicateFunction = pkix_duplicateImmutable;
systemClasses[PKIX_TRUSTANCHOR_TYPE] = entry;
PKIX_RETURN(TRUSTANCHOR);
}
/* --Public-Functions--------------------------------------------- */
/*
* FUNCTION: PKIX_TrustAnchor_CreateWithCert (see comments in pkix_params.h)
*/
PKIX_Error *
PKIX_TrustAnchor_CreateWithCert(
PKIX_PL_Cert *cert,
PKIX_TrustAnchor **pAnchor,
void *plContext)
{
PKIX_TrustAnchor *anchor = NULL;
PKIX_ENTER(TRUSTANCHOR, "PKIX_TrustAnchor_CreateWithCert");
PKIX_NULLCHECK_TWO(cert, pAnchor);
PKIX_CHECK(PKIX_PL_Object_Alloc
(PKIX_TRUSTANCHOR_TYPE,
sizeof (PKIX_TrustAnchor),
(PKIX_PL_Object **)&anchor,
plContext),
PKIX_COULDNOTCREATETRUSTANCHOROBJECT);
/* initialize fields */
PKIX_CHECK(
PKIX_PL_Cert_SetAsTrustAnchor(cert, plContext),
PKIX_CERTSETASTRUSTANCHORFAILED);
PKIX_INCREF(cert);
anchor->trustedCert = cert;
anchor->caName = NULL;
anchor->caPubKey = NULL;
PKIX_CHECK(PKIX_PL_Cert_GetNameConstraints
(anchor->trustedCert, &anchor->nameConstraints, plContext),
PKIX_CERTGETNAMECONSTRAINTSFAILED);
*pAnchor = anchor;
anchor = NULL;
cleanup:
PKIX_DECREF(anchor);
PKIX_RETURN(TRUSTANCHOR);
}
/*
* FUNCTION: PKIX_TrustAnchor_CreateWithNameKeyPair
* (see comments in pkix_params.h)
*/
PKIX_Error *
PKIX_TrustAnchor_CreateWithNameKeyPair(
PKIX_PL_X500Name *name,
PKIX_PL_PublicKey *pubKey,
PKIX_PL_CertNameConstraints *nameConstraints,
PKIX_TrustAnchor **pAnchor,
void *plContext)
{
PKIX_TrustAnchor *anchor = NULL;
PKIX_ENTER(TRUSTANCHOR, "PKIX_TrustAnchor_CreateWithNameKeyPair");
#ifndef BUILD_LIBPKIX_TESTS
/* Nss creates trust anchors by using PKIX_TrustAnchor_CreateWithCert
* function as the complete trusted cert structure, and not only cert
* public key, is required for chain building and validation processes.
* Restricting this function for been used only in libpkix unit
* tests. */
PKIX_ERROR(PKIX_FUNCTIONMUSTNOTBEUSED);
#endif
PKIX_NULLCHECK_THREE(name, pubKey, pAnchor);
PKIX_CHECK(PKIX_PL_Object_Alloc
(PKIX_TRUSTANCHOR_TYPE,
sizeof (PKIX_TrustAnchor),
(PKIX_PL_Object **)&anchor,
plContext),
PKIX_COULDNOTCREATETRUSTANCHOROBJECT);
/* initialize fields */
anchor->trustedCert = NULL;
PKIX_INCREF(name);
anchor->caName = name;
PKIX_INCREF(pubKey);
anchor->caPubKey = pubKey;
PKIX_INCREF(nameConstraints);
anchor->nameConstraints = nameConstraints;
*pAnchor = anchor;
anchor = NULL;
cleanup:
PKIX_DECREF(anchor);
PKIX_RETURN(TRUSTANCHOR);
}
/*
* FUNCTION: PKIX_TrustAnchor_GetTrustedCert (see comments in pkix_params.h)
*/
PKIX_Error *
PKIX_TrustAnchor_GetTrustedCert(
PKIX_TrustAnchor *anchor,
PKIX_PL_Cert **pCert,
void *plContext)
{
PKIX_ENTER(TRUSTANCHOR, "PKIX_TrustAnchor_GetTrustedCert");
PKIX_NULLCHECK_TWO(anchor, pCert);
PKIX_INCREF(anchor->trustedCert);
*pCert = anchor->trustedCert;
cleanup:
PKIX_RETURN(TRUSTANCHOR);
}
/*
* FUNCTION: PKIX_TrustAnchor_GetCAName (see comments in pkix_params.h)
*/
PKIX_Error *
PKIX_TrustAnchor_GetCAName(
PKIX_TrustAnchor *anchor,
PKIX_PL_X500Name **pCAName,
void *plContext)
{
PKIX_ENTER(TRUSTANCHOR, "PKIX_TrustAnchor_GetCAName");
PKIX_NULLCHECK_TWO(anchor, pCAName);
PKIX_INCREF(anchor->caName);
*pCAName = anchor->caName;
cleanup:
PKIX_RETURN(TRUSTANCHOR);
}
/*
* FUNCTION: PKIX_TrustAnchor_GetCAPublicKey (see comments in pkix_params.h)
*/
PKIX_Error *
PKIX_TrustAnchor_GetCAPublicKey(
PKIX_TrustAnchor *anchor,
PKIX_PL_PublicKey **pPubKey,
void *plContext)
{
PKIX_ENTER(TRUSTANCHOR, "PKIX_TrustAnchor_GetCAPublicKey");
PKIX_NULLCHECK_TWO(anchor, pPubKey);
PKIX_INCREF(anchor->caPubKey);
*pPubKey = anchor->caPubKey;
cleanup:
PKIX_RETURN(TRUSTANCHOR);
}
/*
* FUNCTION: PKIX_TrustAnchor_GetNameConstraints
* (see comments in pkix_params.h)
*/
PKIX_Error *
PKIX_TrustAnchor_GetNameConstraints(
PKIX_TrustAnchor *anchor,
PKIX_PL_CertNameConstraints **pNameConstraints,
void *plContext)
{
PKIX_ENTER(TRUSTANCHOR, "PKIX_TrustAnchor_GetNameConstraints");
PKIX_NULLCHECK_TWO(anchor, pNameConstraints);
PKIX_INCREF(anchor->nameConstraints);
*pNameConstraints = anchor->nameConstraints;
cleanup:
PKIX_RETURN(TRUSTANCHOR);
}

35
security/nss/lib/libpkix/pkix/params/pkix_trustanchor.h Normal file
View file

@ -0,0 +1,35 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/*
* pkix_trustanchor.h
*
* TrustAnchor Object Type Definition
*
*/
#ifndef _PKIX_TRUSTANCHOR_H
#define _PKIX_TRUSTANCHOR_H
#include "pkix_tools.h"
#ifdef __cplusplus
extern "C" {
#endif
struct PKIX_TrustAnchorStruct {
PKIX_PL_Cert *trustedCert;
PKIX_PL_X500Name *caName;
PKIX_PL_PublicKey *caPubKey;
PKIX_PL_CertNameConstraints *nameConstraints;
};
/* see source file for function documentation */
PKIX_Error *pkix_TrustAnchor_RegisterSelf(void *plContext);
#ifdef __cplusplus
}
#endif
#endif /* _PKIX_TRUSTANCHOR_H */

335
security/nss/lib/libpkix/pkix/params/pkix_valparams.c Normal file
View file

@ -0,0 +1,335 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/*
* pkix_valparams.c
*
* Validate Params Object Functions
*
*/
#include "pkix_valparams.h"
/* --Private-Functions-------------------------------------------- */
/*
* FUNCTION: pkix_ValidateParams_Destroy
* (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_ValidateParams_Destroy(
PKIX_PL_Object *object,
void *plContext)
{
PKIX_ValidateParams *params = NULL;
PKIX_ENTER(VALIDATEPARAMS, "pkix_ValidateParams_Destroy");
PKIX_NULLCHECK_ONE(object);
/* Check that this object is a validate params object */
PKIX_CHECK(pkix_CheckType(object, PKIX_VALIDATEPARAMS_TYPE, plContext),
PKIX_OBJECTNOTVALIDATEPARAMS);
params = (PKIX_ValidateParams *)object;
PKIX_DECREF(params->procParams);
PKIX_DECREF(params->chain);
cleanup:
PKIX_RETURN(VALIDATEPARAMS);
}
/*
* FUNCTION: pkix_ValidateParams_Equals
* (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_ValidateParams_Equals(
PKIX_PL_Object *first,
PKIX_PL_Object *second,
PKIX_Boolean *pResult,
void *plContext)
{
PKIX_UInt32 secondType;
PKIX_Boolean cmpResult;
PKIX_ValidateParams *firstValParams = NULL;
PKIX_ValidateParams *secondValParams = NULL;
PKIX_ENTER(VALIDATEPARAMS, "pkix_ValidateParams_Equals");
PKIX_NULLCHECK_THREE(first, second, pResult);
PKIX_CHECK(pkix_CheckType(first, PKIX_VALIDATEPARAMS_TYPE, plContext),
PKIX_FIRSTOBJECTNOTVALIDATEPARAMS);
PKIX_CHECK(PKIX_PL_Object_GetType(second, &secondType, plContext),
PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
*pResult = PKIX_FALSE;
if (secondType != PKIX_VALIDATEPARAMS_TYPE) goto cleanup;
firstValParams = (PKIX_ValidateParams *)first;
secondValParams = (PKIX_ValidateParams *)second;
PKIX_CHECK(PKIX_PL_Object_Equals
((PKIX_PL_Object *)firstValParams->procParams,
(PKIX_PL_Object *)secondValParams->procParams,
&cmpResult,
plContext),
PKIX_OBJECTEQUALSFAILED);
if (!cmpResult) goto cleanup;
PKIX_CHECK(PKIX_PL_Object_Equals
((PKIX_PL_Object *)firstValParams->chain,
(PKIX_PL_Object *)secondValParams->chain,
&cmpResult,
plContext),
PKIX_OBJECTEQUALSFAILED);
if (!cmpResult) goto cleanup;
*pResult = cmpResult;
cleanup:
PKIX_RETURN(VALIDATEPARAMS);
}
/*
* FUNCTION: pkix_ValidateParams_Hashcode
* (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_ValidateParams_Hashcode(
PKIX_PL_Object *object,
PKIX_UInt32 *pHashcode,
void *plContext)
{
PKIX_ValidateParams *valParams = NULL;
PKIX_UInt32 hash = 0;
PKIX_UInt32 procParamsHash = 0;
PKIX_UInt32 chainHash = 0;
PKIX_ENTER(VALIDATEPARAMS, "pkix_ValidateParams_Hashcode");
PKIX_NULLCHECK_TWO(object, pHashcode);
PKIX_CHECK(pkix_CheckType(object, PKIX_VALIDATEPARAMS_TYPE, plContext),
PKIX_OBJECTNOTVALIDATEPARAMS);
valParams = (PKIX_ValidateParams*)object;
PKIX_CHECK(PKIX_PL_Object_Hashcode
((PKIX_PL_Object *)valParams->procParams,
&procParamsHash,
plContext),
PKIX_OBJECTHASHCODEFAILED);
PKIX_CHECK(PKIX_PL_Object_Hashcode
((PKIX_PL_Object *)valParams->chain,
&chainHash,
plContext),
PKIX_OBJECTHASHCODEFAILED);
hash = 31 * procParamsHash + chainHash;
*pHashcode = hash;
cleanup:
PKIX_RETURN(VALIDATEPARAMS);
}
/*
* FUNCTION: pkix_ValidateParams_ToString
* (see comments for PKIX_PL_ToStringCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_ValidateParams_ToString(
PKIX_PL_Object *object,
PKIX_PL_String **pString,
void *plContext)
{
PKIX_ValidateParams *valParams = NULL;
char *asciiFormat = NULL;
PKIX_PL_String *formatString = NULL;
PKIX_PL_String *valParamsString = NULL;
PKIX_PL_String *procParamsString = NULL;
PKIX_PL_String *chainString = NULL;
PKIX_ENTER(VALIDATEPARAMS, "pkix_ValidateParams_ToString");
PKIX_NULLCHECK_TWO(object, pString);
PKIX_CHECK(pkix_CheckType(object, PKIX_VALIDATEPARAMS_TYPE, plContext),
PKIX_OBJECTNOTVALIDATEPARAMS);
asciiFormat =
"[\n"
"\tProcessing Params: \n"
"\t********BEGIN PROCESSING PARAMS********\n"
"\t\t%s\n"
"\t********END PROCESSING PARAMS********\n"
"\tChain: \t\t%s\n"
"]\n";
PKIX_CHECK(PKIX_PL_String_Create
(PKIX_ESCASCII,
asciiFormat,
0,
&formatString,
plContext),
PKIX_STRINGCREATEFAILED);
valParams = (PKIX_ValidateParams*)object;
PKIX_CHECK(PKIX_PL_Object_ToString
((PKIX_PL_Object*)valParams->procParams,
&procParamsString,
plContext),
PKIX_OBJECTTOSTRINGFAILED);
PKIX_CHECK(PKIX_PL_Object_ToString
((PKIX_PL_Object *)valParams->chain,
&chainString,
plContext),
PKIX_OBJECTTOSTRINGFAILED);
PKIX_CHECK(PKIX_PL_Sprintf
(&valParamsString,
plContext,
formatString,
procParamsString,
chainString),
PKIX_SPRINTFFAILED);
*pString = valParamsString;
cleanup:
PKIX_DECREF(formatString);
PKIX_DECREF(procParamsString);
PKIX_DECREF(chainString);
PKIX_RETURN(VALIDATEPARAMS);
}
/*
* FUNCTION: pkix_ValidateParams_RegisterSelf
* DESCRIPTION:
* Registers PKIX_VALIDATEPARAMS_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_ValidateParams_RegisterSelf(void *plContext)
{
extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES];
pkix_ClassTable_Entry entry;
PKIX_ENTER(VALIDATEPARAMS, "pkix_ValidateParams_RegisterSelf");
entry.description = "ValidateParams";
entry.objCounter = 0;
entry.typeObjectSize = sizeof(PKIX_ValidateParams);
entry.destructor = pkix_ValidateParams_Destroy;
entry.equalsFunction = pkix_ValidateParams_Equals;
entry.hashcodeFunction = pkix_ValidateParams_Hashcode;
entry.toStringFunction = pkix_ValidateParams_ToString;
entry.comparator = NULL;
entry.duplicateFunction = NULL;
systemClasses[PKIX_VALIDATEPARAMS_TYPE] = entry;
PKIX_RETURN(VALIDATEPARAMS);
}
/* --Public-Functions--------------------------------------------- */
/*
* FUNCTION: PKIX_ValidateParams_Create (see comments in pkix_params.h)
*/
PKIX_Error *
PKIX_ValidateParams_Create(
PKIX_ProcessingParams *procParams,
PKIX_List *chain,
PKIX_ValidateParams **pParams,
void *plContext)
{
PKIX_ValidateParams *params = NULL;
PKIX_ENTER(VALIDATEPARAMS, "PKIX_ValidateParams_Create");
PKIX_NULLCHECK_THREE(procParams, chain, pParams);
PKIX_CHECK(PKIX_PL_Object_Alloc
(PKIX_VALIDATEPARAMS_TYPE,
sizeof (PKIX_ValidateParams),
(PKIX_PL_Object **)&params,
plContext),
PKIX_COULDNOTCREATEVALIDATEPARAMSOBJECT);
/* initialize fields */
PKIX_INCREF(procParams);
params->procParams = procParams;
PKIX_INCREF(chain);
params->chain = chain;
*pParams = params;
params = NULL;
cleanup:
PKIX_DECREF(params);
PKIX_RETURN(VALIDATEPARAMS);
}
/*
* FUNCTION: PKIX_ValidateParams_GetProcessingParams
* (see comments in pkix_params.h)
*/
PKIX_Error *
PKIX_ValidateParams_GetProcessingParams(
PKIX_ValidateParams *valParams,
PKIX_ProcessingParams **pProcParams,
void *plContext)
{
PKIX_ENTER(VALIDATEPARAMS, "PKIX_ValidateParams_GetProcessingParams");
PKIX_NULLCHECK_TWO(valParams, pProcParams);
PKIX_INCREF(valParams->procParams);
*pProcParams = valParams->procParams;
cleanup:
PKIX_RETURN(VALIDATEPARAMS);
}
/*
* FUNCTION: PKIX_ValidateParams_GetCertChain (see comments in pkix_params.h)
*/
PKIX_Error *
PKIX_ValidateParams_GetCertChain(
PKIX_ValidateParams *valParams,
PKIX_List **pChain,
void *plContext)
{
PKIX_ENTER(VALIDATEPARAMS, "PKIX_ValidateParams_GetCertChain");
PKIX_NULLCHECK_TWO(valParams, pChain);
PKIX_INCREF(valParams->chain);
*pChain = valParams->chain;
cleanup:
PKIX_RETURN(VALIDATEPARAMS);
}

33
security/nss/lib/libpkix/pkix/params/pkix_valparams.h Normal file
View file

@ -0,0 +1,33 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/*
* pkix_valparams.h
*
* ValidateParams Object Type Definition
*
*/
#ifndef _PKIX_VALIDATEPARAMS_H
#define _PKIX_VALIDATEPARAMS_H
#include "pkix_tools.h"
#ifdef __cplusplus
extern "C" {
#endif
struct PKIX_ValidateParamsStruct {
PKIX_ProcessingParams *procParams; /* Never NULL */
PKIX_List *chain; /* Never NULL */
};
/* see source file for function documentation */
PKIX_Error *pkix_ValidateParams_RegisterSelf(void *plContext);
#ifdef __cplusplus
}
#endif
#endif /* _PKIX_VALIDATEPARAMS_H */