Wrap the inclusion of openssl/engine.h with a protective check for

[openssl.git] / crypto / store / str_lib.c

diff --git a/crypto/store/str_lib.c b/crypto/store/str_lib.c
index 5e6e424ba34aac6438ca0cd261022041afc8b841..c0ad763e9a1cc4068f03e97a61e54891681a4c83 100644 (file)
--- a/crypto/store/str_lib.c
+++ b/crypto/store/str_lib.c
@@ -59,7 +59,11 @@
 #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] =
@@ -184,6 +188,19 @@ void STORE_free(STORE *store)
        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)
@@ -272,7 +289,7 @@ int STORE_store_certificate(STORE *s, X509 *data, OPENSSL_ITEM attributes[],
        object = STORE_OBJECT_new();
        if (!object)
                {
-               STOREerr(STORE_F_STORE_CERTIFICATE,
+               STOREerr(STORE_F_STORE_STORE_CERTIFICATE,
                        ERR_R_MALLOC_FAILURE);
                return 0;
                }
@@ -290,13 +307,31 @@ int STORE_store_certificate(STORE *s, X509 *data, OPENSSL_ITEM attributes[],
 
        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[])
        {
@@ -458,20 +493,20 @@ int STORE_store_private_key(STORE *s, EVP_PKEY *data, OPENSSL_ITEM attributes[],
        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;
                }
@@ -489,13 +524,31 @@ int STORE_store_private_key(STORE *s, EVP_PKEY *data, OPENSSL_ITEM attributes[],
 
        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[])
        {
@@ -635,20 +688,20 @@ int STORE_store_public_key(STORE *s, EVP_PKEY *data, OPENSSL_ITEM attributes[],
        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;
                }
@@ -666,13 +719,31 @@ int STORE_store_public_key(STORE *s, EVP_PKEY *data, OPENSSL_ITEM attributes[],
 
        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[])
        {
@@ -838,13 +909,13 @@ int STORE_store_crl(STORE *s, X509_CRL *data, OPENSSL_ITEM attributes[],
        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;
                }
@@ -862,13 +933,31 @@ int STORE_store_crl(STORE *s, X509_CRL *data, OPENSSL_ITEM attributes[],
 
        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[])
        {
@@ -962,13 +1051,13 @@ int STORE_store_number(STORE *s, BIGNUM *data, OPENSSL_ITEM attributes[],
        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;
                }
@@ -982,13 +1071,31 @@ int STORE_store_number(STORE *s, BIGNUM *data, OPENSSL_ITEM attributes[],
 
        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[])
        {
@@ -1034,13 +1141,13 @@ int STORE_store_arbitrary(STORE *s, BUF_MEM *data, OPENSSL_ITEM attributes[],
        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;
                }
@@ -1054,13 +1161,31 @@ int STORE_store_arbitrary(STORE *s, BUF_MEM *data, OPENSSL_ITEM attributes[],
 
        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[])
        {
@@ -1291,7 +1416,7 @@ int STORE_ATTR_INFO_set_sha1str(STORE_ATTR_INFO *attrs, STORE_ATTR_TYPES code,
                            (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;
                }
@@ -1311,7 +1436,7 @@ int STORE_ATTR_INFO_set_dn(STORE_ATTR_INFO *attrs, STORE_ATTR_TYPES code,
                {
                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;
                }
@@ -1331,7 +1456,7 @@ int STORE_ATTR_INFO_set_number(STORE_ATTR_INFO *attrs, STORE_ATTR_TYPES code,
                {
                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;
                }
@@ -1420,11 +1545,11 @@ void *STORE_parse_attrs_start(OPENSSL_ITEM *attributes)
                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)
@@ -1540,7 +1665,7 @@ int STORE_parse_attrs_endp(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;
        }