/* 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/. */

#include "plarena.h"

#include "seccomon.h"

#include "secitem.h"

#include "secoidt.h"

#include "secasn1.h"

#include "secder.h"

#include "certt.h"

#include "cert.h"

#include "certi.h"

#include "xconst.h"

#include "secerr.h"

#include "secoid.h"

#include "prprf.h"

#include "genname.h"

SEC_ASN1_MKSUB(SEC_AnyTemplate)

SEC_ASN1_MKSUB(SEC_IntegerTemplate)

SEC_ASN1_MKSUB(SEC_IA5StringTemplate)

SEC_ASN1_MKSUB(SEC_ObjectIDTemplate)

SEC_ASN1_MKSUB(SEC_OctetStringTemplate)

static const SEC_ASN1Template CERTNameConstraintTemplate[] = {

    { SEC_ASN1_SEQUENCE, 0, NULL, sizeof(CERTNameConstraint) },

    { SEC_ASN1_ANY, offsetof(CERTNameConstraint, DERName) },

    { SEC_ASN1_OPTIONAL | SEC_ASN1_CONTEXT_SPECIFIC | SEC_ASN1_XTRN | 0,

      offsetof(CERTNameConstraint, min), SEC_ASN1_SUB(SEC_IntegerTemplate) },

    { SEC_ASN1_OPTIONAL | SEC_ASN1_CONTEXT_SPECIFIC | SEC_ASN1_XTRN | 1,

      offsetof(CERTNameConstraint, max), SEC_ASN1_SUB(SEC_IntegerTemplate) },

    { 0 }

};

const SEC_ASN1Template CERT_NameConstraintSubtreeSubTemplate[] = {

    { SEC_ASN1_SEQUENCE_OF | SEC_ASN1_XTRN, 0, SEC_ASN1_SUB(SEC_AnyTemplate) }

};

static const SEC_ASN1Template CERTNameConstraintsTemplate[] = {

    { SEC_ASN1_SEQUENCE, 0, NULL, sizeof(CERTNameConstraints) },

    { SEC_ASN1_OPTIONAL | SEC_ASN1_CONSTRUCTED | SEC_ASN1_CONTEXT_SPECIFIC | 0,

      offsetof(CERTNameConstraints, DERPermited),

      CERT_NameConstraintSubtreeSubTemplate },

    { SEC_ASN1_OPTIONAL | SEC_ASN1_CONSTRUCTED | SEC_ASN1_CONTEXT_SPECIFIC | 1,

      offsetof(CERTNameConstraints, DERExcluded),

      CERT_NameConstraintSubtreeSubTemplate },

    { 0 }

};

static const SEC_ASN1Template CERTOthNameTemplate[] = {

    { SEC_ASN1_SEQUENCE, 0, NULL, sizeof(OtherName) },

    { SEC_ASN1_OBJECT_ID, offsetof(OtherName, oid) },

    { SEC_ASN1_CONTEXT_SPECIFIC | SEC_ASN1_CONSTRUCTED | SEC_ASN1_EXPLICIT |

          SEC_ASN1_XTRN | 0,

      offsetof(OtherName, name), SEC_ASN1_SUB(SEC_AnyTemplate) },

    { 0 }

};

static const SEC_ASN1Template CERTOtherNameTemplate[] = {

    { SEC_ASN1_CONTEXT_SPECIFIC | SEC_ASN1_CONSTRUCTED | 0,

      offsetof(CERTGeneralName, name.OthName), CERTOthNameTemplate,

      sizeof(CERTGeneralName) }

};

static const SEC_ASN1Template CERT_RFC822NameTemplate[] = {

    { SEC_ASN1_CONTEXT_SPECIFIC | SEC_ASN1_XTRN | 1,

      offsetof(CERTGeneralName, name.other),

      SEC_ASN1_SUB(SEC_IA5StringTemplate), sizeof(CERTGeneralName) }

};

static const SEC_ASN1Template CERT_DNSNameTemplate[] = {

    { SEC_ASN1_CONTEXT_SPECIFIC | SEC_ASN1_XTRN | 2,

      offsetof(CERTGeneralName, name.other),

      SEC_ASN1_SUB(SEC_IA5StringTemplate), sizeof(CERTGeneralName) }

};

