v4.39-9772-betav4.39-9772-beta

1 files changed, 373 insertions, 131 deletions

diff --git a/src/Mayaqua/win32_inc/openssl/asn1.h b/src/Mayaqua/win32_inc/openssl/asn1.h
index ead8df5a..c91c908c 100644
--- a/src/Mayaqua/win32_inc/openssl/asn1.h
+++ b/src/Mayaqua/win32_inc/openssl/asn1.h
@@ -1,14 +1,25 @@
 /*

- * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.

+ * WARNING: do not edit!

+ * Generated by makefile from include\openssl\asn1.h.in

  *

- * Licensed under the OpenSSL license (the "License").  You may not use

+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.

+ *

+ * Licensed under the Apache License 2.0 (the "License").  You may not use

  * this file except in compliance with the License.  You can obtain a copy

  * in the file LICENSE in the source distribution or at

  * https://www.openssl.org/source/license.html

  */

 

-#ifndef HEADER_ASN1_H

-# define HEADER_ASN1_H

+

+

+#ifndef OPENSSL_ASN1_H

+# define OPENSSL_ASN1_H

+# pragma once

+

+# include <openssl/macros.h>

+# ifndef OPENSSL_NO_DEPRECATED_3_0

+#  define HEADER_ASN1_H

+# endif

 

 # include <time.h>

 # include <openssl/e_os2.h>

@@ -18,10 +29,8 @@
 # include <openssl/asn1err.h>

 # include <openssl/symhacks.h>

 

-# include <openssl/ossl_typ.h>

-# if OPENSSL_API_COMPAT < 0x10100000L

-#  include <openssl/bn.h>

-# endif

+# include <openssl/types.h>

+# include <openssl/bn.h>

 

 # ifdef OPENSSL_BUILD_SHLIBCRYPTO

 #  undef OPENSSL_EXTERN

@@ -115,8 +124,36 @@ extern "C" {
 # define SMIME_OLDMIME           0x400

 # define SMIME_CRLFEOL           0x800

 # define SMIME_STREAM            0x1000

-    struct X509_algor_st;

-DEFINE_STACK_OF(X509_ALGOR)

+

+/* Stacks for types not otherwise defined in this header */

+SKM_DEFINE_STACK_OF_INTERNAL(X509_ALGOR, X509_ALGOR, X509_ALGOR)

+#define sk_X509_ALGOR_num(sk) OPENSSL_sk_num(ossl_check_const_X509_ALGOR_sk_type(sk))

+#define sk_X509_ALGOR_value(sk, idx) ((X509_ALGOR *)OPENSSL_sk_value(ossl_check_const_X509_ALGOR_sk_type(sk), (idx)))

+#define sk_X509_ALGOR_new(cmp) ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_new(ossl_check_X509_ALGOR_compfunc_type(cmp)))

+#define sk_X509_ALGOR_new_null() ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_new_null())

+#define sk_X509_ALGOR_new_reserve(cmp, n) ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_new_reserve(ossl_check_X509_ALGOR_compfunc_type(cmp), (n)))

+#define sk_X509_ALGOR_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_X509_ALGOR_sk_type(sk), (n))

+#define sk_X509_ALGOR_free(sk) OPENSSL_sk_free(ossl_check_X509_ALGOR_sk_type(sk))

+#define sk_X509_ALGOR_zero(sk) OPENSSL_sk_zero(ossl_check_X509_ALGOR_sk_type(sk))

+#define sk_X509_ALGOR_delete(sk, i) ((X509_ALGOR *)OPENSSL_sk_delete(ossl_check_X509_ALGOR_sk_type(sk), (i)))

+#define sk_X509_ALGOR_delete_ptr(sk, ptr) ((X509_ALGOR *)OPENSSL_sk_delete_ptr(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr)))

+#define sk_X509_ALGOR_push(sk, ptr) OPENSSL_sk_push(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr))

+#define sk_X509_ALGOR_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr))

+#define sk_X509_ALGOR_pop(sk) ((X509_ALGOR *)OPENSSL_sk_pop(ossl_check_X509_ALGOR_sk_type(sk)))

+#define sk_X509_ALGOR_shift(sk) ((X509_ALGOR *)OPENSSL_sk_shift(ossl_check_X509_ALGOR_sk_type(sk)))

+#define sk_X509_ALGOR_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_X509_ALGOR_sk_type(sk),ossl_check_X509_ALGOR_freefunc_type(freefunc))

+#define sk_X509_ALGOR_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr), (idx))

+#define sk_X509_ALGOR_set(sk, idx, ptr) ((X509_ALGOR *)OPENSSL_sk_set(ossl_check_X509_ALGOR_sk_type(sk), (idx), ossl_check_X509_ALGOR_type(ptr)))

+#define sk_X509_ALGOR_find(sk, ptr) OPENSSL_sk_find(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr))

+#define sk_X509_ALGOR_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr))

+#define sk_X509_ALGOR_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_type(ptr), pnum)

+#define sk_X509_ALGOR_sort(sk) OPENSSL_sk_sort(ossl_check_X509_ALGOR_sk_type(sk))

+#define sk_X509_ALGOR_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_X509_ALGOR_sk_type(sk))

+#define sk_X509_ALGOR_dup(sk) ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_dup(ossl_check_const_X509_ALGOR_sk_type(sk)))

+#define sk_X509_ALGOR_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(X509_ALGOR) *)OPENSSL_sk_deep_copy(ossl_check_const_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_copyfunc_type(copyfunc), ossl_check_X509_ALGOR_freefunc_type(freefunc)))

+#define sk_X509_ALGOR_set_cmp_func(sk, cmp) ((sk_X509_ALGOR_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_X509_ALGOR_sk_type(sk), ossl_check_X509_ALGOR_compfunc_type(cmp)))

+

+

 

 # define ASN1_STRING_FLAG_BITS_LEFT 0x08/* Set if 0x07 has bits left value */

 /*

@@ -183,15 +220,41 @@ typedef struct ASN1_ENCODING_st {
  (B_ASN1_PRINTABLESTRING|B_ASN1_T61STRING|B_ASN1_BMPSTRING|B_ASN1_UTF8STRING)

 # define PKCS9STRING_TYPE (DIRSTRING_TYPE|B_ASN1_IA5STRING)

 

-typedef struct asn1_string_table_st {

+struct asn1_string_table_st {

     int nid;

     long minsize;

     long maxsize;

     unsigned long mask;

     unsigned long flags;

-} ASN1_STRING_TABLE;

+};

+

+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_STRING_TABLE, ASN1_STRING_TABLE, ASN1_STRING_TABLE)

+#define sk_ASN1_STRING_TABLE_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk))

+#define sk_ASN1_STRING_TABLE_value(sk, idx) ((ASN1_STRING_TABLE *)OPENSSL_sk_value(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk), (idx)))

+#define sk_ASN1_STRING_TABLE_new(cmp) ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_new(ossl_check_ASN1_STRING_TABLE_compfunc_type(cmp)))

+#define sk_ASN1_STRING_TABLE_new_null() ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_new_null())

+#define sk_ASN1_STRING_TABLE_new_reserve(cmp, n) ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_STRING_TABLE_compfunc_type(cmp), (n)))

+#define sk_ASN1_STRING_TABLE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_STRING_TABLE_sk_type(sk), (n))

+#define sk_ASN1_STRING_TABLE_free(sk) OPENSSL_sk_free(ossl_check_ASN1_STRING_TABLE_sk_type(sk))

+#define sk_ASN1_STRING_TABLE_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_STRING_TABLE_sk_type(sk))

+#define sk_ASN1_STRING_TABLE_delete(sk, i) ((ASN1_STRING_TABLE *)OPENSSL_sk_delete(ossl_check_ASN1_STRING_TABLE_sk_type(sk), (i)))

+#define sk_ASN1_STRING_TABLE_delete_ptr(sk, ptr) ((ASN1_STRING_TABLE *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr)))

+#define sk_ASN1_STRING_TABLE_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr))

+#define sk_ASN1_STRING_TABLE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr))

+#define sk_ASN1_STRING_TABLE_pop(sk) ((ASN1_STRING_TABLE *)OPENSSL_sk_pop(ossl_check_ASN1_STRING_TABLE_sk_type(sk)))

+#define sk_ASN1_STRING_TABLE_shift(sk) ((ASN1_STRING_TABLE *)OPENSSL_sk_shift(ossl_check_ASN1_STRING_TABLE_sk_type(sk)))

+#define sk_ASN1_STRING_TABLE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_STRING_TABLE_sk_type(sk),ossl_check_ASN1_STRING_TABLE_freefunc_type(freefunc))

+#define sk_ASN1_STRING_TABLE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr), (idx))

+#define sk_ASN1_STRING_TABLE_set(sk, idx, ptr) ((ASN1_STRING_TABLE *)OPENSSL_sk_set(ossl_check_ASN1_STRING_TABLE_sk_type(sk), (idx), ossl_check_ASN1_STRING_TABLE_type(ptr)))

+#define sk_ASN1_STRING_TABLE_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr))

+#define sk_ASN1_STRING_TABLE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr))

+#define sk_ASN1_STRING_TABLE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_type(ptr), pnum)

+#define sk_ASN1_STRING_TABLE_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_STRING_TABLE_sk_type(sk))

+#define sk_ASN1_STRING_TABLE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk))

+#define sk_ASN1_STRING_TABLE_dup(sk) ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_dup(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk)))

+#define sk_ASN1_STRING_TABLE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_STRING_TABLE) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_copyfunc_type(copyfunc), ossl_check_ASN1_STRING_TABLE_freefunc_type(freefunc)))

+#define sk_ASN1_STRING_TABLE_set_cmp_func(sk, cmp) ((sk_ASN1_STRING_TABLE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_STRING_TABLE_sk_type(sk), ossl_check_ASN1_STRING_TABLE_compfunc_type(cmp)))

 

-DEFINE_STACK_OF(ASN1_STRING_TABLE)

 

 /* size limits: this stuff is taken straight from RFC2459 */

 

@@ -214,50 +277,79 @@ typedef struct ASN1_VALUE_st ASN1_VALUE;
 

 /* Declare ASN1 functions: the implement macro in in asn1t.h */

 

-# define DECLARE_ASN1_FUNCTIONS(type) DECLARE_ASN1_FUNCTIONS_name(type, type)

-

-# define DECLARE_ASN1_ALLOC_FUNCTIONS(type) \

-        DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, type)

