#include <string.h>
#include <openssl/bn.h>
#include <openssl/err.h>
+#ifndef OPENSSL_NO_ENGINE
#include <openssl/engine.h>
+#endif
+#include <openssl/sha.h>
+#include <openssl/x509.h>
#include "str_locl.h"
const char * const STORE_object_type_string[STORE_OBJECT_TYPE_NUM+1] =
"X.509 CRL",
"Private Key",
"Public Key",
- "Number"
+ "Number",
+ "Arbitrary Data"
};
const int STORE_param_sizes[STORE_PARAM_TYPE_NUM+1] =
{
STORE *ret;
- ret=(STORE *)OPENSSL_malloc(sizeof(STORE));
- if (ret == NULL)
+ if (method == NULL)
{
- STOREerr(STORE_F_STORE_NEW_METHOD,ERR_R_MALLOC_FAILURE);
+ STOREerr(STORE_F_STORE_NEW_METHOD,ERR_R_PASSED_NULL_PARAMETER);
return NULL;
}
- if (method == NULL)
+
+ ret=(STORE *)OPENSSL_malloc(sizeof(STORE));
+ if (ret == NULL)
{
- STOREerr(STORE_F_STORE_NEW_METHOD,ERR_R_PASSED_NULL_PARAMETER);
+ STOREerr(STORE_F_STORE_NEW_METHOD,ERR_R_MALLOC_FAILURE);
return NULL;
}
- else
- ret->meth=method;
+
+ ret->meth=method;
CRYPTO_new_ex_data(CRYPTO_EX_INDEX_STORE, ret, &ret->ex_data);
if (ret->meth->init && !ret->meth->init(ret))
OPENSSL_free(store);
}
+int STORE_ctrl(STORE *store, int cmd, long i, void *p, void (*f)(void))
+ {
+ if (store == NULL)
+ {
+ STOREerr(STORE_F_STORE_CTRL,ERR_R_PASSED_NULL_PARAMETER);
+ return 0;
+ }
+ if (store->meth->ctrl)
+ return store->meth->ctrl(store, cmd, i, p, f);
+ STOREerr(STORE_F_STORE_CTRL,STORE_R_NO_CONTROL_FUNCTION);
+ return 0;
+ }
+
int STORE_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
#define check_store(s,fncode,fnname,fnerrcode) \
do \
{ \
- if ((s) == NULL || (s)->meth) \
+ if ((s) == NULL || (s)->meth == NULL) \
{ \
STOREerr((fncode), ERR_R_PASSED_NULL_PARAMETER); \
return 0; \
int STORE_store_certificate(STORE *s, X509 *data, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[])
{
- STORE_OBJECT *object = STORE_OBJECT_new();
+ STORE_OBJECT *object;
int i;
check_store(s,STORE_F_STORE_CERTIFICATE,
store_object,STORE_R_NO_STORE_OBJECT_FUNCTION);
+ object = STORE_OBJECT_new();
if (!object)
{
- STOREerr(STORE_F_STORE_CERTIFICATE,
+ STOREerr(STORE_F_STORE_STORE_CERTIFICATE,
ERR_R_MALLOC_FAILURE);
return 0;
}
if (!i)
{
- STOREerr(STORE_F_STORE_CERTIFICATE,
+ STOREerr(STORE_F_STORE_STORE_CERTIFICATE,
STORE_R_FAILED_STORING_CERTIFICATE);
return 0;
}
return 1;
}
+int STORE_modify_certificate(STORE *s, OPENSSL_ITEM search_attributes[],
+ OPENSSL_ITEM add_attributes[], OPENSSL_ITEM modify_attributes[],
+ OPENSSL_ITEM delete_attributes[], OPENSSL_ITEM parameters[])
+ {
+ check_store(s,STORE_F_STORE_MODIFY_CERTIFICATE,
+ modify_object,STORE_R_NO_MODIFY_OBJECT_FUNCTION);
+
+ if (!s->meth->modify_object(s, STORE_OBJECT_TYPE_X509_CERTIFICATE,
+ search_attributes, add_attributes, modify_attributes,
+ delete_attributes, parameters))
+ {
+ STOREerr(STORE_F_STORE_MODIFY_CERTIFICATE,
+ STORE_R_FAILED_MODIFYING_CERTIFICATE);
+ return 0;
+ }
+ return 1;
+ }
+
int STORE_revoke_certificate(STORE *s, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[])
{
int STORE_store_private_key(STORE *s, EVP_PKEY *data, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[])
{
- STORE_OBJECT *object = STORE_OBJECT_new();
+ STORE_OBJECT *object;
int i;
- check_store(s,STORE_F_STORE_PRIVATE_KEY,
+ check_store(s,STORE_F_STORE_STORE_PRIVATE_KEY,
store_object,STORE_R_NO_STORE_OBJECT_FUNCTION);
+ object = STORE_OBJECT_new();
if (!object)
{
- STOREerr(STORE_F_STORE_PRIVATE_KEY,
+ STOREerr(STORE_F_STORE_STORE_PRIVATE_KEY,
ERR_R_MALLOC_FAILURE);
return 0;
}
object->data.key = EVP_PKEY_new();
if (!object->data.key)
{
- STOREerr(STORE_F_STORE_PRIVATE_KEY,
+ STOREerr(STORE_F_STORE_STORE_PRIVATE_KEY,
ERR_R_MALLOC_FAILURE);
return 0;
}
if (!i)
{
- STOREerr(STORE_F_STORE_PRIVATE_KEY,
+ STOREerr(STORE_F_STORE_STORE_PRIVATE_KEY,
STORE_R_FAILED_STORING_KEY);
return 0;
}
return i;
}
+int STORE_modify_private_key(STORE *s, OPENSSL_ITEM search_attributes[],
+ OPENSSL_ITEM add_attributes[], OPENSSL_ITEM modify_attributes[],
+ OPENSSL_ITEM delete_attributes[], OPENSSL_ITEM parameters[])
+ {
+ check_store(s,STORE_F_STORE_MODIFY_PRIVATE_KEY,
+ modify_object,STORE_R_NO_MODIFY_OBJECT_FUNCTION);
+
+ if (!s->meth->modify_object(s, STORE_OBJECT_TYPE_PRIVATE_KEY,
+ search_attributes, add_attributes, modify_attributes,
+ delete_attributes, parameters))
+ {
+ STOREerr(STORE_F_STORE_MODIFY_PRIVATE_KEY,
+ STORE_R_FAILED_MODIFYING_PRIVATE_KEY);
+ return 0;
+ }
+ return 1;
+ }
+
int STORE_revoke_private_key(STORE *s, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[])
{
int STORE_store_public_key(STORE *s, EVP_PKEY *data, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[])
{
- STORE_OBJECT *object = STORE_OBJECT_new();
+ STORE_OBJECT *object;
int i;
- check_store(s,STORE_F_STORE_PUBLIC_KEY,
+ check_store(s,STORE_F_STORE_STORE_PUBLIC_KEY,
store_object,STORE_R_NO_STORE_OBJECT_FUNCTION);
+ object = STORE_OBJECT_new();
if (!object)
{
- STOREerr(STORE_F_STORE_PUBLIC_KEY,
+ STOREerr(STORE_F_STORE_STORE_PUBLIC_KEY,
ERR_R_MALLOC_FAILURE);
return 0;
}
object->data.key = EVP_PKEY_new();
if (!object->data.key)
{
- STOREerr(STORE_F_STORE_PUBLIC_KEY,
+ STOREerr(STORE_F_STORE_STORE_PUBLIC_KEY,
ERR_R_MALLOC_FAILURE);
return 0;
}
if (!i)
{
- STOREerr(STORE_F_STORE_PUBLIC_KEY,
+ STOREerr(STORE_F_STORE_STORE_PUBLIC_KEY,
STORE_R_FAILED_STORING_KEY);
return 0;
}
return i;
}
+int STORE_modify_public_key(STORE *s, OPENSSL_ITEM search_attributes[],
+ OPENSSL_ITEM add_attributes[], OPENSSL_ITEM modify_attributes[],
+ OPENSSL_ITEM delete_attributes[], OPENSSL_ITEM parameters[])
+ {
+ check_store(s,STORE_F_STORE_MODIFY_PUBLIC_KEY,
+ modify_object,STORE_R_NO_MODIFY_OBJECT_FUNCTION);
+
+ if (!s->meth->modify_object(s, STORE_OBJECT_TYPE_PUBLIC_KEY,
+ search_attributes, add_attributes, modify_attributes,
+ delete_attributes, parameters))
+ {
+ STOREerr(STORE_F_STORE_MODIFY_PUBLIC_KEY,
+ STORE_R_FAILED_MODIFYING_PUBLIC_KEY);
+ return 0;
+ }
+ return 1;
+ }
+
int STORE_revoke_public_key(STORE *s, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[])
{
int STORE_store_crl(STORE *s, X509_CRL *data, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[])
{
- STORE_OBJECT *object = STORE_OBJECT_new();
+ STORE_OBJECT *object;
int i;
- check_store(s,STORE_F_STORE_CRL,
+ check_store(s,STORE_F_STORE_STORE_CRL,
store_object,STORE_R_NO_STORE_OBJECT_FUNCTION);
+ object = STORE_OBJECT_new();
if (!object)
{
- STOREerr(STORE_F_STORE_CRL,
+ STOREerr(STORE_F_STORE_STORE_CRL,
ERR_R_MALLOC_FAILURE);
return 0;
}
if (!i)
{
- STOREerr(STORE_F_STORE_CRL,
+ STOREerr(STORE_F_STORE_STORE_CRL,
STORE_R_FAILED_STORING_KEY);
return 0;
}
return i;
}
+int STORE_modify_crl(STORE *s, OPENSSL_ITEM search_attributes[],
+ OPENSSL_ITEM add_attributes[], OPENSSL_ITEM modify_attributes[],
+ OPENSSL_ITEM delete_attributes[], OPENSSL_ITEM parameters[])
+ {
+ check_store(s,STORE_F_STORE_MODIFY_CRL,
+ modify_object,STORE_R_NO_MODIFY_OBJECT_FUNCTION);
+
+ if (!s->meth->modify_object(s, STORE_OBJECT_TYPE_X509_CRL,
+ search_attributes, add_attributes, modify_attributes,
+ delete_attributes, parameters))
+ {
+ STOREerr(STORE_F_STORE_MODIFY_CRL,
+ STORE_R_FAILED_MODIFYING_CRL);
+ return 0;
+ }
+ return 1;
+ }
+
int STORE_delete_crl(STORE *s, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[])
{
int STORE_store_number(STORE *s, BIGNUM *data, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[])
{
- STORE_OBJECT *object = STORE_OBJECT_new();
+ STORE_OBJECT *object;
int i;
- check_store(s,STORE_F_STORE_NUMBER,
+ check_store(s,STORE_F_STORE_STORE_NUMBER,
store_object,STORE_R_NO_STORE_OBJECT_NUMBER_FUNCTION);
+ object = STORE_OBJECT_new();
if (!object)
{
- STOREerr(STORE_F_STORE_NUMBER,
+ STOREerr(STORE_F_STORE_STORE_NUMBER,
ERR_R_MALLOC_FAILURE);
return 0;
}
if (!i)
{
- STOREerr(STORE_F_STORE_NUMBER,
+ STOREerr(STORE_F_STORE_STORE_NUMBER,
STORE_R_FAILED_STORING_NUMBER);
return 0;
}
return 1;
}
+int STORE_modify_number(STORE *s, OPENSSL_ITEM search_attributes[],
+ OPENSSL_ITEM add_attributes[], OPENSSL_ITEM modify_attributes[],
+ OPENSSL_ITEM delete_attributes[], OPENSSL_ITEM parameters[])
+ {
+ check_store(s,STORE_F_STORE_MODIFY_NUMBER,
+ modify_object,STORE_R_NO_MODIFY_OBJECT_FUNCTION);
+
+ if (!s->meth->modify_object(s, STORE_OBJECT_TYPE_NUMBER,
+ search_attributes, add_attributes, modify_attributes,
+ delete_attributes, parameters))
+ {
+ STOREerr(STORE_F_STORE_MODIFY_NUMBER,
+ STORE_R_FAILED_MODIFYING_NUMBER);
+ return 0;
+ }
+ return 1;
+ }
+
BIGNUM *STORE_get_number(STORE *s, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[])
{
int STORE_store_arbitrary(STORE *s, BUF_MEM *data, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[])
{
- STORE_OBJECT *object = STORE_OBJECT_new();
+ STORE_OBJECT *object;
int i;
- check_store(s,STORE_F_STORE_ARBITRARY,
+ check_store(s,STORE_F_STORE_STORE_ARBITRARY,
store_object,STORE_R_NO_STORE_OBJECT_ARBITRARY_FUNCTION);
+ object = STORE_OBJECT_new();
if (!object)
{
- STOREerr(STORE_F_STORE_ARBITRARY,
+ STOREerr(STORE_F_STORE_STORE_ARBITRARY,
ERR_R_MALLOC_FAILURE);
return 0;
}
if (!i)
{
- STOREerr(STORE_F_STORE_ARBITRARY,
+ STOREerr(STORE_F_STORE_STORE_ARBITRARY,
STORE_R_FAILED_STORING_ARBITRARY);
return 0;
}
return 1;
}
+int STORE_modify_arbitrary(STORE *s, OPENSSL_ITEM search_attributes[],
+ OPENSSL_ITEM add_attributes[], OPENSSL_ITEM modify_attributes[],
+ OPENSSL_ITEM delete_attributes[], OPENSSL_ITEM parameters[])
+ {
+ check_store(s,STORE_F_STORE_MODIFY_ARBITRARY,
+ modify_object,STORE_R_NO_MODIFY_OBJECT_FUNCTION);
+
+ if (!s->meth->modify_object(s, STORE_OBJECT_TYPE_ARBITRARY,
+ search_attributes, add_attributes, modify_attributes,
+ delete_attributes, parameters))
+ {
+ STOREerr(STORE_F_STORE_MODIFY_ARBITRARY,
+ STORE_R_FAILED_MODIFYING_ARBITRARY);
+ return 0;
+ }
+ return 1;
+ }
+
BUF_MEM *STORE_get_arbitrary(STORE *s, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[])
{
(unsigned char *)BUF_memdup(sha1str,
sha1str_size)))
return 1;
- STOREerr(STORE_F_STORE_ATTR_INFO_SET_CSTR,
+ STOREerr(STORE_F_STORE_ATTR_INFO_SET_SHA1STR,
ERR_R_MALLOC_FAILURE);
return 0;
}
{
if ((attrs->values[code].dn = X509_NAME_dup(dn)))
return 1;
- STOREerr(STORE_F_STORE_ATTR_INFO_SET_CSTR,
+ STOREerr(STORE_F_STORE_ATTR_INFO_SET_DN,
ERR_R_MALLOC_FAILURE);
return 0;
}
{
if ((attrs->values[code].number = BN_dup(number)))
return 1;
- STOREerr(STORE_F_STORE_ATTR_INFO_SET_CSTR,
+ STOREerr(STORE_F_STORE_ATTR_INFO_SET_NUMBER,
ERR_R_MALLOC_FAILURE);
return 0;
}
if (context)
context->attributes = attributes;
else
- STOREerr(STORE_F_STORE_PARSE_ATTRS_END,
+ STOREerr(STORE_F_STORE_PARSE_ATTRS_START,
ERR_R_MALLOC_FAILURE);
return context;
}
- STOREerr(STORE_F_STORE_PARSE_ATTRS_END, ERR_R_PASSED_NULL_PARAMETER);
+ STOREerr(STORE_F_STORE_PARSE_ATTRS_START, ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
STORE_ATTR_INFO *STORE_parse_attrs_next(void *handle)
{
return context->attributes->code == STORE_ATTR_END;
}
- STOREerr(STORE_F_STORE_PARSE_ATTRS_END, ERR_R_PASSED_NULL_PARAMETER);
+ STOREerr(STORE_F_STORE_PARSE_ATTRS_ENDP, ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
static int attr_info_compare_compute_range(
- unsigned char *abits, unsigned char *bbits,
+ const unsigned char *abits, const unsigned char *bbits,
unsigned int *alowp, unsigned int *ahighp,
unsigned int *blowp, unsigned int *bhighp)
{
return res;
}
-int STORE_ATTR_INFO_compare(STORE_ATTR_INFO *a, STORE_ATTR_INFO *b)
+int STORE_ATTR_INFO_compare(const STORE_ATTR_INFO * const *a,
+ const STORE_ATTR_INFO * const *b)
{
if (a == b) return 0;
if (!a) return -1;
if (!b) return 1;
- return attr_info_compare_compute_range(a->set, b->set, 0, 0, 0, 0);
+ return attr_info_compare_compute_range((*a)->set, (*b)->set, 0, 0, 0, 0);
}
+
int STORE_ATTR_INFO_in_range(STORE_ATTR_INFO *a, STORE_ATTR_INFO *b)
{
unsigned int alow, ahigh, blow, bhigh;
return 1;
return 0;
}
+
int STORE_ATTR_INFO_in(STORE_ATTR_INFO *a, STORE_ATTR_INFO *b)
{
unsigned char *abits, *bbits;
}
return 1;
}
+
int STORE_ATTR_INFO_in_ex(STORE_ATTR_INFO *a, STORE_ATTR_INFO *b)
{
STORE_ATTR_TYPES i;