path: root/security/nss/lib/ckfw/dbm/db.c

/* 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 "ckdbm.h"

#define PREFIX_METADATA "0000"
#define PREFIX_OBJECT "0001"
#define PREFIX_INDEX "0002"

static CK_VERSION nss_dbm_db_format_version = { 1, 0 };
struct handle {
    char prefix[4];
    CK_ULONG id;
};

NSS_IMPLEMENT nss_dbm_db_t *
nss_dbm_db_open(
    NSSArena *arena,
    NSSCKFWInstance *fwInstance,
    char *filename,
    int flags,
    CK_RV *pError)
{
    nss_dbm_db_t *rv;
    CK_VERSION db_version;

    rv = nss_ZNEW(arena, nss_dbm_db_t);
    if ((nss_dbm_db_t *)NULL == rv) {
        *pError = CKR_HOST_MEMORY;
        return (nss_dbm_db_t *)NULL;
    }

    rv->db = dbopen(filename, flags, 0600, DB_HASH, (const void *)NULL);
    if ((DB *)NULL == rv->db) {
        *pError = CKR_TOKEN_NOT_PRESENT;
        return (nss_dbm_db_t *)NULL;
    }

    rv->crustylock = NSSCKFWInstance_CreateMutex(fwInstance, arena, pError);
    if ((NSSCKFWMutex *)NULL == rv->crustylock) {
        return (nss_dbm_db_t *)NULL;
    }

    db_version = nss_dbm_db_get_format_version(rv);
    if (db_version.major != nss_dbm_db_format_version.major) {
        nss_dbm_db_close(rv);
        *pError = CKR_TOKEN_NOT_RECOGNIZED;
        return (nss_dbm_db_t *)NULL;
    }

    return rv;
}

NSS_IMPLEMENT void
nss_dbm_db_close(
    nss_dbm_db_t *db)
{
    if ((NSSCKFWMutex *)NULL != db->crustylock) {
        (void)NSSCKFWMutex_Destroy(db->crustylock);
    }

    if ((DB *)NULL != db->db) {
        (void)db->db->close(db->db);
    }

    nss_ZFreeIf(db);
}

NSS_IMPLEMENT CK_VERSION
nss_dbm_db_get_format_version(
    nss_dbm_db_t *db)
{
    CK_VERSION rv;
    DBT k, v;
    int dbrv;
    char buffer[64];

    rv.major = rv.minor = 0;

    k.data = PREFIX_METADATA "FormatVersion";
    k.size = nssUTF8_Size((NSSUTF8 *)k.data, (PRStatus *)NULL);
    (void)memset(&v, 0, sizeof(v));

    /* Locked region */
    {
        if (CKR_OK != NSSCKFWMutex_Lock(db->crustylock)) {
            return rv;
        }

        dbrv = db->db->get(db->db, &k, &v, 0);
        if (dbrv == 0) {
            CK_ULONG major = 0, minor = 0;
            (void)PR_sscanf(v.data, "%ld.%ld", &major, &minor);
            rv.major = major;
            rv.minor = minor;
        } else if (dbrv > 0) {
            (void)PR_snprintf(buffer, sizeof(buffer), "%ld.%ld", nss_dbm_db_format_version.major,
                              nss_dbm_db_format_version.minor);
            v.data = buffer;
            v.size = nssUTF8_Size((NSSUTF8 *)v.data, (PRStatus *)NULL);
            dbrv = db->db->put(db->db, &k, &v, 0);
            (void)db->db->sync(db->db, 0);
            rv = nss_dbm_db_format_version;
        } else {
            /* No error return.. */
            ;
        }

        (void)NSSCKFWMutex_Unlock(db->crustylock);
    }

    return rv;
}