-

-# define DECLARE_ASN1_FUNCTIONS_name(type, name) \

-        DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \

-        DECLARE_ASN1_ENCODE_FUNCTIONS(type, name, name)

-

-# define DECLARE_ASN1_FUNCTIONS_fname(type, itname, name) \

-        DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \

-        DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name)

-

-# define DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name) \

-        type *d2i_##name(type **a, const unsigned char **in, long len); \

-        int i2d_##name(type *a, unsigned char **out); \

-        DECLARE_ASN1_ITEM(itname)

-

-# define DECLARE_ASN1_ENCODE_FUNCTIONS_const(type, name) \

-        type *d2i_##name(type **a, const unsigned char **in, long len); \

-        int i2d_##name(const type *a, unsigned char **out); \

-        DECLARE_ASN1_ITEM(name)

-

-# define DECLARE_ASN1_NDEF_FUNCTION(name) \

-        int i2d_##name##_NDEF(name *a, unsigned char **out);

-

-# define DECLARE_ASN1_FUNCTIONS_const(name) \

-        DECLARE_ASN1_ALLOC_FUNCTIONS(name) \

-        DECLARE_ASN1_ENCODE_FUNCTIONS_const(name, name)

-

-# define DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \

-        type *name##_new(void); \

-        void name##_free(type *a);

-

-# define DECLARE_ASN1_PRINT_FUNCTION(stname) \

-        DECLARE_ASN1_PRINT_FUNCTION_fname(stname, stname)

+/*

+ * The mysterious 'extern' that's passed to some macros is innocuous,

+ * and is there to quiet pre-C99 compilers that may complain about empty

+ * arguments in macro calls.

+ */

 

-# define DECLARE_ASN1_PRINT_FUNCTION_fname(stname, fname) \

-        int fname##_print_ctx(BIO *out, stname *x, int indent, \

-                                         const ASN1_PCTX *pctx);

+# define DECLARE_ASN1_FUNCTIONS_attr(attr, type)                            \

+    DECLARE_ASN1_FUNCTIONS_name_attr(attr, type, type)

+# define DECLARE_ASN1_FUNCTIONS(type)                                       \

+    DECLARE_ASN1_FUNCTIONS_attr(extern, type)

+

+# define DECLARE_ASN1_ALLOC_FUNCTIONS_attr(attr, type)                      \

+    DECLARE_ASN1_ALLOC_FUNCTIONS_name_attr(attr, type, type)

+# define DECLARE_ASN1_ALLOC_FUNCTIONS(type)                                 \

+    DECLARE_ASN1_ALLOC_FUNCTIONS_attr(extern, type)

+

+# define DECLARE_ASN1_FUNCTIONS_name_attr(attr, type, name)                 \

+    DECLARE_ASN1_ALLOC_FUNCTIONS_name_attr(attr, type, name)                \

+    DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(attr, type, name)

+# define DECLARE_ASN1_FUNCTIONS_name(type, name)                            \

+    DECLARE_ASN1_FUNCTIONS_name_attr(extern, type, name)

+

+# define DECLARE_ASN1_ENCODE_FUNCTIONS_attr(attr, type, itname, name)       \

+    DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(attr, type, name)               \

+    DECLARE_ASN1_ITEM_attr(attr, itname)

+# define DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name)                  \

+    DECLARE_ASN1_ENCODE_FUNCTIONS_attr(extern, type, itname, name)

+

+# define DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(attr, type, name)          \

+    DECLARE_ASN1_ENCODE_FUNCTIONS_attr(attr, type, name, name)

