/* 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/. */
/*
 * testutil_nss.c
 *
 * NSS-specific utility functions for handling test errors
 *
 */

#include <stdio.h>
#include <string.h>
#include <stddef.h>

#include "pkix_pl_generalname.h"
#include "pkix_pl_cert.h"
#include "pkix.h"
#include "testutil.h"
#include "prlong.h"
#include "plstr.h"
#include "prthread.h"
#include "secutil.h"
#include "nspr.h"
#include "prtypes.h"
#include "prtime.h"
#include "pk11func.h"
#include "secasn1.h"
#include "cert.h"
#include "cryptohi.h"
#include "secoid.h"
#include "certdb.h"
#include "secitem.h"
#include "keythi.h"
#include "nss.h"

static char *
catDirName(char *dir, char *name, void *plContext)
{
    char *pathName = NULL;
    PKIX_UInt32 nameLen;
    PKIX_UInt32 dirLen;

    PKIX_TEST_STD_VARS();

    nameLen = PL_strlen(name);
    dirLen = PL_strlen(dir);

    PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Malloc(dirLen + nameLen + 2,
                                             (void **)&pathName,
                                             plContext));

    PL_strcpy(pathName, dir);
    PL_strcat(pathName, "/");
    PL_strcat(pathName, name);
    printf("pathName = %s\n", pathName);

cleanup:

    PKIX_TEST_RETURN();

    return (pathName);
}

PKIX_PL_Cert *
createCert(
    char *dirName,
    char *certFileName,
    void *plContext)
{
    PKIX_PL_ByteArray *byteArray = NULL;
    void *buf = NULL;
    PRFileDesc *certFile = NULL;
    PKIX_UInt32 len;
    SECItem certDER;
    SECStatus rv;
    /* default: NULL cert (failure case) */
    PKIX_PL_Cert *cert = NULL;
    char *pathName = NULL;

    PKIX_TEST_STD_VARS();

    certDER.data = NULL;

    pathName = catDirName(dirName, certFileName, plContext);
    certFile = PR_Open(pathName, PR_RDONLY, 0);

    if (!certFile) {
        pkixTestErrorMsg = "Unable to open cert file";
        goto cleanup;
    } else {
        rv = SECU_ReadDERFromFile(&certDER, certFile, PR_FALSE, PR_FALSE);
        if (!rv) {
            buf = (void *)certDER.data;
            len = certDER.len;

            PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_ByteArray_Create(buf, len, &byteArray, plContext));

            PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Cert_Create(byteArray, &cert, plContext));

            SECITEM_FreeItem(&certDER, PR_FALSE);
        } else {
            pkixTestErrorMsg = "Unable to read DER from cert file";
            goto cleanup;
        }
    }

cleanup:

    pkixTestErrorResult = PKIX_PL_Free(pathName, plContext);

    if (certFile) {
        PR_Close(certFile);
    }

    if (PKIX_TEST_ERROR_RECEIVED) {
        SECITEM_FreeItem(&certDER, PR_FALSE);
    }

    PKIX_TEST_DECREF_AC(byteArray);

    PKIX_TEST_RETURN();

    return (cert);
}

PKIX_PL_CRL *
createCRL(
    char *dirName,
    char *crlFileName,
    void *plContext)
{
    PKIX_PL_ByteArray *byteArray = NULL;
    PKIX_PL_CRL *crl = NULL;
    PKIX_Error *error = NULL;
    PRFileDesc *inFile = NULL;
    SECItem crlDER;
    void *buf = NULL;
    PKIX_UInt32 len;
    SECStatus rv;
    char *pathName = NULL;

    PKIX_TEST_STD_VARS();

    crlDER.data = NULL;

    pathName = catDirName(dirName, crlFileName, plContext);
    inFile = PR_Open(pathName, PR_RDONLY, 0);

    if (!inFile) {
        pkixTestErrorMsg = "Unable to open crl file";
        goto cleanup;
    } else {
        rv = SECU_ReadDERFromFile(&crlDER, inFile, PR_FALSE, PR_FALSE);
        if (!rv) {
            buf = (void *)crlDER.data;
            len = crlDER.len;

            error = PKIX_PL_ByteArray_Create(buf, len, &byteArray, plContext);

            if (error) {
                pkixTestErrorMsg =
                    "PKIX_PL_ByteArray_Create failed";
                goto cleanup;
            }

            error = PKIX_PL_CRL_Create(byteArray, &crl, plContext);
            if (error) {
                pkixTestErrorMsg = "PKIX_PL_Crl_Create failed";
                goto cleanup;
            }

            SECITEM_FreeItem(&crlDER, PR_FALSE);
        } else {
            pkixTestErrorMsg = "Unable to read DER from crl file";
            goto cleanup;
        }
    }

cleanup:

    PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(pathName, plContext));

    if (inFile) {
        PR_Close(inFile);
    }

    if (error) {
        SECITEM_FreeItem(&crlDER, PR_FALSE);
    }

    PKIX_TEST_DECREF_AC(byteArray);

    PKIX_TEST_RETURN();

    return (crl);
}