NSS_IMPLEMENT CK_RV
nss_dbm_db_set_label(
    nss_dbm_db_t *db,
    NSSUTF8 *label)
{
    CK_RV rv;
    DBT k, v;
    int dbrv;

    k.data = PREFIX_METADATA "Label";
    k.size = nssUTF8_Size((NSSUTF8 *)k.data, (PRStatus *)NULL);
    v.data = label;
    v.size = nssUTF8_Size((NSSUTF8 *)v.data, (PRStatus *)NULL);

    /* Locked region */
    {
        rv = NSSCKFWMutex_Lock(db->crustylock);
        if (CKR_OK != rv) {
            return rv;
        }

        dbrv = db->db->put(db->db, &k, &v, 0);
        if (0 != dbrv) {
            rv = CKR_DEVICE_ERROR;
        }

        dbrv = db->db->sync(db->db, 0);
        if (0 != dbrv) {
            rv = CKR_DEVICE_ERROR;
        }

        (void)NSSCKFWMutex_Unlock(db->crustylock);
    }

    return rv;
}

NSS_IMPLEMENT NSSUTF8 *
nss_dbm_db_get_label(
    nss_dbm_db_t *db,
    NSSArena *arena,
    CK_RV *pError)
{
    NSSUTF8 *rv = (NSSUTF8 *)NULL;
    DBT k, v;
    int dbrv;

    k.data = PREFIX_METADATA "Label";
    k.size = nssUTF8_Size((NSSUTF8 *)k.data, (PRStatus *)NULL);

    /* Locked region */
    {
        if (CKR_OK != NSSCKFWMutex_Lock(db->crustylock)) {
            return rv;
        }

        dbrv = db->db->get(db->db, &k, &v, 0);
        if (0 == dbrv) {
            rv = nssUTF8_Duplicate((NSSUTF8 *)v.data, arena);
            if ((NSSUTF8 *)NULL == rv) {
                *pError = CKR_HOST_MEMORY;
            }
        } else if (dbrv > 0) {
            /* Just return null */
            ;
        } else {
            *pError = CKR_DEVICE_ERROR;
            ;
        }

        (void)NSSCKFWMutex_Unlock(db->crustylock);
    }

    return rv;
}

NSS_IMPLEMENT CK_RV
nss_dbm_db_delete_object(
    nss_dbm_dbt_t *dbt)
{
    CK_RV rv;
    int dbrv;

    /* Locked region */
    {
        rv = NSSCKFWMutex_Lock(dbt->my_db->crustylock);
        if (CKR_OK != rv) {
            return rv;
        }

        dbrv = dbt->my_db->db->del(dbt->my_db->db, &dbt->dbt, 0);
        if (0 != dbrv) {
            rv = CKR_DEVICE_ERROR;
            goto done;
        }

        dbrv = dbt->my_db->db->sync(dbt->my_db->db, 0);
        if (0 != dbrv) {
            rv = CKR_DEVICE_ERROR;
            goto done;
        }

    done:
        (void)NSSCKFWMutex_Unlock(dbt->my_db->crustylock);
    }

    return rv;
}

static CK_ULONG
nss_dbm_db_new_handle(
    nss_dbm_db_t *db,
    DBT *dbt, /* pre-allocated */
    CK_RV *pError)
{
    CK_ULONG rv;
    DBT k, v;
    CK_ULONG align = 0, id, myid;
    struct handle *hp;

    if (sizeof(struct handle) != dbt->size) {
        return EINVAL;
    }

    /* Locked region */
    {
        *pError = NSSCKFWMutex_Lock(db->crustylock);
        if (CKR_OK != *pError) {
            return EINVAL;
        }

        k.data = PREFIX_METADATA "LastID";
        k.size = nssUTF8_Size((NSSUTF8 *)k.data, (PRStatus *)NULL);
        (void)memset(&v, 0, sizeof(v));

        rv = db->db->get(db->db, &k, &v, 0);
        if (0 == rv) {
            (void)memcpy(&align, v.data, sizeof(CK_ULONG));
            id = ntohl(align);
        } else if (rv > 0) {
            id = 0;
        } else {
            goto done;
        }

        myid = id;
        id++;
        align = htonl(id);
        v.data = &align;
        v.size = sizeof(CK_ULONG);

        rv = db->db->put(db->db, &k, &v, 0);
        if (0 != rv) {
            goto done;
        }

        rv = db->db->sync(db->db, 0);
        if (0 != rv) {
            goto done;
        }

    done:
        (void)NSSCKFWMutex_Unlock(db->crustylock);
    }

    if (0 != rv) {
        return rv;
    }

    hp = (struct handle *)dbt->data;
    (void)memcpy(&hp->prefix[0], PREFIX_OBJECT, 4);
    hp->id = myid;

    return 0;
}