+# define DECLARE_ASN1_ENCODE_FUNCTIONS_name(type, name) \

+    DECLARE_ASN1_ENCODE_FUNCTIONS_name_attr(extern, type, name)

+

+# define DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(attr, type, name)          \

+    attr type *d2i_##name(type **a, const unsigned char **in, long len);    \

+    attr int i2d_##name(const type *a, unsigned char **out);

+# define DECLARE_ASN1_ENCODE_FUNCTIONS_only(type, name)                     \

+    DECLARE_ASN1_ENCODE_FUNCTIONS_only_attr(extern, type, name)

+

+# define DECLARE_ASN1_NDEF_FUNCTION_attr(attr, name)                        \

+    attr int i2d_##name##_NDEF(const name *a, unsigned char **out);

+# define DECLARE_ASN1_NDEF_FUNCTION(name)                                   \

+    DECLARE_ASN1_NDEF_FUNCTION_attr(extern, name)

+

+# define DECLARE_ASN1_ALLOC_FUNCTIONS_name_attr(attr, type, name)           \

+    attr type *name##_new(void);                                            \

+    attr void name##_free(type *a);

+# define DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name)                      \

+    DECLARE_ASN1_ALLOC_FUNCTIONS_name_attr(extern, type, name)

+

+# define DECLARE_ASN1_DUP_FUNCTION_attr(attr, type)                         \

+    DECLARE_ASN1_DUP_FUNCTION_name_attr(attr, type, type)

+# define DECLARE_ASN1_DUP_FUNCTION(type)                                    \

+    DECLARE_ASN1_DUP_FUNCTION_attr(extern, type)

+

+# define DECLARE_ASN1_DUP_FUNCTION_name_attr(attr, type, name)              \

+    attr type *name##_dup(const type *a);

+# define DECLARE_ASN1_DUP_FUNCTION_name(type, name)                         \

+    DECLARE_ASN1_DUP_FUNCTION_name_attr(extern, type, name)

+

+# define DECLARE_ASN1_PRINT_FUNCTION_attr(attr, stname)                     \

+    DECLARE_ASN1_PRINT_FUNCTION_fname_attr(attr, stname, stname)

+# define DECLARE_ASN1_PRINT_FUNCTION(stname)                                \

+    DECLARE_ASN1_PRINT_FUNCTION_attr(extern, stname)

+

+# define DECLARE_ASN1_PRINT_FUNCTION_fname_attr(attr, stname, fname)        \

+    attr int fname##_print_ctx(BIO *out, const stname *x, int indent,       \

+                               const ASN1_PCTX *pctx);

+# define DECLARE_ASN1_PRINT_FUNCTION_fname(stname, fname)                   \

+    DECLARE_ASN1_PRINT_FUNCTION_fname_attr(extern, stname, fname)

 

 # define D2I_OF(type) type *(*)(type **,const unsigned char **,long)

-# define I2D_OF(type) int (*)(type *,unsigned char **)

-# define I2D_OF_const(type) int (*)(const type *,unsigned char **)

+# define I2D_OF(type) int (*)(const type *,unsigned char **)

 

 # define CHECKED_D2I_OF(type, d2i) \

     ((d2i_of_void*) (1 ? d2i : ((D2I_OF(type))0)))

@@ -271,10 +363,11 @@ typedef struct ASN1_VALUE_st ASN1_VALUE;
     ((void**) (1 ? p : (type**)0))

 

 # define TYPEDEF_D2I_OF(type) typedef type *d2i_of_##type(type **,const unsigned char **,long)

-# define TYPEDEF_I2D_OF(type) typedef int i2d_of_##type(type *,unsigned char **)

+# define TYPEDEF_I2D_OF(type) typedef int i2d_of_##type(const type *,unsigned char **)

 # define TYPEDEF_D2I2D_OF(type) TYPEDEF_D2I_OF(type); TYPEDEF_I2D_OF(type)

 

-TYPEDEF_D2I2D_OF(void);

+typedef void *d2i_of_void(void **, const unsigned char **, long);

+typedef int i2d_of_void(const void *, unsigned char **);

 

 /*-

  * The following macros and typedefs allow an ASN1_ITEM

@@ -312,23 +405,6 @@ TYPEDEF_D2I2D_OF(void);
  *

  */

 

-# ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION

-

-/* ASN1_ITEM pointer exported type */

-typedef const ASN1_ITEM ASN1_ITEM_EXP;

-

-/* Macro to obtain ASN1_ITEM pointer from exported type */

-#  define ASN1_ITEM_ptr(iptr) (iptr)

-

-/* Macro to include ASN1_ITEM pointer from base type */

-#  define ASN1_ITEM_ref(iptr) (&(iptr##_it))

-

-#  define ASN1_ITEM_rptr(ref) (&(ref##_it))

-

-#  define DECLARE_ASN1_ITEM(name) \

-        OPENSSL_EXTERN const ASN1_ITEM name##_it;

-

-# else

 

 /*

  * Platforms that can't easily handle shared global variables are declared as

@@ -339,17 +415,17 @@ typedef const ASN1_ITEM ASN1_ITEM_EXP;
 typedef const ASN1_ITEM *ASN1_ITEM_EXP (void);

 

 /* Macro to obtain ASN1_ITEM pointer from exported type */

-#  define ASN1_ITEM_ptr(iptr) (iptr())

+# define ASN1_ITEM_ptr(iptr) (iptr())

 

 /* Macro to include ASN1_ITEM pointer from base type */

-#  define ASN1_ITEM_ref(iptr) (iptr##_it)

+# define ASN1_ITEM_ref(iptr) (iptr##_it)

 

-#  define ASN1_ITEM_rptr(ref) (ref##_it())

+# define ASN1_ITEM_rptr(ref) (ref##_it())

 

-#  define DECLARE_ASN1_ITEM(name) \

-        const ASN1_ITEM * name##_it(void);

-

-# endif

+# define DECLARE_ASN1_ITEM_attr(attr, name)                                 \

+    attr const ASN1_ITEM * name##_it(void);

+# define DECLARE_ASN1_ITEM(name)                                            \

+    DECLARE_ASN1_ITEM_attr(extern, name)

 

 /* Parameters used by ASN1_STRING_print_ex() */

 

@@ -362,6 +438,11 @@ typedef const ASN1_ITEM *ASN1_ITEM_EXP (void);
 # define ASN1_STRFLGS_ESC_CTRL           2

 # define ASN1_STRFLGS_ESC_MSB            4

 

+/* Lower 8 bits are reserved as an output type specifier */

+# define ASN1_DTFLGS_TYPE_MASK    0x0FUL

+# define ASN1_DTFLGS_RFC822       0x00UL

+# define ASN1_DTFLGS_ISO8601      0x01UL