static const SEC_ASN1Template CERT_X400AddressTemplate[] = {

    { SEC_ASN1_CONTEXT_SPECIFIC | SEC_ASN1_CONSTRUCTED | SEC_ASN1_XTRN | 3,

      offsetof(CERTGeneralName, name.other), SEC_ASN1_SUB(SEC_AnyTemplate),

      sizeof(CERTGeneralName) }

};

static const SEC_ASN1Template CERT_DirectoryNameTemplate[] = {

    { SEC_ASN1_CONTEXT_SPECIFIC | SEC_ASN1_CONSTRUCTED | SEC_ASN1_EXPLICIT |

          SEC_ASN1_XTRN | 4,

      offsetof(CERTGeneralName, derDirectoryName),

      SEC_ASN1_SUB(SEC_AnyTemplate), sizeof(CERTGeneralName) }

};

static const SEC_ASN1Template CERT_EDIPartyNameTemplate[] = {

    { SEC_ASN1_CONTEXT_SPECIFIC | SEC_ASN1_CONSTRUCTED | SEC_ASN1_XTRN | 5,

      offsetof(CERTGeneralName, name.other), SEC_ASN1_SUB(SEC_AnyTemplate),

      sizeof(CERTGeneralName) }

};

static const SEC_ASN1Template CERT_URITemplate[] = {

    { SEC_ASN1_CONTEXT_SPECIFIC | SEC_ASN1_XTRN | 6,

      offsetof(CERTGeneralName, name.other),

      SEC_ASN1_SUB(SEC_IA5StringTemplate), sizeof(CERTGeneralName) }

};

static const SEC_ASN1Template CERT_IPAddressTemplate[] = {

    { SEC_ASN1_CONTEXT_SPECIFIC | SEC_ASN1_XTRN | 7,

      offsetof(CERTGeneralName, name.other),

      SEC_ASN1_SUB(SEC_OctetStringTemplate), sizeof(CERTGeneralName) }

};

static const SEC_ASN1Template CERT_RegisteredIDTemplate[] = {

    { SEC_ASN1_CONTEXT_SPECIFIC | SEC_ASN1_XTRN | 8,

      offsetof(CERTGeneralName, name.other), SEC_ASN1_SUB(SEC_ObjectIDTemplate),

      sizeof(CERTGeneralName) }

};

const SEC_ASN1Template CERT_GeneralNamesTemplate[] = {

    { SEC_ASN1_SEQUENCE_OF | SEC_ASN1_XTRN, 0, SEC_ASN1_SUB(SEC_AnyTemplate) }

};

static struct {

    CERTGeneralNameType type;

    char *name;

} typesArray[] = { { certOtherName, "other" },

                   { certRFC822Name, "email" },

                   { certRFC822Name, "rfc822" },

                   { certDNSName, "dns" },

                   { certX400Address, "x400" },

                   { certX400Address, "x400addr" },

                   { certDirectoryName, "directory" },

                   { certDirectoryName, "dn" },

                   { certEDIPartyName, "edi" },

                   { certEDIPartyName, "ediparty" },

                   { certURI, "uri" },

                   { certIPAddress, "ip" },

                   { certIPAddress, "ipaddr" },

                   { certRegisterID, "registerid" } };

CERTGeneralNameType

CERT_GetGeneralNameTypeFromString(const char *string)

{

    int types_count = sizeof(typesArray) / sizeof(typesArray[0]);

    int i;

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

        if (PORT_Strcasecmp(string, typesArray[i].name) == 0) {

            return typesArray[i].type;

        }

    }

    return 0;

}

CERTGeneralName *

CERT_NewGeneralName(PLArenaPool *arena, CERTGeneralNameType type)

{

    CERTGeneralName *name = arena ? PORT_ArenaZNew(arena, CERTGeneralName)

                                  : PORT_ZNew(CERTGeneralName);

    if (name) {

        name->type = type;

        name->l.prev = name->l.next = &name->l;

    }

    return name;

}

/* Copy content of one General Name to another.

** Caller has allocated destination general name.

** This function does not change the destinate's GeneralName's list linkage.

*/

SECStatus