/*
 * This attribute-type-dependent swapping should probably
 * be in the Framework, because it'll be a concern of just
 * about every Module.  Of course any Framework implementation
 * will have to be augmentable or overridable by a Module.
 */

enum swap_type { type_byte,
                 type_short,
                 type_long,
                 type_opaque };

static enum swap_type
nss_dbm_db_swap_type(
    CK_ATTRIBUTE_TYPE type)
{
    switch (type) {
        case CKA_CLASS:
            return type_long;
        case CKA_TOKEN:
            return type_byte;
        case CKA_PRIVATE:
            return type_byte;
        case CKA_LABEL:
            return type_opaque;
        case CKA_APPLICATION:
            return type_opaque;
        case CKA_VALUE:
            return type_opaque;
        case CKA_CERTIFICATE_TYPE:
            return type_long;
        case CKA_ISSUER:
            return type_opaque;
        case CKA_SERIAL_NUMBER:
            return type_opaque;
        case CKA_KEY_TYPE:
            return type_long;
        case CKA_SUBJECT:
            return type_opaque;
        case CKA_ID:
            return type_opaque;
        case CKA_SENSITIVE:
            return type_byte;
        case CKA_ENCRYPT:
            return type_byte;
        case CKA_DECRYPT:
            return type_byte;
        case CKA_WRAP:
            return type_byte;
        case CKA_UNWRAP:
            return type_byte;
        case CKA_SIGN:
            return type_byte;
        case CKA_SIGN_RECOVER:
            return type_byte;
        case CKA_VERIFY:
            return type_byte;
        case CKA_VERIFY_RECOVER:
            return type_byte;
        case CKA_DERIVE:
            return type_byte;
        case CKA_START_DATE:
            return type_opaque;
        case CKA_END_DATE:
            return type_opaque;
        case CKA_MODULUS:
            return type_opaque;
        case CKA_MODULUS_BITS:
            return type_long;
        case CKA_PUBLIC_EXPONENT:
            return type_opaque;
        case CKA_PRIVATE_EXPONENT:
            return type_opaque;
        case CKA_PRIME_1:
            return type_opaque;
        case CKA_PRIME_2:
            return type_opaque;
        case CKA_EXPONENT_1:
            return type_opaque;
        case CKA_EXPONENT_2:
            return type_opaque;
        case CKA_COEFFICIENT:
            return type_opaque;
        case CKA_PRIME:
            return type_opaque;
        case CKA_SUBPRIME:
            return type_opaque;
        case CKA_BASE:
            return type_opaque;
        case CKA_VALUE_BITS:
            return type_long;
        case CKA_VALUE_LEN:
            return type_long;
        case CKA_EXTRACTABLE:
            return type_byte;
        case CKA_LOCAL:
            return type_byte;
        case CKA_NEVER_EXTRACTABLE:
            return type_byte;
        case CKA_ALWAYS_SENSITIVE:
            return type_byte;
        case CKA_MODIFIABLE:
            return type_byte;
        case CKA_NETSCAPE_URL:
            return type_opaque;
        case CKA_NETSCAPE_EMAIL:
            return type_opaque;
        case CKA_NETSCAPE_SMIME_INFO:
            return type_opaque;
        case CKA_NETSCAPE_SMIME_TIMESTAMP:
            return type_opaque;
        case CKA_NETSCAPE_PKCS8_SALT:
            return type_opaque;
        case CKA_NETSCAPE_PASSWORD_CHECK:
            return type_opaque;
        case CKA_NETSCAPE_EXPIRES:
            return type_opaque;
        case CKA_TRUST_DIGITAL_SIGNATURE:
            return type_long;
        case CKA_TRUST_NON_REPUDIATION:
            return type_long;
        case CKA_TRUST_KEY_ENCIPHERMENT:
            return type_long;
        case CKA_TRUST_DATA_ENCIPHERMENT:
            return type_long;
        case CKA_TRUST_KEY_AGREEMENT:
            return type_long;
        case CKA_TRUST_KEY_CERT_SIGN:
            return type_long;
        case CKA_TRUST_CRL_SIGN:
            return type_long;
        case CKA_TRUST_SERVER_AUTH:
            return type_long;
        case CKA_TRUST_CLIENT_AUTH:
            return type_long;
        case CKA_TRUST_CODE_SIGNING:
            return type_long;
        case CKA_TRUST_EMAIL_PROTECTION:
            return type_long;
        case CKA_TRUST_IPSEC_END_SYSTEM:
            return type_long;
        case CKA_TRUST_IPSEC_TUNNEL:
            return type_long;
        case CKA_TRUST_IPSEC_USER:
            return type_long;
        case CKA_TRUST_TIME_STAMPING:
            return type_long;
        case CKA_NETSCAPE_DB:
            return type_opaque;
        case CKA_NETSCAPE_TRUST:
            return type_opaque;
        default:
            return type_opaque;
    }
}