+

 /*

  * This flag determines how we do escaping: normally RC2253 backslash only,

  * set this to use backslash and quote.

@@ -435,13 +516,8 @@ typedef const ASN1_ITEM *ASN1_ITEM_EXP (void);
                                 ASN1_STRFLGS_DUMP_UNKNOWN | \

                                 ASN1_STRFLGS_DUMP_DER)

 

-DEFINE_STACK_OF(ASN1_INTEGER)

-

-DEFINE_STACK_OF(ASN1_GENERALSTRING)

 

-DEFINE_STACK_OF(ASN1_UTF8STRING)

-

-typedef struct asn1_type_st {

+struct asn1_type_st {

     int type;

     union {

         char *ptr;

@@ -470,14 +546,40 @@ typedef struct asn1_type_st {
         ASN1_STRING *sequence;

         ASN1_VALUE *asn1_value;

     } value;

-} ASN1_TYPE;

+};

+

+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_TYPE, ASN1_TYPE, ASN1_TYPE)

+#define sk_ASN1_TYPE_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_TYPE_sk_type(sk))

+#define sk_ASN1_TYPE_value(sk, idx) ((ASN1_TYPE *)OPENSSL_sk_value(ossl_check_const_ASN1_TYPE_sk_type(sk), (idx)))

+#define sk_ASN1_TYPE_new(cmp) ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_new(ossl_check_ASN1_TYPE_compfunc_type(cmp)))

+#define sk_ASN1_TYPE_new_null() ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_new_null())

+#define sk_ASN1_TYPE_new_reserve(cmp, n) ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_TYPE_compfunc_type(cmp), (n)))

+#define sk_ASN1_TYPE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_TYPE_sk_type(sk), (n))

+#define sk_ASN1_TYPE_free(sk) OPENSSL_sk_free(ossl_check_ASN1_TYPE_sk_type(sk))

+#define sk_ASN1_TYPE_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_TYPE_sk_type(sk))

+#define sk_ASN1_TYPE_delete(sk, i) ((ASN1_TYPE *)OPENSSL_sk_delete(ossl_check_ASN1_TYPE_sk_type(sk), (i)))

+#define sk_ASN1_TYPE_delete_ptr(sk, ptr) ((ASN1_TYPE *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr)))

+#define sk_ASN1_TYPE_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr))

+#define sk_ASN1_TYPE_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr))

+#define sk_ASN1_TYPE_pop(sk) ((ASN1_TYPE *)OPENSSL_sk_pop(ossl_check_ASN1_TYPE_sk_type(sk)))

+#define sk_ASN1_TYPE_shift(sk) ((ASN1_TYPE *)OPENSSL_sk_shift(ossl_check_ASN1_TYPE_sk_type(sk)))

+#define sk_ASN1_TYPE_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_TYPE_sk_type(sk),ossl_check_ASN1_TYPE_freefunc_type(freefunc))

+#define sk_ASN1_TYPE_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr), (idx))

+#define sk_ASN1_TYPE_set(sk, idx, ptr) ((ASN1_TYPE *)OPENSSL_sk_set(ossl_check_ASN1_TYPE_sk_type(sk), (idx), ossl_check_ASN1_TYPE_type(ptr)))

+#define sk_ASN1_TYPE_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr))

+#define sk_ASN1_TYPE_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr))

+#define sk_ASN1_TYPE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_type(ptr), pnum)

+#define sk_ASN1_TYPE_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_TYPE_sk_type(sk))

+#define sk_ASN1_TYPE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_TYPE_sk_type(sk))

+#define sk_ASN1_TYPE_dup(sk) ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_dup(ossl_check_const_ASN1_TYPE_sk_type(sk)))

+#define sk_ASN1_TYPE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_TYPE) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_copyfunc_type(copyfunc), ossl_check_ASN1_TYPE_freefunc_type(freefunc)))

+#define sk_ASN1_TYPE_set_cmp_func(sk, cmp) ((sk_ASN1_TYPE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_TYPE_sk_type(sk), ossl_check_ASN1_TYPE_compfunc_type(cmp)))

 

-DEFINE_STACK_OF(ASN1_TYPE)

 

 typedef STACK_OF(ASN1_TYPE) ASN1_SEQUENCE_ANY;

 

-DECLARE_ASN1_ENCODE_FUNCTIONS_const(ASN1_SEQUENCE_ANY, ASN1_SEQUENCE_ANY)

-DECLARE_ASN1_ENCODE_FUNCTIONS_const(ASN1_SEQUENCE_ANY, ASN1_SET_ANY)

+DECLARE_ASN1_ENCODE_FUNCTIONS_name(ASN1_SEQUENCE_ANY, ASN1_SEQUENCE_ANY)

+DECLARE_ASN1_ENCODE_FUNCTIONS_name(ASN1_SEQUENCE_ANY, ASN1_SET_ANY)

 

 /* This is used to contain a list of bit names */

 typedef struct BIT_STRING_BITNAME_st {

@@ -515,7 +617,8 @@ typedef struct BIT_STRING_BITNAME_st {
                         B_ASN1_BMPSTRING|\

                         B_ASN1_UTF8STRING

 

-DECLARE_ASN1_FUNCTIONS_fname(ASN1_TYPE, ASN1_ANY, ASN1_TYPE)

+DECLARE_ASN1_ALLOC_FUNCTIONS_name(ASN1_TYPE, ASN1_TYPE)

+DECLARE_ASN1_ENCODE_FUNCTIONS(ASN1_TYPE, ASN1_ANY, ASN1_TYPE)

 

 int ASN1_TYPE_get(const ASN1_TYPE *a);

 void ASN1_TYPE_set(ASN1_TYPE *a, int type, void *value);

@@ -525,21 +628,41 @@ int ASN1_TYPE_cmp(const ASN1_TYPE *a, const ASN1_TYPE *b);
 ASN1_TYPE *ASN1_TYPE_pack_sequence(const ASN1_ITEM *it, void *s, ASN1_TYPE **t);

 void *ASN1_TYPE_unpack_sequence(const ASN1_ITEM *it, const ASN1_TYPE *t);

 

-ASN1_OBJECT *ASN1_OBJECT_new(void);

-void ASN1_OBJECT_free(ASN1_OBJECT *a);

-int i2d_ASN1_OBJECT(const ASN1_OBJECT *a, unsigned char **pp);

-ASN1_OBJECT *d2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp,

-                             long length);

-

-DECLARE_ASN1_ITEM(ASN1_OBJECT)

-

-DEFINE_STACK_OF(ASN1_OBJECT)

+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_OBJECT, ASN1_OBJECT, ASN1_OBJECT)

+#define sk_ASN1_OBJECT_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_OBJECT_sk_type(sk))

+#define sk_ASN1_OBJECT_value(sk, idx) ((ASN1_OBJECT *)OPENSSL_sk_value(ossl_check_const_ASN1_OBJECT_sk_type(sk), (idx)))

+#define sk_ASN1_OBJECT_new(cmp) ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_new(ossl_check_ASN1_OBJECT_compfunc_type(cmp)))

+#define sk_ASN1_OBJECT_new_null() ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_new_null())

+#define sk_ASN1_OBJECT_new_reserve(cmp, n) ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_OBJECT_compfunc_type(cmp), (n)))

