db.c

来自「支持SSL v2/v3, TLS, PKCS #5, PKCS #7, PKCS」· C语言 代码 · 共 1,066 行 · 第 1/2 页

    
    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;
}