static void
nss_dbm_db_swap_copy(
    CK_ATTRIBUTE_TYPE type,
    void *dest,
    void *src,
    CK_ULONG len)
{
    switch (nss_dbm_db_swap_type(type)) {
        case type_byte:
        case type_opaque:
            (void)memcpy(dest, src, len);
            break;
        case type_short: {
            CK_USHORT s, d;
            (void)memcpy(&s, src, sizeof(CK_USHORT));
            d = htons(s);
            (void)memcpy(dest, &d, sizeof(CK_USHORT));
            break;
        }
        case type_long: {
            CK_ULONG s, d;
            (void)memcpy(&s, src, sizeof(CK_ULONG));
            d = htonl(s);
            (void)memcpy(dest, &d, sizeof(CK_ULONG));
            break;
        }
    }
}

static CK_RV
nss_dbm_db_wrap_object(
    NSSArena *arena,
    CK_ATTRIBUTE_PTR pTemplate,
    CK_ULONG ulAttributeCount,
    DBT *object)
{
    CK_ULONG object_size;
    CK_ULONG i;
    CK_ULONG *pulData;
    char *pcData;
    CK_ULONG offset;

    object_size = (1 + ulAttributeCount * 3) * sizeof(CK_ULONG);
    offset = object_size;
    for (i = 0; i < ulAttributeCount; i++) {
        object_size += pTemplate[i].ulValueLen;
    }

    object->size = object_size;
    object->data = nss_ZAlloc(arena, object_size);
    if ((void *)NULL == object->data) {
        return CKR_HOST_MEMORY;
    }

    pulData = (CK_ULONG *)object->data;
    pcData = (char *)object->data;

    pulData[0] = htonl(ulAttributeCount);
    for (i = 0; i < ulAttributeCount; i++) {
        CK_ULONG len = pTemplate[i].ulValueLen;
        pulData[1 + i * 3] = htonl(pTemplate[i].type);
        pulData[2 + i * 3] = htonl(len);
        pulData[3 + i * 3] = htonl(offset);
        nss_dbm_db_swap_copy(pTemplate[i].type, &pcData[offset], pTemplate[i].pValue, len);
        offset += len;
    }

    return CKR_OK;
}