+#define sk_ASN1_OBJECT_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_OBJECT_sk_type(sk), (n))

+#define sk_ASN1_OBJECT_free(sk) OPENSSL_sk_free(ossl_check_ASN1_OBJECT_sk_type(sk))

+#define sk_ASN1_OBJECT_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_OBJECT_sk_type(sk))

+#define sk_ASN1_OBJECT_delete(sk, i) ((ASN1_OBJECT *)OPENSSL_sk_delete(ossl_check_ASN1_OBJECT_sk_type(sk), (i)))

+#define sk_ASN1_OBJECT_delete_ptr(sk, ptr) ((ASN1_OBJECT *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr)))

+#define sk_ASN1_OBJECT_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr))

+#define sk_ASN1_OBJECT_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr))

+#define sk_ASN1_OBJECT_pop(sk) ((ASN1_OBJECT *)OPENSSL_sk_pop(ossl_check_ASN1_OBJECT_sk_type(sk)))

+#define sk_ASN1_OBJECT_shift(sk) ((ASN1_OBJECT *)OPENSSL_sk_shift(ossl_check_ASN1_OBJECT_sk_type(sk)))

+#define sk_ASN1_OBJECT_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_OBJECT_sk_type(sk),ossl_check_ASN1_OBJECT_freefunc_type(freefunc))

+#define sk_ASN1_OBJECT_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr), (idx))

+#define sk_ASN1_OBJECT_set(sk, idx, ptr) ((ASN1_OBJECT *)OPENSSL_sk_set(ossl_check_ASN1_OBJECT_sk_type(sk), (idx), ossl_check_ASN1_OBJECT_type(ptr)))

+#define sk_ASN1_OBJECT_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr))

+#define sk_ASN1_OBJECT_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr))

+#define sk_ASN1_OBJECT_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_type(ptr), pnum)

+#define sk_ASN1_OBJECT_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_OBJECT_sk_type(sk))

+#define sk_ASN1_OBJECT_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_OBJECT_sk_type(sk))

+#define sk_ASN1_OBJECT_dup(sk) ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_dup(ossl_check_const_ASN1_OBJECT_sk_type(sk)))

+#define sk_ASN1_OBJECT_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_OBJECT) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_copyfunc_type(copyfunc), ossl_check_ASN1_OBJECT_freefunc_type(freefunc)))

+#define sk_ASN1_OBJECT_set_cmp_func(sk, cmp) ((sk_ASN1_OBJECT_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_OBJECT_sk_type(sk), ossl_check_ASN1_OBJECT_compfunc_type(cmp)))

+

+

+DECLARE_ASN1_FUNCTIONS(ASN1_OBJECT)

 

 ASN1_STRING *ASN1_STRING_new(void);

 void ASN1_STRING_free(ASN1_STRING *a);

 void ASN1_STRING_clear_free(ASN1_STRING *a);

 int ASN1_STRING_copy(ASN1_STRING *dst, const ASN1_STRING *str);

-ASN1_STRING *ASN1_STRING_dup(const ASN1_STRING *a);