PKIX_TrustAnchor *
createTrustAnchor(
    char *dirName,
    char *certFileName,
    PKIX_Boolean useCert,
    void *plContext)
{
    PKIX_TrustAnchor *anchor = NULL;
    PKIX_PL_Cert *cert = NULL;
    PKIX_PL_X500Name *name = NULL;
    PKIX_PL_PublicKey *pubKey = NULL;
    PKIX_PL_CertNameConstraints *nameConstraints = NULL;

    PKIX_TEST_STD_VARS();

    cert = createCert(dirName, certFileName, plContext);

    if (useCert) {
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_TrustAnchor_CreateWithCert(cert, &anchor, plContext));
    } else {
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Cert_GetSubject(cert, &name, plContext));

        if (name == NULL) {
            goto cleanup;
        }

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Cert_GetSubjectPublicKey(cert, &pubKey, plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Cert_GetNameConstraints(cert, &nameConstraints, NULL));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_TrustAnchor_CreateWithNameKeyPair(name, pubKey, nameConstraints, &anchor, plContext));
    }

cleanup:

    if (PKIX_TEST_ERROR_RECEIVED) {
        PKIX_TEST_DECREF_AC(anchor);
    }

    PKIX_TEST_DECREF_AC(cert);
    PKIX_TEST_DECREF_AC(name);
    PKIX_TEST_DECREF_AC(pubKey);
    PKIX_TEST_DECREF_AC(nameConstraints);

    PKIX_TEST_RETURN();

    return (anchor);
}

PKIX_List *
createCertChain(
    char *dirName,
    char *firstCertFileName,
    char *secondCertFileName,
    void *plContext)
{
    PKIX_PL_Cert *firstCert = NULL;
    PKIX_PL_Cert *secondCert = NULL;
    PKIX_List *certList = NULL;

    PKIX_TEST_STD_VARS();

    PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(&certList, plContext));

    firstCert = createCert(dirName, firstCertFileName, plContext);

    PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(certList, (PKIX_PL_Object *)firstCert, plContext));

    if (secondCertFileName) {
        secondCert = createCert(dirName, secondCertFileName, plContext);

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(certList, (PKIX_PL_Object *)secondCert, plContext));
    }

    PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_SetImmutable(certList, plContext));

cleanup:

    if (PKIX_TEST_ERROR_RECEIVED) {
        PKIX_TEST_DECREF_AC(certList);
    }

    PKIX_TEST_DECREF_AC(firstCert);
    PKIX_TEST_DECREF_AC(secondCert);

    PKIX_TEST_RETURN();

    return (certList);
}

PKIX_List *
createCertChainPlus(
    char *dirName,
    char *certNames[],
    PKIX_PL_Cert *certs[],
    PKIX_UInt32 numCerts,
    void *plContext)
{
    PKIX_List *certList = NULL;
    PKIX_UInt32 i;

    PKIX_TEST_STD_VARS();

    PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(&certList, plContext));

    for (i = 0; i < numCerts; i++) {

        certs[i] = createCert(dirName, certNames[i], plContext);

        /* Create Cert may fail */
        if (certs[i] == NULL) {
            PKIX_TEST_DECREF_BC(certList);
            goto cleanup;
        }

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(certList,
                                                       (PKIX_PL_Object *)certs[i],
                                                       plContext));
    }

    PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_SetImmutable(certList, plContext));