static CK_RV
nss_dbm_db_unwrap_object(
    NSSArena *arena,
    DBT *object,
    CK_ATTRIBUTE_PTR *ppTemplate,
    CK_ULONG *pulAttributeCount)
{
    CK_ULONG *pulData;
    char *pcData;
    CK_ULONG n, i;
    CK_ATTRIBUTE_PTR pTemplate;

    pulData = (CK_ULONG *)object->data;
    pcData = (char *)object->data;

    n = ntohl(pulData[0]);
    *pulAttributeCount = n;
    pTemplate = nss_ZNEWARRAY(arena, CK_ATTRIBUTE, n);
    if ((CK_ATTRIBUTE_PTR)NULL == pTemplate) {
        return CKR_HOST_MEMORY;
    }

    for (i = 0; i < n; i++) {
        CK_ULONG len;
        CK_ULONG offset;
        void *p;

        pTemplate[i].type = ntohl(pulData[1 + i * 3]);
        len = ntohl(pulData[2 + i * 3]);
        offset = ntohl(pulData[3 + i * 3]);

        p = nss_ZAlloc(arena, len);
        if ((void *)NULL == p) {
            return CKR_HOST_MEMORY;
        }

        nss_dbm_db_swap_copy(pTemplate[i].type, p, &pcData[offset], len);
        pTemplate[i].ulValueLen = len;
        pTemplate[i].pValue = p;
    }

    *ppTemplate = pTemplate;
    return CKR_OK;
}

NSS_IMPLEMENT nss_dbm_dbt_t *
nss_dbm_db_create_object(
    NSSArena *arena,
    nss_dbm_db_t *db,
    CK_ATTRIBUTE_PTR pTemplate,
    CK_ULONG ulAttributeCount,
    CK_RV *pError,
    CK_ULONG *pdbrv)
{
    NSSArena *tmparena = (NSSArena *)NULL;
    nss_dbm_dbt_t *rv = (nss_dbm_dbt_t *)NULL;
    DBT object;

    rv = nss_ZNEW(arena, nss_dbm_dbt_t);
    if ((nss_dbm_dbt_t *)NULL == rv) {
        *pError = CKR_HOST_MEMORY;
        return (nss_dbm_dbt_t *)NULL;
    }

    rv->my_db = db;
    rv->dbt.size = sizeof(struct handle);
    rv->dbt.data = nss_ZAlloc(arena, rv->dbt.size);
    if ((void *)NULL == rv->dbt.data) {
        *pError = CKR_HOST_MEMORY;
        return (nss_dbm_dbt_t *)NULL;
    }

    *pdbrv = nss_dbm_db_new_handle(db, &rv->dbt, pError);
    if (0 != *pdbrv) {
        return (nss_dbm_dbt_t *)NULL;
    }

    tmparena = NSSArena_Create();
    if ((NSSArena *)NULL == tmparena) {
        *pError = CKR_HOST_MEMORY;
        return (nss_dbm_dbt_t *)NULL;
    }

    *pError = nss_dbm_db_wrap_object(tmparena, pTemplate, ulAttributeCount, &object);
    if (CKR_OK != *pError) {
        return (nss_dbm_dbt_t *)NULL;
    }

    /* Locked region */
    {
        *pError = NSSCKFWMutex_Lock(db->crustylock);
        if (CKR_OK != *pError) {
            goto loser;
        }

        *pdbrv = db->db->put(db->db, &rv->dbt, &object, 0);
        if (0 != *pdbrv) {
            *pError = CKR_DEVICE_ERROR;
        }

        (void)db->db->sync(db->db, 0);

        (void)NSSCKFWMutex_Unlock(db->crustylock);
    }

loser:
    if ((NSSArena *)NULL != tmparena) {
        (void)NSSArena_Destroy(tmparena);
    }

    return rv;
}