cert_CopyOneGeneralName(PLArenaPool *arena, CERTGeneralName *dest,

                        CERTGeneralName *src)

{

    SECStatus rv;

    void *mark = NULL;

    PORT_Assert(dest != NULL);

    dest->type = src->type;

    mark = PORT_ArenaMark(arena);

    switch (src->type) {

        case certDirectoryName:

            rv = SECITEM_CopyItem(arena, &dest->derDirectoryName,

                                  &src->derDirectoryName);

            if (rv == SECSuccess)

                rv = CERT_CopyName(arena, &dest->name.directoryName,

                                   &src->name.directoryName);

            break;

        case certOtherName:

            rv = SECITEM_CopyItem(arena, &dest->name.OthName.name,

                                  &src->name.OthName.name);

            if (rv == SECSuccess)

                rv = SECITEM_CopyItem(arena, &dest->name.OthName.oid,

                                      &src->name.OthName.oid);

            break;

        default:

            rv = SECITEM_CopyItem(arena, &dest->name.other, &src->name.other);

            break;

    }

    if (rv != SECSuccess) {

        PORT_ArenaRelease(arena, mark);

    } else {

        PORT_ArenaUnmark(arena, mark);

    }

    return rv;

}

void

CERT_DestroyGeneralNameList(CERTGeneralNameList *list)

{

    PZLock *lock;

    if (list != NULL) {

        lock = list->lock;

        PZ_Lock(lock);

        if (--list->refCount <= 0 && list->arena != NULL) {

            PORT_FreeArena(list->arena, PR_FALSE);

            PZ_Unlock(lock);

            PZ_DestroyLock(lock);

        } else {

            PZ_Unlock(lock);

        }

    }

    return;

}

CERTGeneralNameList *

CERT_CreateGeneralNameList(CERTGeneralName *name)

{

    PLArenaPool *arena;

    CERTGeneralNameList *list = NULL;

    arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);

    if (arena == NULL) {

        goto done;

    }

    list = PORT_ArenaZNew(arena, CERTGeneralNameList);

    if (!list)

        goto loser;

    if (name != NULL) {

        SECStatus rv;

        list->name = CERT_NewGeneralName(arena, (CERTGeneralNameType)0);

        if (!list->name)

            goto loser;

        rv = CERT_CopyGeneralName(arena, list->name, name);

        if (rv != SECSuccess)

            goto loser;

    }

    list->lock = PZ_NewLock(nssILockList);

    if (!list->lock)

        goto loser;

    list->arena = arena;

    list->refCount = 1;

done:

    return list;

loser:

    PORT_FreeArena(arena, PR_FALSE);

    return NULL;

}

CERTGeneralName *

CERT_GetNextGeneralName(CERTGeneralName *current)

{

    PRCList *next;

    next = current->l.next;

    return (CERTGeneralName *)(((char *)next) - offsetof(CERTGeneralName, l));

}

CERTGeneralName *

CERT_GetPrevGeneralName(CERTGeneralName *current)

{

    PRCList *prev;

    prev = current->l.prev;

    return (CERTGeneralName *)(((char *)prev) - offsetof(CERTGeneralName, l));

}

CERTNameConstraint *

CERT_GetNextNameConstraint(CERTNameConstraint *current)

{

    PRCList *next;

    next = current->l.next;

    return (CERTNameConstraint *)(((char *)next) -

                                  offsetof(CERTNameConstraint, l));

}

CERTNameConstraint *

CERT_GetPrevNameConstraint(CERTNameConstraint *current)

{

    PRCList *prev;

    prev = current->l.prev;

    return (CERTNameConstraint *)(((char *)prev) -

                                  offsetof(CERTNameConstraint, l));

}

SECItem *

CERT_EncodeGeneralName(CERTGeneralName *genName, SECItem *dest,

                       PLArenaPool *arena)

{

    const SEC_ASN1Template *template;

    PORT_Assert(arena);

    if (arena == NULL || !genName) {

        PORT_SetError(SEC_ERROR_INVALID_ARGS);

        return NULL;

    }

    /* TODO: mark arena */

    if (dest == NULL) {

        dest = PORT_ArenaZNew(arena, SECItem);

        if (!dest)

            goto loser;