cleanup:

    if (PKIX_TEST_ERROR_RECEIVED) {
        PKIX_TEST_DECREF_AC(certList);
    }

    for (i = 0; i < numCerts; i++) {
        PKIX_TEST_DECREF_AC(certs[i]);
    }

    PKIX_TEST_RETURN();

    return (certList);
}

PKIX_PL_Date *
createDate(
    char *asciiDate,
    void *plContext)
{
    PKIX_PL_Date *date = NULL;
    PKIX_PL_String *plString = NULL;

    PKIX_TEST_STD_VARS();

    PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII, asciiDate, 0, &plString, plContext));

    PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Date_Create_UTCTime(plString, &date, plContext));

cleanup:

    PKIX_TEST_DECREF_AC(plString);

    PKIX_TEST_RETURN();

    return (date);
}

PKIX_ProcessingParams *
createProcessingParams(
    char *dirName,
    char *firstAnchorFileName,
    char *secondAnchorFileName,
    char *dateAscii,
    PKIX_List *initialPolicies, /* List of PKIX_PL_OID */
    PKIX_Boolean isCrlEnabled,
    void *plContext)
{

    PKIX_TrustAnchor *firstAnchor = NULL;
    PKIX_TrustAnchor *secondAnchor = NULL;
    PKIX_List *anchorsList = NULL;
    PKIX_ProcessingParams *procParams = NULL;
    PKIX_PL_String *dateString = NULL;
    PKIX_PL_Date *testDate = NULL;

    PKIX_TEST_STD_VARS();

    PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(&anchorsList, plContext));

    firstAnchor = createTrustAnchor(dirName, firstAnchorFileName, PKIX_FALSE, plContext);

    PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(anchorsList,
                                                   (PKIX_PL_Object *)firstAnchor,
                                                   plContext));

    if (secondAnchorFileName) {
        secondAnchor =
            createTrustAnchor(dirName, secondAnchorFileName, PKIX_FALSE, plContext);

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(anchorsList,
                                                       (PKIX_PL_Object *)secondAnchor,
                                                       plContext));
    }

    PKIX_TEST_EXPECT_NO_ERROR(PKIX_ProcessingParams_Create(anchorsList, &procParams, plContext));

    if (dateAscii) {
        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII,
                                                        dateAscii,
                                                        0,
                                                        &dateString,
                                                        plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Date_Create_UTCTime(dateString, &testDate, plContext));

        PKIX_TEST_EXPECT_NO_ERROR(PKIX_ProcessingParams_SetDate(procParams, testDate, plContext));
    }

    PKIX_TEST_EXPECT_NO_ERROR(PKIX_ProcessingParams_SetInitialPolicies(procParams, initialPolicies, plContext));

    PKIX_TEST_EXPECT_NO_ERROR(PKIX_ProcessingParams_SetRevocationEnabled(procParams, isCrlEnabled, plContext));

cleanup:

    if (PKIX_TEST_ERROR_RECEIVED) {
        PKIX_TEST_DECREF_AC(procParams);
    }

    PKIX_TEST_DECREF_AC(dateString);
    PKIX_TEST_DECREF_AC(testDate);
    PKIX_TEST_DECREF_AC(anchorsList);
    PKIX_TEST_DECREF_AC(firstAnchor);
    PKIX_TEST_DECREF_AC(secondAnchor);

    PKIX_TEST_RETURN();

    return (procParams);
}