NSS_IMPLEMENT CK_RV
nss_dbm_db_find_objects(
    nss_dbm_find_t *find,
    nss_dbm_db_t *db,
    CK_ATTRIBUTE_PTR pTemplate,
    CK_ULONG ulAttributeCount,
    CK_ULONG *pdbrv)
{
    CK_RV rv = CKR_OK;

    if ((nss_dbm_db_t *)NULL != db) {
        DBT k, v;

        rv = NSSCKFWMutex_Lock(db->crustylock);
        if (CKR_OK != rv) {
            return rv;
        }

        *pdbrv = db->db->seq(db->db, &k, &v, R_FIRST);
        while (0 == *pdbrv) {
            CK_ULONG i, j;
            NSSArena *tmparena = (NSSArena *)NULL;
            CK_ULONG ulac;
            CK_ATTRIBUTE_PTR pt;

            if ((k.size < 4) || (0 != memcmp(k.data, PREFIX_OBJECT, 4))) {
                goto nomatch;
            }

            tmparena = NSSArena_Create();

            rv = nss_dbm_db_unwrap_object(tmparena, &v, &pt, &ulac);
            if (CKR_OK != rv) {
                goto loser;
            }

            for (i = 0; i < ulAttributeCount; i++) {
                for (j = 0; j < ulac; j++) {
                    if (pTemplate[i].type ==
                        pt[j].type) {
                        if (pTemplate[i].ulValueLen !=
                            pt[j].ulValueLen) {
                            goto nomatch;
                        }
                        if (0 !=
                            memcmp(pTemplate[i].pValue, pt[j].pValue, pt[j].ulValueLen)) {
                            goto nomatch;
                        }
                        break;
                    }
                }
                if (j == ulac) {
                    goto nomatch;
                }
            }

            /* entire template matches */
            {
                struct nss_dbm_dbt_node *node;

                node = nss_ZNEW(find->arena, struct nss_dbm_dbt_node);
                if ((struct nss_dbm_dbt_node *)NULL == node) {
                    rv =
                        CKR_HOST_MEMORY;
                    goto loser;
                }

                node->dbt = nss_ZNEW(find->arena, nss_dbm_dbt_t);
                if ((nss_dbm_dbt_t *)NULL == node->dbt) {
                    rv =
                        CKR_HOST_MEMORY;
                    goto loser;
                }

                node->dbt->dbt.size = k.size;
                node->dbt->dbt.data = nss_ZAlloc(find->arena, k.size);
                if ((void *)NULL == node->dbt->dbt.data) {
                    rv =
                        CKR_HOST_MEMORY;
                    goto loser;
                }

                (void)memcpy(node->dbt->dbt.data, k.data, k.size);

                node->dbt->my_db = db;

                node->next = find->found;
                find->found = node;
            }

        nomatch:
            if ((NSSArena *)NULL != tmparena) {
                (void)NSSArena_Destroy(tmparena);
            }
            *pdbrv = db->db->seq(db->db, &k, &v, R_NEXT);
        }

        if (*pdbrv < 0) {
            rv = CKR_DEVICE_ERROR;
            goto loser;
        }

        rv = CKR_OK;

    loser:
        (void)NSSCKFWMutex_Unlock(db->crustylock);
    }

    return rv;
}

NSS_IMPLEMENT CK_BBOOL
nss_dbm_db_object_still_exists(
    nss_dbm_dbt_t *dbt)
{
    CK_BBOOL rv;
    CK_RV ckrv;
    int dbrv;
    DBT object;

    ckrv = NSSCKFWMutex_Lock(dbt->my_db->crustylock);
    if (CKR_OK != ckrv) {
        return CK_FALSE;
    }

    dbrv = dbt->my_db->db->get(dbt->my_db->db, &dbt->dbt, &object, 0);
    if (0 == dbrv) {
        rv = CK_TRUE;
    } else {
        rv = CK_FALSE;
    }

    (void)NSSCKFWMutex_Unlock(dbt->my_db->crustylock);

    return rv;
}

NSS_IMPLEMENT CK_ULONG
nss_dbm_db_get_object_attribute_count(
    nss_dbm_dbt_t *dbt,
    CK_RV *pError,
    CK_ULONG *pdbrv)
{
    CK_ULONG rv = 0;
    DBT object;
    CK_ULONG *pulData;

    /* Locked region */
    {
        *pError = NSSCKFWMutex_Lock(dbt->my_db->crustylock);
        if (CKR_OK != *pError) {
            return rv;
        }

        *pdbrv = dbt->my_db->db->get(dbt->my_db->db, &dbt->dbt, &object, 0);
        if (0 == *pdbrv) {
            ;
        } else if (*pdbrv > 0) {
            *pError = CKR_OBJECT_HANDLE_INVALID;
            goto done;
        } else {
            *pError = CKR_DEVICE_ERROR;
            goto done;
        }

        pulData = (CK_ULONG *)object.data;
        rv = ntohl(pulData[0]);

    done:
        (void)NSSCKFWMutex_Unlock(dbt->my_db->crustylock);
    }

    return rv;
}