+DECLARE_ASN1_DUP_FUNCTION(ASN1_STRING)

 ASN1_STRING *ASN1_STRING_type_new(int type);

 int ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b);

   /*

@@ -549,9 +672,13 @@ int ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b);
 int ASN1_STRING_set(ASN1_STRING *str, const void *data, int len);

 void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len);

 int ASN1_STRING_length(const ASN1_STRING *x);

-void ASN1_STRING_length_set(ASN1_STRING *x, int n);

+# ifndef OPENSSL_NO_DEPRECATED_3_0

+OSSL_DEPRECATEDIN_3_0 void ASN1_STRING_length_set(ASN1_STRING *x, int n);

+# endif

 int ASN1_STRING_type(const ASN1_STRING *x);

-DEPRECATEDIN_1_1_0(unsigned char *ASN1_STRING_data(ASN1_STRING *x))

+# ifndef OPENSSL_NO_DEPRECATED_1_1_0

+OSSL_DEPRECATEDIN_1_1_0 unsigned char *ASN1_STRING_data(ASN1_STRING *x);

+# endif

 const unsigned char *ASN1_STRING_get0_data(const ASN1_STRING *x);

 

 DECLARE_ASN1_FUNCTIONS(ASN1_BIT_STRING)

@@ -567,10 +694,39 @@ int ASN1_BIT_STRING_num_asc(const char *name, BIT_STRING_BITNAME *tbl);
 int ASN1_BIT_STRING_set_asc(ASN1_BIT_STRING *bs, const char *name, int value,

                             BIT_STRING_BITNAME *tbl);

 

+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_INTEGER, ASN1_INTEGER, ASN1_INTEGER)

+#define sk_ASN1_INTEGER_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_INTEGER_sk_type(sk))

+#define sk_ASN1_INTEGER_value(sk, idx) ((ASN1_INTEGER *)OPENSSL_sk_value(ossl_check_const_ASN1_INTEGER_sk_type(sk), (idx)))

+#define sk_ASN1_INTEGER_new(cmp) ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_new(ossl_check_ASN1_INTEGER_compfunc_type(cmp)))

+#define sk_ASN1_INTEGER_new_null() ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_new_null())

+#define sk_ASN1_INTEGER_new_reserve(cmp, n) ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_INTEGER_compfunc_type(cmp), (n)))

+#define sk_ASN1_INTEGER_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_INTEGER_sk_type(sk), (n))

+#define sk_ASN1_INTEGER_free(sk) OPENSSL_sk_free(ossl_check_ASN1_INTEGER_sk_type(sk))

+#define sk_ASN1_INTEGER_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_INTEGER_sk_type(sk))

+#define sk_ASN1_INTEGER_delete(sk, i) ((ASN1_INTEGER *)OPENSSL_sk_delete(ossl_check_ASN1_INTEGER_sk_type(sk), (i)))

+#define sk_ASN1_INTEGER_delete_ptr(sk, ptr) ((ASN1_INTEGER *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr)))

+#define sk_ASN1_INTEGER_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr))

+#define sk_ASN1_INTEGER_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr))

+#define sk_ASN1_INTEGER_pop(sk) ((ASN1_INTEGER *)OPENSSL_sk_pop(ossl_check_ASN1_INTEGER_sk_type(sk)))

+#define sk_ASN1_INTEGER_shift(sk) ((ASN1_INTEGER *)OPENSSL_sk_shift(ossl_check_ASN1_INTEGER_sk_type(sk)))

+#define sk_ASN1_INTEGER_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_INTEGER_sk_type(sk),ossl_check_ASN1_INTEGER_freefunc_type(freefunc))

+#define sk_ASN1_INTEGER_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr), (idx))

+#define sk_ASN1_INTEGER_set(sk, idx, ptr) ((ASN1_INTEGER *)OPENSSL_sk_set(ossl_check_ASN1_INTEGER_sk_type(sk), (idx), ossl_check_ASN1_INTEGER_type(ptr)))

+#define sk_ASN1_INTEGER_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr))

+#define sk_ASN1_INTEGER_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr))

+#define sk_ASN1_INTEGER_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_type(ptr), pnum)

+#define sk_ASN1_INTEGER_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_INTEGER_sk_type(sk))

+#define sk_ASN1_INTEGER_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_INTEGER_sk_type(sk))

+#define sk_ASN1_INTEGER_dup(sk) ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_dup(ossl_check_const_ASN1_INTEGER_sk_type(sk)))

+#define sk_ASN1_INTEGER_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_INTEGER) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_copyfunc_type(copyfunc), ossl_check_ASN1_INTEGER_freefunc_type(freefunc)))

+#define sk_ASN1_INTEGER_set_cmp_func(sk, cmp) ((sk_ASN1_INTEGER_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_INTEGER_sk_type(sk), ossl_check_ASN1_INTEGER_compfunc_type(cmp)))

+

+

+

 DECLARE_ASN1_FUNCTIONS(ASN1_INTEGER)

 ASN1_INTEGER *d2i_ASN1_UINTEGER(ASN1_INTEGER **a, const unsigned char **pp,

                                 long length);

-ASN1_INTEGER *ASN1_INTEGER_dup(const ASN1_INTEGER *x);

+DECLARE_ASN1_DUP_FUNCTION(ASN1_INTEGER)

 int ASN1_INTEGER_cmp(const ASN1_INTEGER *x, const ASN1_INTEGER *y);

 

 DECLARE_ASN1_FUNCTIONS(ASN1_ENUMERATED)

@@ -594,12 +750,40 @@ int ASN1_TIME_diff(int *pday, int *psec,
                    const ASN1_TIME *from, const ASN1_TIME *to);

 

 DECLARE_ASN1_FUNCTIONS(ASN1_OCTET_STRING)

-ASN1_OCTET_STRING *ASN1_OCTET_STRING_dup(const ASN1_OCTET_STRING *a);

+DECLARE_ASN1_DUP_FUNCTION(ASN1_OCTET_STRING)

 int ASN1_OCTET_STRING_cmp(const ASN1_OCTET_STRING *a,

                           const ASN1_OCTET_STRING *b);

 int ASN1_OCTET_STRING_set(ASN1_OCTET_STRING *str, const unsigned char *data,

                           int len);

 

+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_UTF8STRING, ASN1_UTF8STRING, ASN1_UTF8STRING)

+#define sk_ASN1_UTF8STRING_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_UTF8STRING_sk_type(sk))

+#define sk_ASN1_UTF8STRING_value(sk, idx) ((ASN1_UTF8STRING *)OPENSSL_sk_value(ossl_check_const_ASN1_UTF8STRING_sk_type(sk), (idx)))

+#define sk_ASN1_UTF8STRING_new(cmp) ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_new(ossl_check_ASN1_UTF8STRING_compfunc_type(cmp)))

+#define sk_ASN1_UTF8STRING_new_null() ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_new_null())

+#define sk_ASN1_UTF8STRING_new_reserve(cmp, n) ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_UTF8STRING_compfunc_type(cmp), (n)))

+#define sk_ASN1_UTF8STRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_UTF8STRING_sk_type(sk), (n))

+#define sk_ASN1_UTF8STRING_free(sk) OPENSSL_sk_free(ossl_check_ASN1_UTF8STRING_sk_type(sk))

+#define sk_ASN1_UTF8STRING_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_UTF8STRING_sk_type(sk))

+#define sk_ASN1_UTF8STRING_delete(sk, i) ((ASN1_UTF8STRING *)OPENSSL_sk_delete(ossl_check_ASN1_UTF8STRING_sk_type(sk), (i)))

+#define sk_ASN1_UTF8STRING_delete_ptr(sk, ptr) ((ASN1_UTF8STRING *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr)))

+#define sk_ASN1_UTF8STRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr))

+#define sk_ASN1_UTF8STRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr))

+#define sk_ASN1_UTF8STRING_pop(sk) ((ASN1_UTF8STRING *)OPENSSL_sk_pop(ossl_check_ASN1_UTF8STRING_sk_type(sk)))

+#define sk_ASN1_UTF8STRING_shift(sk) ((ASN1_UTF8STRING *)OPENSSL_sk_shift(ossl_check_ASN1_UTF8STRING_sk_type(sk)))

+#define sk_ASN1_UTF8STRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_UTF8STRING_sk_type(sk),ossl_check_ASN1_UTF8STRING_freefunc_type(freefunc))

+#define sk_ASN1_UTF8STRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr), (idx))

+#define sk_ASN1_UTF8STRING_set(sk, idx, ptr) ((ASN1_UTF8STRING *)OPENSSL_sk_set(ossl_check_ASN1_UTF8STRING_sk_type(sk), (idx), ossl_check_ASN1_UTF8STRING_type(ptr)))

+#define sk_ASN1_UTF8STRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr))

+#define sk_ASN1_UTF8STRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr))

+#define sk_ASN1_UTF8STRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_type(ptr), pnum)

+#define sk_ASN1_UTF8STRING_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_UTF8STRING_sk_type(sk))

+#define sk_ASN1_UTF8STRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_UTF8STRING_sk_type(sk))

+#define sk_ASN1_UTF8STRING_dup(sk) ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_dup(ossl_check_const_ASN1_UTF8STRING_sk_type(sk)))

+#define sk_ASN1_UTF8STRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_UTF8STRING) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_copyfunc_type(copyfunc), ossl_check_ASN1_UTF8STRING_freefunc_type(freefunc)))

+#define sk_ASN1_UTF8STRING_set_cmp_func(sk, cmp) ((sk_ASN1_UTF8STRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_UTF8STRING_sk_type(sk), ossl_check_ASN1_UTF8STRING_compfunc_type(cmp)))

+

+

 DECLARE_ASN1_FUNCTIONS(ASN1_VISIBLESTRING)

 DECLARE_ASN1_FUNCTIONS(ASN1_UNIVERSALSTRING)

 DECLARE_ASN1_FUNCTIONS(ASN1_UTF8STRING)

@@ -609,6 +793,34 @@ DECLARE_ASN1_FUNCTIONS(ASN1_BMPSTRING)
 int UTF8_getc(const unsigned char *str, int len, unsigned long *val);

 int UTF8_putc(unsigned char *str, int len, unsigned long value);

 

+SKM_DEFINE_STACK_OF_INTERNAL(ASN1_GENERALSTRING, ASN1_GENERALSTRING, ASN1_GENERALSTRING)

+#define sk_ASN1_GENERALSTRING_num(sk) OPENSSL_sk_num(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk))

+#define sk_ASN1_GENERALSTRING_value(sk, idx) ((ASN1_GENERALSTRING *)OPENSSL_sk_value(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk), (idx)))

+#define sk_ASN1_GENERALSTRING_new(cmp) ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_new(ossl_check_ASN1_GENERALSTRING_compfunc_type(cmp)))

+#define sk_ASN1_GENERALSTRING_new_null() ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_new_null())

+#define sk_ASN1_GENERALSTRING_new_reserve(cmp, n) ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_new_reserve(ossl_check_ASN1_GENERALSTRING_compfunc_type(cmp), (n)))

+#define sk_ASN1_GENERALSTRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_ASN1_GENERALSTRING_sk_type(sk), (n))

+#define sk_ASN1_GENERALSTRING_free(sk) OPENSSL_sk_free(ossl_check_ASN1_GENERALSTRING_sk_type(sk))

+#define sk_ASN1_GENERALSTRING_zero(sk) OPENSSL_sk_zero(ossl_check_ASN1_GENERALSTRING_sk_type(sk))

+#define sk_ASN1_GENERALSTRING_delete(sk, i) ((ASN1_GENERALSTRING *)OPENSSL_sk_delete(ossl_check_ASN1_GENERALSTRING_sk_type(sk), (i)))

+#define sk_ASN1_GENERALSTRING_delete_ptr(sk, ptr) ((ASN1_GENERALSTRING *)OPENSSL_sk_delete_ptr(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr)))

+#define sk_ASN1_GENERALSTRING_push(sk, ptr) OPENSSL_sk_push(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr))

+#define sk_ASN1_GENERALSTRING_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr))

+#define sk_ASN1_GENERALSTRING_pop(sk) ((ASN1_GENERALSTRING *)OPENSSL_sk_pop(ossl_check_ASN1_GENERALSTRING_sk_type(sk)))

+#define sk_ASN1_GENERALSTRING_shift(sk) ((ASN1_GENERALSTRING *)OPENSSL_sk_shift(ossl_check_ASN1_GENERALSTRING_sk_type(sk)))

+#define sk_ASN1_GENERALSTRING_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_ASN1_GENERALSTRING_sk_type(sk),ossl_check_ASN1_GENERALSTRING_freefunc_type(freefunc))

+#define sk_ASN1_GENERALSTRING_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr), (idx))

+#define sk_ASN1_GENERALSTRING_set(sk, idx, ptr) ((ASN1_GENERALSTRING *)OPENSSL_sk_set(ossl_check_ASN1_GENERALSTRING_sk_type(sk), (idx), ossl_check_ASN1_GENERALSTRING_type(ptr)))

+#define sk_ASN1_GENERALSTRING_find(sk, ptr) OPENSSL_sk_find(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr))

+#define sk_ASN1_GENERALSTRING_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr))

+#define sk_ASN1_GENERALSTRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_type(ptr), pnum)

+#define sk_ASN1_GENERALSTRING_sort(sk) OPENSSL_sk_sort(ossl_check_ASN1_GENERALSTRING_sk_type(sk))

+#define sk_ASN1_GENERALSTRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk))

+#define sk_ASN1_GENERALSTRING_dup(sk) ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_dup(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk)))

+#define sk_ASN1_GENERALSTRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(ASN1_GENERALSTRING) *)OPENSSL_sk_deep_copy(ossl_check_const_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_copyfunc_type(copyfunc), ossl_check_ASN1_GENERALSTRING_freefunc_type(freefunc)))

+#define sk_ASN1_GENERALSTRING_set_cmp_func(sk, cmp) ((sk_ASN1_GENERALSTRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_ASN1_GENERALSTRING_sk_type(sk), ossl_check_ASN1_GENERALSTRING_compfunc_type(cmp)))

+

+

 DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, ASN1_PRINTABLE)

 

 DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DIRECTORYSTRING)

@@ -621,6 +833,10 @@ DECLARE_ASN1_FUNCTIONS(ASN1_UTCTIME)
 DECLARE_ASN1_FUNCTIONS(ASN1_GENERALIZEDTIME)

 DECLARE_ASN1_FUNCTIONS(ASN1_TIME)

 

+DECLARE_ASN1_DUP_FUNCTION(ASN1_TIME)

+DECLARE_ASN1_DUP_FUNCTION(ASN1_UTCTIME)

+DECLARE_ASN1_DUP_FUNCTION(ASN1_GENERALIZEDTIME)

+

 DECLARE_ASN1_ITEM(ASN1_OCTET_STRING_NDEF)

 

 ASN1_TIME *ASN1_TIME_set(ASN1_TIME *s, time_t t);

@@ -685,19 +901,23 @@ int ASN1_put_eoc(unsigned char **pp);
 int ASN1_object_size(int constructed, int length, int tag);

 

 /* Used to implement other functions */