PKIX_ValidateParams *
createValidateParams(
    char *dirName,
    char *firstAnchorFileName,
    char *secondAnchorFileName,
    char *dateAscii,
    PKIX_List *initialPolicies, /* List of PKIX_PL_OID */
    PKIX_Boolean initialPolicyMappingInhibit,
    PKIX_Boolean initialAnyPolicyInhibit,
    PKIX_Boolean initialExplicitPolicy,
    PKIX_Boolean isCrlEnabled,
    PKIX_List *chain,
    void *plContext)
{

    PKIX_ProcessingParams *procParams = NULL;
    PKIX_ValidateParams *valParams = NULL;

    PKIX_TEST_STD_VARS();

    procParams =
        createProcessingParams(dirName,
                               firstAnchorFileName,
                               secondAnchorFileName,
                               dateAscii,
                               NULL,
                               isCrlEnabled,
                               plContext);

    PKIX_TEST_EXPECT_NO_ERROR(PKIX_ProcessingParams_SetInitialPolicies(procParams, initialPolicies, plContext));

    PKIX_TEST_EXPECT_NO_ERROR(PKIX_ProcessingParams_SetPolicyMappingInhibited(procParams, initialPolicyMappingInhibit, NULL));

    PKIX_TEST_EXPECT_NO_ERROR(PKIX_ProcessingParams_SetAnyPolicyInhibited(procParams, initialAnyPolicyInhibit, NULL));

    PKIX_TEST_EXPECT_NO_ERROR(PKIX_ProcessingParams_SetExplicitPolicyRequired(procParams, initialExplicitPolicy, NULL));

    PKIX_TEST_EXPECT_NO_ERROR(PKIX_ValidateParams_Create(procParams, chain, &valParams, plContext));

cleanup:

    if (PKIX_TEST_ERROR_RECEIVED) {
        PKIX_TEST_DECREF_AC(valParams);
    }

    PKIX_TEST_DECREF_AC(procParams);

    PKIX_TEST_RETURN();

    return (valParams);
}

PKIX_ValidateResult *
createValidateResult(
    char *dirName,
    char *anchorFileName,
    char *pubKeyCertFileName,
    void *plContext)
{

    PKIX_TrustAnchor *anchor = NULL;
    PKIX_ValidateResult *valResult = NULL;
    PKIX_PL_Cert *cert = NULL;
    PKIX_PL_PublicKey *pubKey = NULL;

    PKIX_TEST_STD_VARS();

    anchor = createTrustAnchor(dirName, anchorFileName, PKIX_FALSE, plContext);
    cert = createCert(dirName, pubKeyCertFileName, plContext);

    PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Cert_GetSubjectPublicKey(cert, &pubKey, plContext));

    PKIX_TEST_EXPECT_NO_ERROR(pkix_ValidateResult_Create(pubKey, anchor, NULL, &valResult, plContext));

cleanup:

    if (PKIX_TEST_ERROR_RECEIVED) {
        PKIX_TEST_DECREF_AC(valResult);
    }

    PKIX_TEST_DECREF_AC(anchor);
    PKIX_TEST_DECREF_AC(cert);
    PKIX_TEST_DECREF_AC(pubKey);

    PKIX_TEST_RETURN();

    return (valResult);
}

PKIX_PL_GeneralName *
createGeneralName(
    PKIX_UInt32 nameType,
    char *asciiName,
    void *plContext)
{

    PKIX_PL_GeneralName *generalName = NULL;
    PKIX_PL_String *plString = NULL;

    PKIX_TEST_STD_VARS();

    PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII, asciiName, 0, &plString, plContext));

    PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_GeneralName_Create(nameType, plString, &generalName, plContext));

cleanup:

    PKIX_TEST_DECREF_AC(plString);

    PKIX_TEST_RETURN();

    return (generalName);
}

PKIX_BuildResult *
createBuildResult(
    char *dirName,
    char *anchorFileName,
    char *pubKeyCertFileName,
    char *firstChainCertFileName,
    char *secondChainCertFileName,
    void *plContext)
{
    PKIX_BuildResult *buildResult = NULL;
    PKIX_ValidateResult *valResult = NULL;
    PKIX_List *certChain = NULL;

    PKIX_TEST_STD_VARS();

    valResult = createValidateResult(dirName, anchorFileName, pubKeyCertFileName, plContext);
    certChain = createCertChain(dirName,
                                firstChainCertFileName,
                                secondChainCertFileName,
                                plContext);

    PKIX_TEST_EXPECT_NO_ERROR(pkix_BuildResult_Create(valResult, certChain, &buildResult, plContext));

cleanup:

    if (PKIX_TEST_ERROR_RECEIVED) {
        PKIX_TEST_DECREF_AC(buildResult);
    }

    PKIX_TEST_DECREF_AC(valResult);
    PKIX_TEST_DECREF_AC(certChain);

    PKIX_TEST_RETURN();

    return (buildResult);
}