NSS_IMPLEMENT CK_RV
nss_dbm_db_get_object_attribute_types(
    nss_dbm_dbt_t *dbt,
    CK_ATTRIBUTE_TYPE_PTR typeArray,
    CK_ULONG ulCount,
    CK_ULONG *pdbrv)
{
    CK_RV rv = CKR_OK;
    DBT object;
    CK_ULONG *pulData;
    CK_ULONG n, i;

    /* Locked region */
    {
        rv = NSSCKFWMutex_Lock(dbt->my_db->crustylock);
        if (CKR_OK != rv) {
            return rv;
        }

        *pdbrv = dbt->my_db->db->get(dbt->my_db->db, &dbt->dbt, &object, 0);
        if (0 == *pdbrv) {
            ;
        } else if (*pdbrv > 0) {
            rv = CKR_OBJECT_HANDLE_INVALID;
            goto done;
        } else {
            rv = CKR_DEVICE_ERROR;
            goto done;
        }

        pulData = (CK_ULONG *)object.data;
        n = ntohl(pulData[0]);

        if (ulCount < n) {
            rv = CKR_BUFFER_TOO_SMALL;
            goto done;
        }

        for (i = 0; i < n; i++) {
            typeArray[i] = ntohl(pulData[1 + i * 3]);
        }

    done:
        (void)NSSCKFWMutex_Unlock(dbt->my_db->crustylock);
    }

    return rv;
}

NSS_IMPLEMENT CK_ULONG
nss_dbm_db_get_object_attribute_size(
    nss_dbm_dbt_t *dbt,
    CK_ATTRIBUTE_TYPE type,
    CK_RV *pError,
    CK_ULONG *pdbrv)
{
    CK_ULONG rv = 0;
    DBT object;
    CK_ULONG *pulData;
    CK_ULONG n, i;

    /* Locked region */
    {
        *pError = NSSCKFWMutex_Lock(dbt->my_db->crustylock);
        if (CKR_OK != *pError) {
            return rv;
        }

        *pdbrv = dbt->my_db->db->get(dbt->my_db->db, &dbt->dbt, &object, 0);
        if (0 == *pdbrv) {
            ;
        } else if (*pdbrv > 0) {
            *pError = CKR_OBJECT_HANDLE_INVALID;
            goto done;
        } else {
            *pError = CKR_DEVICE_ERROR;
            goto done;
        }

        pulData = (CK_ULONG *)object.data;
        n = ntohl(pulData[0]);

        for (i = 0; i < n; i++) {
            if (type == ntohl(pulData[1 + i * 3])) {
                rv = ntohl(pulData[2 + i * 3]);
            }
        }

        if (i == n) {
            *pError = CKR_ATTRIBUTE_TYPE_INVALID;
            goto done;
        }

    done:
        (void)NSSCKFWMutex_Unlock(dbt->my_db->crustylock);
    }

    return rv;
}