-void *ASN1_dup(i2d_of_void *i2d, d2i_of_void *d2i, void *x);

+void *ASN1_dup(i2d_of_void *i2d, d2i_of_void *d2i, const void *x);

 

 # define ASN1_dup_of(type,i2d,d2i,x) \

     ((type*)ASN1_dup(CHECKED_I2D_OF(type, i2d), \

                      CHECKED_D2I_OF(type, d2i), \

-                     CHECKED_PTR_OF(type, x)))

-

-# define ASN1_dup_of_const(type,i2d,d2i,x) \

-    ((type*)ASN1_dup(CHECKED_I2D_OF(const type, i2d), \

-                     CHECKED_D2I_OF(type, d2i), \

                      CHECKED_PTR_OF(const type, x)))

 

-void *ASN1_item_dup(const ASN1_ITEM *it, void *x);

+void *ASN1_item_dup(const ASN1_ITEM *it, const void *x);

+int ASN1_item_sign_ex(const ASN1_ITEM *it, X509_ALGOR *algor1,

+                      X509_ALGOR *algor2, ASN1_BIT_STRING *signature,

+                      const void *data, const ASN1_OCTET_STRING *id,

+                      EVP_PKEY *pkey, const EVP_MD *md, OSSL_LIB_CTX *libctx,

+                      const char *propq);

+int ASN1_item_verify_ex(const ASN1_ITEM *it, const X509_ALGOR *alg,

+                        const ASN1_BIT_STRING *signature, const void *data,

+                        const ASN1_OCTET_STRING *id, EVP_PKEY *pkey,

+                        OSSL_LIB_CTX *libctx, const char *propq);

 

 /* ASN1 alloc/free macros for when a type is only used internally */

 

@@ -714,20 +934,17 @@ void *ASN1_d2i_fp(void *(*xnew) (void), d2i_of_void *d2i, FILE *in, void **x);
                         in, \

                         CHECKED_PPTR_OF(type, x)))

 

+void *ASN1_item_d2i_fp_ex(const ASN1_ITEM *it, FILE *in, void *x,

+                          OSSL_LIB_CTX *libctx, const char *propq);

 void *ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x);

-int ASN1_i2d_fp(i2d_of_void *i2d, FILE *out, void *x);

+int ASN1_i2d_fp(i2d_of_void *i2d, FILE *out, const void *x);

 

 #  define ASN1_i2d_fp_of(type,i2d,out,x) \

     (ASN1_i2d_fp(CHECKED_I2D_OF(type, i2d), \

                  out, \

-                 CHECKED_PTR_OF(type, x)))

-

-#  define ASN1_i2d_fp_of_const(type,i2d,out,x) \

