1069 lines
26 KiB
C
1069 lines
26 KiB
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_NSS_URL:
|
|
return type_opaque;
|
|
case CKA_NSS_EMAIL:
|
|
return type_opaque;
|
|
case CKA_NSS_SMIME_INFO:
|
|
return type_opaque;
|
|
case CKA_NSS_SMIME_TIMESTAMP:
|
|
return type_opaque;
|
|
case CKA_NSS_PKCS8_SALT:
|
|
return type_opaque;
|
|
case CKA_NSS_PASSWORD_CHECK:
|
|
return type_opaque;
|
|
case CKA_NSS_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_NSS_DB:
|
|
return type_opaque;
|
|
case CKA_NSS_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;
|
|
}
|