NSS_IMPLEMENT NSSItem *
nss_dbm_db_get_object_attribute(
    nss_dbm_dbt_t *dbt,
    NSSArena *arena,
    CK_ATTRIBUTE_TYPE type,
    CK_RV *pError,
    CK_ULONG *pdbrv)
{
    NSSItem *rv = (NSSItem *)NULL;
    DBT object;
    CK_ULONG i;
    NSSArena *tmp = NSSArena_Create();
    CK_ATTRIBUTE_PTR pTemplate;
    CK_ULONG ulAttributeCount;

    /* Locked region */
    {
        *pError = NSSCKFWMutex_Lock(dbt->my_db->crustylock);
        if (CKR_OK != *pError) {
            goto loser;
        }

        *pdbrv = dbt->my_db->db->get(dbt->my_db->db, &dbt->dbt, &object, 0);
        if (0 == *pdbrv) {
            ;
        } else if (*pdbrv > 0) {
            *pError = CKR_OBJECT_HANDLE_INVALID;
            goto done;
        } else {
            *pError = CKR_DEVICE_ERROR;
            goto done;
        }

        *pError = nss_dbm_db_unwrap_object(tmp, &object, &pTemplate, &ulAttributeCount);
        if (CKR_OK != *pError) {
            goto done;
        }

        for (i = 0; i < ulAttributeCount; i++) {
            if (type == pTemplate[i].type) {
                rv = nss_ZNEW(arena, NSSItem);
                if ((NSSItem *)NULL == rv) {
                    *pError =
                        CKR_HOST_MEMORY;
                    goto done;
                }
                rv->size = pTemplate[i].ulValueLen;
                rv->data = nss_ZAlloc(arena, rv->size);
                if ((void *)NULL == rv->data) {
                    *pError =
                        CKR_HOST_MEMORY;
                    goto done;
                }
                (void)memcpy(rv->data, pTemplate[i].pValue, rv->size);
                break;
            }
        }
        if (ulAttributeCount == i) {
            *pError = CKR_ATTRIBUTE_TYPE_INVALID;
            goto done;
        }

    done:
        (void)NSSCKFWMutex_Unlock(dbt->my_db->crustylock);
    }

loser:
    if ((NSSArena *)NULL != tmp) {
        NSSArena_Destroy(tmp);
    }

    return rv;
}

NSS_IMPLEMENT CK_RV
nss_dbm_db_set_object_attribute(
    nss_dbm_dbt_t *dbt,
    CK_ATTRIBUTE_TYPE type,
    NSSItem *value,
    CK_ULONG *pdbrv)
{
    CK_RV rv = CKR_OK;
    DBT object;
    CK_ULONG i;
    NSSArena *tmp = NSSArena_Create();
    CK_ATTRIBUTE_PTR pTemplate;
    CK_ULONG ulAttributeCount;

    /* Locked region */
    {
        rv = NSSCKFWMutex_Lock(dbt->my_db->crustylock);
        if (CKR_OK != rv) {
            goto loser;
        }

        *pdbrv = dbt->my_db->db->get(dbt->my_db->db, &dbt->dbt, &object, 0);
        if (0 == *pdbrv) {
            ;
        } else if (*pdbrv > 0) {
            rv = CKR_OBJECT_HANDLE_INVALID;
            goto done;
        } else {
            rv = CKR_DEVICE_ERROR;
            goto done;
        }

        rv = nss_dbm_db_unwrap_object(tmp, &object, &pTemplate, &ulAttributeCount);
        if (CKR_OK != rv) {
            goto done;
        }

        for (i = 0; i < ulAttributeCount; i++) {
            if (type == pTemplate[i].type) {
                /* Replacing an existing attribute */
                pTemplate[i].ulValueLen = value->size;
                pTemplate[i].pValue = value->data;
                break;
            }
        }

        if (i == ulAttributeCount) {
            /* Adding a new attribute */
            CK_ATTRIBUTE_PTR npt = nss_ZNEWARRAY(tmp, CK_ATTRIBUTE, ulAttributeCount + 1);
            if ((CK_ATTRIBUTE_PTR)NULL == npt) {
                rv = CKR_DEVICE_ERROR;
                goto done;
            }

            for (i = 0; i < ulAttributeCount; i++) {
                npt[i] = pTemplate[i];
            }

            npt[ulAttributeCount].type = type;
            npt[ulAttributeCount].ulValueLen = value->size;
            npt[ulAttributeCount].pValue = value->data;

            pTemplate = npt;
            ulAttributeCount++;
        }

        rv = nss_dbm_db_wrap_object(tmp, pTemplate, ulAttributeCount, &object);
        if (CKR_OK != rv) {
            goto done;
        }

        *pdbrv = dbt->my_db->db->put(dbt->my_db->db, &dbt->dbt, &object, 0);
        if (0 != *pdbrv) {
            rv = CKR_DEVICE_ERROR;
            goto done;
        }

        (void)dbt->my_db->db->sync(dbt->my_db->db, 0);

    done:
        (void)NSSCKFWMutex_Unlock(dbt->my_db->crustylock);
    }

loser:
    if ((NSSArena *)NULL != tmp) {
        NSSArena_Destroy(tmp);
    }

    return rv;
}