-    (ASN1_i2d_fp(CHECKED_I2D_OF(const type, i2d), \

-                 out, \

                  CHECKED_PTR_OF(const type, x)))

 

-int ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, void *x);

+int ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, const void *x);

 int ASN1_STRING_print_ex_fp(FILE *fp, const ASN1_STRING *str, unsigned long flags);

 # endif

 

@@ -741,23 +958,22 @@ void *ASN1_d2i_bio(void *(*xnew) (void), d2i_of_void *d2i, BIO *in, void **x);
                           in, \

                           CHECKED_PPTR_OF(type, x)))

 

-void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *x);

-int ASN1_i2d_bio(i2d_of_void *i2d, BIO *out, unsigned char *x);

+void *ASN1_item_d2i_bio_ex(const ASN1_ITEM *it, BIO *in, void *pval,

+                           OSSL_LIB_CTX *libctx, const char *propq);

+void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *pval);

+int ASN1_i2d_bio(i2d_of_void *i2d, BIO *out, const void *x);

 

 #  define ASN1_i2d_bio_of(type,i2d,out,x) \

     (ASN1_i2d_bio(CHECKED_I2D_OF(type, i2d), \

                   out, \

-                  CHECKED_PTR_OF(type, x)))

-

-#  define ASN1_i2d_bio_of_const(type,i2d,out,x) \

-    (ASN1_i2d_bio(CHECKED_I2D_OF(const type, i2d), \

-                  out, \

                   CHECKED_PTR_OF(const type, x)))

 

-int ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, void *x);

+int ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, const void *x);

+BIO *ASN1_item_i2d_mem_bio(const ASN1_ITEM *it, const ASN1_VALUE *val);

 int ASN1_UTCTIME_print(BIO *fp, const ASN1_UTCTIME *a);

 int ASN1_GENERALIZEDTIME_print(BIO *fp, const ASN1_GENERALIZEDTIME *a);

-int ASN1_TIME_print(BIO *fp, const ASN1_TIME *a);

+int ASN1_TIME_print(BIO *bp, const ASN1_TIME *tm);

+int ASN1_TIME_print_ex(BIO *bp, const ASN1_TIME *tm, unsigned long flags);

 int ASN1_STRING_print(BIO *bp, const ASN1_STRING *v);

 int ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str, unsigned long flags);

 int ASN1_buf_print(BIO *bp, const unsigned char *buf, size_t buflen, int off);

@@ -804,11 +1020,16 @@ void ASN1_STRING_TABLE_cleanup(void);
 

 /* Old API compatible functions */

 ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it);

+ASN1_VALUE *ASN1_item_new_ex(const ASN1_ITEM *it, OSSL_LIB_CTX *libctx,

+                             const char *propq);

 void ASN1_item_free(ASN1_VALUE *val, const ASN1_ITEM *it);

+ASN1_VALUE *ASN1_item_d2i_ex(ASN1_VALUE **val, const unsigned char **in,

+                             long len, const ASN1_ITEM *it,

+                             OSSL_LIB_CTX *libctx, const char *propq);

 ASN1_VALUE *ASN1_item_d2i(ASN1_VALUE **val, const unsigned char **in,

                           long len, const ASN1_ITEM *it);

-int ASN1_item_i2d(ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it);

-int ASN1_item_ndef_i2d(ASN1_VALUE *val, unsigned char **out,

+int ASN1_item_i2d(const ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it);

+int ASN1_item_ndef_i2d(const ASN1_VALUE *val, unsigned char **out,

                        const ASN1_ITEM *it);

 

 void ASN1_add_oid_module(void);

@@ -839,7 +1060,7 @@ int ASN1_str2mask(const char *str, unsigned long *pmask);
 /* Don't show structure name even at top level */

 # define ASN1_PCTX_FLAGS_NO_STRUCT_NAME          0x100

 

-int ASN1_item_print(BIO *out, ASN1_VALUE *ifld, int indent,

+int ASN1_item_print(BIO *out, const ASN1_VALUE *ifld, int indent,

                     const ASN1_ITEM *it, const ASN1_PCTX *pctx);

 ASN1_PCTX *ASN1_PCTX_new(void);

 void ASN1_PCTX_free(ASN1_PCTX *p);

@@ -864,22 +1085,43 @@ void *ASN1_SCTX_get_app_data(ASN1_SCTX *p);
 

 const BIO_METHOD *BIO_f_asn1(void);

 

+/* cannot constify val because of CMS_stream() */

 BIO *BIO_new_NDEF(BIO *out, ASN1_VALUE *val, const ASN1_ITEM *it);

 

 int i2d_ASN1_bio_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags,

                         const ASN1_ITEM *it);

 int PEM_write_bio_ASN1_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags,

                               const char *hdr, const ASN1_ITEM *it);

+/* cannot constify val because of CMS_dataFinal() */

 int SMIME_write_ASN1(BIO *bio, ASN1_VALUE *val, BIO *data, int flags,

                      int ctype_nid, int econt_nid,

                      STACK_OF(X509_ALGOR) *mdalgs, const ASN1_ITEM *it);

+int SMIME_write_ASN1_ex(BIO *bio, ASN1_VALUE *val, BIO *data, int flags,

+                        int ctype_nid, int econt_nid,

+                        STACK_OF(X509_ALGOR) *mdalgs, const ASN1_ITEM *it,

+                        OSSL_LIB_CTX *libctx, const char *propq);

 ASN1_VALUE *SMIME_read_ASN1(BIO *bio, BIO **bcont, const ASN1_ITEM *it);

+ASN1_VALUE *SMIME_read_ASN1_ex(BIO *bio, int flags, BIO **bcont,

+                               const ASN1_ITEM *it, ASN1_VALUE **x,

+                               OSSL_LIB_CTX *libctx, const char *propq);

 int SMIME_crlf_copy(BIO *in, BIO *out, int flags);

 int SMIME_text(BIO *in, BIO *out);

 

 const ASN1_ITEM *ASN1_ITEM_lookup(const char *name);

 const ASN1_ITEM *ASN1_ITEM_get(size_t i);

 

+/* Legacy compatibility */

+# define DECLARE_ASN1_FUNCTIONS_fname(type, itname, name) \

+         DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \

+         DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name)

+# define DECLARE_ASN1_FUNCTIONS_const(type) DECLARE_ASN1_FUNCTIONS(type)

+# define DECLARE_ASN1_ENCODE_FUNCTIONS_const(type, name) \

+         DECLARE_ASN1_ENCODE_FUNCTIONS(type, name)

+# define I2D_OF_const(type) I2D_OF(type)

+# define ASN1_dup_of_const(type,i2d,d2i,x) ASN1_dup_of(type,i2d,d2i,x)

+# define ASN1_i2d_fp_of_const(type,i2d,out,x) ASN1_i2d_fp_of(type,i2d,out,x)

+# define ASN1_i2d_bio_of_const(type,i2d,out,x) ASN1_i2d_bio_of(type,i2d,out,x)

+

 # ifdef  __cplusplus

 }

 # endif