diff --git a/qt/patch/qt-sources-patch.diff b/qt/patch/qt-sources-patch.diff new file mode 100644 index 0000000..f6723db --- /dev/null +++ b/qt/patch/qt-sources-patch.diff @@ -0,0 +1,35366 @@ +diff -urN qt.orig/include/openssl/aes.h qt.patched/include/openssl/aes.h +--- qt.orig/include/openssl/aes.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/aes.h 2010-08-27 12:01:44.915172300 +0200 +@@ -0,0 +1,142 @@ ++/* crypto/aes/aes.h -*- mode:C; c-file-style: "eay" -*- */ ++/* ==================================================================== ++ * Copyright (c) 1998-2002 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * openssl-core@openssl.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.openssl.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ */ ++ ++#ifndef HEADER_AES_H ++#define HEADER_AES_H ++ ++#include ++ ++#ifdef OPENSSL_NO_AES ++#error AES is disabled. ++#endif ++ ++#include ++ ++#define AES_ENCRYPT 1 ++#define AES_DECRYPT 0 ++ ++/* Because array size can't be a const in C, the following two are macros. ++ Both sizes are in bytes. */ ++#define AES_MAXNR 14 ++#define AES_BLOCK_SIZE 16 ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* This should be a hidden type, but EVP requires that the size be known */ ++struct aes_key_st { ++#ifdef AES_LONG ++ unsigned long rd_key[4 *(AES_MAXNR + 1)]; ++#else ++ unsigned int rd_key[4 *(AES_MAXNR + 1)]; ++#endif ++ int rounds; ++}; ++typedef struct aes_key_st AES_KEY; ++ ++const char *AES_options(void); ++ ++int AES_set_encrypt_key(const unsigned char *userKey, const int bits, ++ AES_KEY *key); ++int AES_set_decrypt_key(const unsigned char *userKey, const int bits, ++ AES_KEY *key); ++ ++void AES_encrypt(const unsigned char *in, unsigned char *out, ++ const AES_KEY *key); ++void AES_decrypt(const unsigned char *in, unsigned char *out, ++ const AES_KEY *key); ++ ++void AES_ecb_encrypt(const unsigned char *in, unsigned char *out, ++ const AES_KEY *key, const int enc); ++void AES_cbc_encrypt(const unsigned char *in, unsigned char *out, ++ size_t length, const AES_KEY *key, ++ unsigned char *ivec, const int enc); ++void AES_cfb128_encrypt(const unsigned char *in, unsigned char *out, ++ size_t length, const AES_KEY *key, ++ unsigned char *ivec, int *num, const int enc); ++void AES_cfb1_encrypt(const unsigned char *in, unsigned char *out, ++ size_t length, const AES_KEY *key, ++ unsigned char *ivec, int *num, const int enc); ++void AES_cfb8_encrypt(const unsigned char *in, unsigned char *out, ++ size_t length, const AES_KEY *key, ++ unsigned char *ivec, int *num, const int enc); ++void AES_ofb128_encrypt(const unsigned char *in, unsigned char *out, ++ size_t length, const AES_KEY *key, ++ unsigned char *ivec, int *num); ++void AES_ctr128_encrypt(const unsigned char *in, unsigned char *out, ++ size_t length, const AES_KEY *key, ++ unsigned char ivec[AES_BLOCK_SIZE], ++ unsigned char ecount_buf[AES_BLOCK_SIZE], ++ unsigned int *num); ++/* NB: the IV is _two_ blocks long */ ++void AES_ige_encrypt(const unsigned char *in, unsigned char *out, ++ size_t length, const AES_KEY *key, ++ unsigned char *ivec, const int enc); ++/* NB: the IV is _four_ blocks long */ ++void AES_bi_ige_encrypt(const unsigned char *in, unsigned char *out, ++ size_t length, const AES_KEY *key, ++ const AES_KEY *key2, const unsigned char *ivec, ++ const int enc); ++ ++int AES_wrap_key(AES_KEY *key, const unsigned char *iv, ++ unsigned char *out, ++ const unsigned char *in, unsigned int inlen); ++int AES_unwrap_key(AES_KEY *key, const unsigned char *iv, ++ unsigned char *out, ++ const unsigned char *in, unsigned int inlen); ++ ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* !HEADER_AES_H */ +diff -urN qt.orig/include/openssl/applink.c qt.patched/include/openssl/applink.c +--- qt.orig/include/openssl/applink.c 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/applink.c 2010-08-27 12:01:44.946421100 +0200 +@@ -0,0 +1,94 @@ ++#define APPLINK_STDIN 1 ++#define APPLINK_STDOUT 2 ++#define APPLINK_STDERR 3 ++#define APPLINK_FPRINTF 4 ++#define APPLINK_FGETS 5 ++#define APPLINK_FREAD 6 ++#define APPLINK_FWRITE 7 ++#define APPLINK_FSETMOD 8 ++#define APPLINK_FEOF 9 ++#define APPLINK_FCLOSE 10 /* should not be used */ ++ ++#define APPLINK_FOPEN 11 /* solely for completeness */ ++#define APPLINK_FSEEK 12 ++#define APPLINK_FTELL 13 ++#define APPLINK_FFLUSH 14 ++#define APPLINK_FERROR 15 ++#define APPLINK_CLEARERR 16 ++#define APPLINK_FILENO 17 /* to be used with below */ ++ ++#define APPLINK_OPEN 18 /* formally can't be used, as flags can vary */ ++#define APPLINK_READ 19 ++#define APPLINK_WRITE 20 ++#define APPLINK_LSEEK 21 ++#define APPLINK_CLOSE 22 ++#define APPLINK_MAX 22 /* always same as last macro */ ++ ++#ifndef APPMACROS_ONLY ++#include ++#include ++#include ++ ++static void *app_stdin(void) { return stdin; } ++static void *app_stdout(void) { return stdout; } ++static void *app_stderr(void) { return stderr; } ++static int app_feof(FILE *fp) { return feof(fp); } ++static int app_ferror(FILE *fp) { return ferror(fp); } ++static void app_clearerr(FILE *fp) { clearerr(fp); } ++static int app_fileno(FILE *fp) { return _fileno(fp); } ++static int app_fsetmod(FILE *fp,char mod) ++{ return _setmode (_fileno(fp),mod=='b'?_O_BINARY:_O_TEXT); } ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++__declspec(dllexport) ++void ** ++#if defined(__BORLANDC__) ++__stdcall /* __stdcall appears to be the only way to get the name ++ * decoration right with Borland C. Otherwise it works ++ * purely incidentally, as we pass no parameters. */ ++#else ++__cdecl ++#endif ++OPENSSL_Applink(void) ++{ static int once=1; ++ static void *OPENSSL_ApplinkTable[APPLINK_MAX+1]={(void *)APPLINK_MAX}; ++ ++ if (once) ++ { OPENSSL_ApplinkTable[APPLINK_STDIN] = app_stdin; ++ OPENSSL_ApplinkTable[APPLINK_STDOUT] = app_stdout; ++ OPENSSL_ApplinkTable[APPLINK_STDERR] = app_stderr; ++ OPENSSL_ApplinkTable[APPLINK_FPRINTF] = fprintf; ++ OPENSSL_ApplinkTable[APPLINK_FGETS] = fgets; ++ OPENSSL_ApplinkTable[APPLINK_FREAD] = fread; ++ OPENSSL_ApplinkTable[APPLINK_FWRITE] = fwrite; ++ OPENSSL_ApplinkTable[APPLINK_FSETMOD] = app_fsetmod; ++ OPENSSL_ApplinkTable[APPLINK_FEOF] = app_feof; ++ OPENSSL_ApplinkTable[APPLINK_FCLOSE] = fclose; ++ ++ OPENSSL_ApplinkTable[APPLINK_FOPEN] = fopen; ++ OPENSSL_ApplinkTable[APPLINK_FSEEK] = fseek; ++ OPENSSL_ApplinkTable[APPLINK_FTELL] = ftell; ++ OPENSSL_ApplinkTable[APPLINK_FFLUSH] = fflush; ++ OPENSSL_ApplinkTable[APPLINK_FERROR] = app_ferror; ++ OPENSSL_ApplinkTable[APPLINK_CLEARERR] = app_clearerr; ++ OPENSSL_ApplinkTable[APPLINK_FILENO] = app_fileno; ++ ++ OPENSSL_ApplinkTable[APPLINK_OPEN] = _open; ++ OPENSSL_ApplinkTable[APPLINK_READ] = _read; ++ OPENSSL_ApplinkTable[APPLINK_WRITE] = _write; ++ OPENSSL_ApplinkTable[APPLINK_LSEEK] = _lseek; ++ OPENSSL_ApplinkTable[APPLINK_CLOSE] = _close; ++ ++ once = 0; ++ } ++ ++ return OPENSSL_ApplinkTable; ++} ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/asn1.h qt.patched/include/openssl/asn1.h +--- qt.orig/include/openssl/asn1.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/asn1.h 2010-08-27 12:01:44.946421100 +0200 +@@ -0,0 +1,1402 @@ ++/* crypto/asn1/asn1.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_ASN1_H ++#define HEADER_ASN1_H ++ ++#include ++#include ++#ifndef OPENSSL_NO_BIO ++#include ++#endif ++#include ++#include ++ ++#include ++ ++#include ++#ifndef OPENSSL_NO_DEPRECATED ++#include ++#endif ++ ++#ifdef OPENSSL_BUILD_SHLIBCRYPTO ++# undef OPENSSL_EXTERN ++# define OPENSSL_EXTERN OPENSSL_EXPORT ++#endif ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#define V_ASN1_UNIVERSAL 0x00 ++#define V_ASN1_APPLICATION 0x40 ++#define V_ASN1_CONTEXT_SPECIFIC 0x80 ++#define V_ASN1_PRIVATE 0xc0 ++ ++#define V_ASN1_CONSTRUCTED 0x20 ++#define V_ASN1_PRIMITIVE_TAG 0x1f ++#define V_ASN1_PRIMATIVE_TAG 0x1f ++ ++#define V_ASN1_APP_CHOOSE -2 /* let the recipient choose */ ++#define V_ASN1_OTHER -3 /* used in ASN1_TYPE */ ++#define V_ASN1_ANY -4 /* used in ASN1 template code */ ++ ++#define V_ASN1_NEG 0x100 /* negative flag */ ++ ++#define V_ASN1_UNDEF -1 ++#define V_ASN1_EOC 0 ++#define V_ASN1_BOOLEAN 1 /**/ ++#define V_ASN1_INTEGER 2 ++#define V_ASN1_NEG_INTEGER (2 | V_ASN1_NEG) ++#define V_ASN1_BIT_STRING 3 ++#define V_ASN1_OCTET_STRING 4 ++#define V_ASN1_NULL 5 ++#define V_ASN1_OBJECT 6 ++#define V_ASN1_OBJECT_DESCRIPTOR 7 ++#define V_ASN1_EXTERNAL 8 ++#define V_ASN1_REAL 9 ++#define V_ASN1_ENUMERATED 10 ++#define V_ASN1_NEG_ENUMERATED (10 | V_ASN1_NEG) ++#define V_ASN1_UTF8STRING 12 ++#define V_ASN1_SEQUENCE 16 ++#define V_ASN1_SET 17 ++#define V_ASN1_NUMERICSTRING 18 /**/ ++#define V_ASN1_PRINTABLESTRING 19 ++#define V_ASN1_T61STRING 20 ++#define V_ASN1_TELETEXSTRING 20 /* alias */ ++#define V_ASN1_VIDEOTEXSTRING 21 /**/ ++#define V_ASN1_IA5STRING 22 ++#define V_ASN1_UTCTIME 23 ++#define V_ASN1_GENERALIZEDTIME 24 /**/ ++#define V_ASN1_GRAPHICSTRING 25 /**/ ++#define V_ASN1_ISO64STRING 26 /**/ ++#define V_ASN1_VISIBLESTRING 26 /* alias */ ++#define V_ASN1_GENERALSTRING 27 /**/ ++#define V_ASN1_UNIVERSALSTRING 28 /**/ ++#define V_ASN1_BMPSTRING 30 ++ ++/* For use with d2i_ASN1_type_bytes() */ ++#define B_ASN1_NUMERICSTRING 0x0001 ++#define B_ASN1_PRINTABLESTRING 0x0002 ++#define B_ASN1_T61STRING 0x0004 ++#define B_ASN1_TELETEXSTRING 0x0004 ++#define B_ASN1_VIDEOTEXSTRING 0x0008 ++#define B_ASN1_IA5STRING 0x0010 ++#define B_ASN1_GRAPHICSTRING 0x0020 ++#define B_ASN1_ISO64STRING 0x0040 ++#define B_ASN1_VISIBLESTRING 0x0040 ++#define B_ASN1_GENERALSTRING 0x0080 ++#define B_ASN1_UNIVERSALSTRING 0x0100 ++#define B_ASN1_OCTET_STRING 0x0200 ++#define B_ASN1_BIT_STRING 0x0400 ++#define B_ASN1_BMPSTRING 0x0800 ++#define B_ASN1_UNKNOWN 0x1000 ++#define B_ASN1_UTF8STRING 0x2000 ++#define B_ASN1_UTCTIME 0x4000 ++#define B_ASN1_GENERALIZEDTIME 0x8000 ++#define B_ASN1_SEQUENCE 0x10000 ++ ++/* For use with ASN1_mbstring_copy() */ ++#define MBSTRING_FLAG 0x1000 ++#define MBSTRING_UTF8 (MBSTRING_FLAG) ++#define MBSTRING_ASC (MBSTRING_FLAG|1) ++#define MBSTRING_BMP (MBSTRING_FLAG|2) ++#define MBSTRING_UNIV (MBSTRING_FLAG|4) ++ ++#define SMIME_OLDMIME 0x400 ++#define SMIME_CRLFEOL 0x800 ++#define SMIME_STREAM 0x1000 ++ ++struct X509_algor_st; ++DECLARE_STACK_OF(X509_ALGOR) ++ ++#define DECLARE_ASN1_SET_OF(type) /* filled in by mkstack.pl */ ++#define IMPLEMENT_ASN1_SET_OF(type) /* nothing, no longer needed */ ++ ++/* We MUST make sure that, except for constness, asn1_ctx_st and ++ asn1_const_ctx are exactly the same. Fortunately, as soon as ++ the old ASN1 parsing macros are gone, we can throw this away ++ as well... */ ++typedef struct asn1_ctx_st ++ { ++ unsigned char *p;/* work char pointer */ ++ int eos; /* end of sequence read for indefinite encoding */ ++ int error; /* error code to use when returning an error */ ++ int inf; /* constructed if 0x20, indefinite is 0x21 */ ++ int tag; /* tag from last 'get object' */ ++ int xclass; /* class from last 'get object' */ ++ long slen; /* length of last 'get object' */ ++ unsigned char *max; /* largest value of p allowed */ ++ unsigned char *q;/* temporary variable */ ++ unsigned char **pp;/* variable */ ++ int line; /* used in error processing */ ++ } ASN1_CTX; ++ ++typedef struct asn1_const_ctx_st ++ { ++ const unsigned char *p;/* work char pointer */ ++ int eos; /* end of sequence read for indefinite encoding */ ++ int error; /* error code to use when returning an error */ ++ int inf; /* constructed if 0x20, indefinite is 0x21 */ ++ int tag; /* tag from last 'get object' */ ++ int xclass; /* class from last 'get object' */ ++ long slen; /* length of last 'get object' */ ++ const unsigned char *max; /* largest value of p allowed */ ++ const unsigned char *q;/* temporary variable */ ++ const unsigned char **pp;/* variable */ ++ int line; /* used in error processing */ ++ } ASN1_const_CTX; ++ ++/* These are used internally in the ASN1_OBJECT to keep track of ++ * whether the names and data need to be free()ed */ ++#define ASN1_OBJECT_FLAG_DYNAMIC 0x01 /* internal use */ ++#define ASN1_OBJECT_FLAG_CRITICAL 0x02 /* critical x509v3 object id */ ++#define ASN1_OBJECT_FLAG_DYNAMIC_STRINGS 0x04 /* internal use */ ++#define ASN1_OBJECT_FLAG_DYNAMIC_DATA 0x08 /* internal use */ ++typedef struct asn1_object_st ++ { ++ const char *sn,*ln; ++ int nid; ++ int length; ++ const unsigned char *data; /* data remains const after init */ ++ int flags; /* Should we free this one */ ++ } ASN1_OBJECT; ++ ++#define ASN1_STRING_FLAG_BITS_LEFT 0x08 /* Set if 0x07 has bits left value */ ++/* This indicates that the ASN1_STRING is not a real value but just a place ++ * holder for the location where indefinite length constructed data should ++ * be inserted in the memory buffer ++ */ ++#define ASN1_STRING_FLAG_NDEF 0x010 ++ ++/* This flag is used by the CMS code to indicate that a string is not ++ * complete and is a place holder for content when it had all been ++ * accessed. The flag will be reset when content has been written to it. ++ */ ++ ++#define ASN1_STRING_FLAG_CONT 0x020 ++/* This flag is used by ASN1 code to indicate an ASN1_STRING is an MSTRING ++ * type. ++ */ ++#define ASN1_STRING_FLAG_MSTRING 0x040 ++/* This is the base type that holds just about everything :-) */ ++typedef struct asn1_string_st ++ { ++ int length; ++ int type; ++ unsigned char *data; ++ /* The value of the following field depends on the type being ++ * held. It is mostly being used for BIT_STRING so if the ++ * input data has a non-zero 'unused bits' value, it will be ++ * handled correctly */ ++ long flags; ++ } ASN1_STRING; ++ ++/* ASN1_ENCODING structure: this is used to save the received ++ * encoding of an ASN1 type. This is useful to get round ++ * problems with invalid encodings which can break signatures. ++ */ ++ ++typedef struct ASN1_ENCODING_st ++ { ++ unsigned char *enc; /* DER encoding */ ++ long len; /* Length of encoding */ ++ int modified; /* set to 1 if 'enc' is invalid */ ++ } ASN1_ENCODING; ++ ++/* Used with ASN1 LONG type: if a long is set to this it is omitted */ ++#define ASN1_LONG_UNDEF 0x7fffffffL ++ ++#define STABLE_FLAGS_MALLOC 0x01 ++#define STABLE_NO_MASK 0x02 ++#define DIRSTRING_TYPE \ ++ (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 { ++ int nid; ++ long minsize; ++ long maxsize; ++ unsigned long mask; ++ unsigned long flags; ++} ASN1_STRING_TABLE; ++ ++DECLARE_STACK_OF(ASN1_STRING_TABLE) ++ ++/* size limits: this stuff is taken straight from RFC2459 */ ++ ++#define ub_name 32768 ++#define ub_common_name 64 ++#define ub_locality_name 128 ++#define ub_state_name 128 ++#define ub_organization_name 64 ++#define ub_organization_unit_name 64 ++#define ub_title 64 ++#define ub_email_address 128 ++ ++/* Declarations for template structures: for full definitions ++ * see asn1t.h ++ */ ++typedef struct ASN1_TEMPLATE_st ASN1_TEMPLATE; ++typedef struct ASN1_ITEM_st ASN1_ITEM; ++typedef struct ASN1_TLC_st ASN1_TLC; ++/* This is just an opaque pointer */ ++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) ++ ++#define DECLARE_ASN1_PRINT_FUNCTION_fname(stname, fname) \ ++ int fname##_print_ctx(BIO *out, stname *x, int indent, \ ++ const ASN1_PCTX *pctx); ++ ++#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 CHECKED_D2I_OF(type, d2i) \ ++ ((d2i_of_void*) (1 ? d2i : ((D2I_OF(type))0))) ++#define CHECKED_I2D_OF(type, i2d) \ ++ ((i2d_of_void*) (1 ? i2d : ((I2D_OF(type))0))) ++#define CHECKED_NEW_OF(type, xnew) \ ++ ((void *(*)(void)) (1 ? xnew : ((type *(*)(void))0))) ++#define CHECKED_PTR_OF(type, p) \ ++ ((void*) (1 ? p : (type*)0)) ++#define CHECKED_PPTR_OF(type, p) \ ++ ((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_D2I2D_OF(type) TYPEDEF_D2I_OF(type); TYPEDEF_I2D_OF(type) ++ ++TYPEDEF_D2I2D_OF(void); ++ ++/* The following macros and typedefs allow an ASN1_ITEM ++ * to be embedded in a structure and referenced. Since ++ * the ASN1_ITEM pointers need to be globally accessible ++ * (possibly from shared libraries) they may exist in ++ * different forms. On platforms that support it the ++ * ASN1_ITEM structure itself will be globally exported. ++ * Other platforms will export a function that returns ++ * an ASN1_ITEM pointer. ++ * ++ * To handle both cases transparently the macros below ++ * should be used instead of hard coding an ASN1_ITEM ++ * pointer in a structure. ++ * ++ * The structure will look like this: ++ * ++ * typedef struct SOMETHING_st { ++ * ... ++ * ASN1_ITEM_EXP *iptr; ++ * ... ++ * } SOMETHING; ++ * ++ * It would be initialised as e.g.: ++ * ++ * SOMETHING somevar = {...,ASN1_ITEM_ref(X509),...}; ++ * ++ * and the actual pointer extracted with: ++ * ++ * const ASN1_ITEM *it = ASN1_ITEM_ptr(somevar.iptr); ++ * ++ * Finally an ASN1_ITEM pointer can be extracted from an ++ * appropriate reference with: ASN1_ITEM_rptr(X509). This ++ * would be used when a function takes an ASN1_ITEM * argument. ++ * ++ */ ++ ++#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 functions returning ASN1_ITEM pointers. ++ */ ++ ++/* ASN1_ITEM pointer exported type */ ++typedef const ASN1_ITEM * ASN1_ITEM_EXP(void); ++ ++/* 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) \ ++ const ASN1_ITEM * name##_it(void); ++ ++#endif ++ ++/* Parameters used by ASN1_STRING_print_ex() */ ++ ++/* These determine which characters to escape: ++ * RFC2253 special characters, control characters and ++ * MSB set characters ++ */ ++ ++#define ASN1_STRFLGS_ESC_2253 1 ++#define ASN1_STRFLGS_ESC_CTRL 2 ++#define ASN1_STRFLGS_ESC_MSB 4 ++ ++ ++/* This flag determines how we do escaping: normally ++ * RC2253 backslash only, set this to use backslash and ++ * quote. ++ */ ++ ++#define ASN1_STRFLGS_ESC_QUOTE 8 ++ ++ ++/* These three flags are internal use only. */ ++ ++/* Character is a valid PrintableString character */ ++#define CHARTYPE_PRINTABLESTRING 0x10 ++/* Character needs escaping if it is the first character */ ++#define CHARTYPE_FIRST_ESC_2253 0x20 ++/* Character needs escaping if it is the last character */ ++#define CHARTYPE_LAST_ESC_2253 0x40 ++ ++/* NB the internal flags are safely reused below by flags ++ * handled at the top level. ++ */ ++ ++/* If this is set we convert all character strings ++ * to UTF8 first ++ */ ++ ++#define ASN1_STRFLGS_UTF8_CONVERT 0x10 ++ ++/* If this is set we don't attempt to interpret content: ++ * just assume all strings are 1 byte per character. This ++ * will produce some pretty odd looking output! ++ */ ++ ++#define ASN1_STRFLGS_IGNORE_TYPE 0x20 ++ ++/* If this is set we include the string type in the output */ ++#define ASN1_STRFLGS_SHOW_TYPE 0x40 ++ ++/* This determines which strings to display and which to ++ * 'dump' (hex dump of content octets or DER encoding). We can ++ * only dump non character strings or everything. If we ++ * don't dump 'unknown' they are interpreted as character ++ * strings with 1 octet per character and are subject to ++ * the usual escaping options. ++ */ ++ ++#define ASN1_STRFLGS_DUMP_ALL 0x80 ++#define ASN1_STRFLGS_DUMP_UNKNOWN 0x100 ++ ++/* These determine what 'dumping' does, we can dump the ++ * content octets or the DER encoding: both use the ++ * RFC2253 #XXXXX notation. ++ */ ++ ++#define ASN1_STRFLGS_DUMP_DER 0x200 ++ ++/* All the string flags consistent with RFC2253, ++ * escaping control characters isn't essential in ++ * RFC2253 but it is advisable anyway. ++ */ ++ ++#define ASN1_STRFLGS_RFC2253 (ASN1_STRFLGS_ESC_2253 | \ ++ ASN1_STRFLGS_ESC_CTRL | \ ++ ASN1_STRFLGS_ESC_MSB | \ ++ ASN1_STRFLGS_UTF8_CONVERT | \ ++ ASN1_STRFLGS_DUMP_UNKNOWN | \ ++ ASN1_STRFLGS_DUMP_DER) ++ ++DECLARE_STACK_OF(ASN1_INTEGER) ++DECLARE_ASN1_SET_OF(ASN1_INTEGER) ++ ++DECLARE_STACK_OF(ASN1_GENERALSTRING) ++ ++typedef struct asn1_type_st ++ { ++ int type; ++ union { ++ char *ptr; ++ ASN1_BOOLEAN boolean; ++ ASN1_STRING * asn1_string; ++ ASN1_OBJECT * object; ++ ASN1_INTEGER * integer; ++ ASN1_ENUMERATED * enumerated; ++ ASN1_BIT_STRING * bit_string; ++ ASN1_OCTET_STRING * octet_string; ++ ASN1_PRINTABLESTRING * printablestring; ++ ASN1_T61STRING * t61string; ++ ASN1_IA5STRING * ia5string; ++ ASN1_GENERALSTRING * generalstring; ++ ASN1_BMPSTRING * bmpstring; ++ ASN1_UNIVERSALSTRING * universalstring; ++ ASN1_UTCTIME * utctime; ++ ASN1_GENERALIZEDTIME * generalizedtime; ++ ASN1_VISIBLESTRING * visiblestring; ++ ASN1_UTF8STRING * utf8string; ++ /* set and sequence are left complete and still ++ * contain the set or sequence bytes */ ++ ASN1_STRING * set; ++ ASN1_STRING * sequence; ++ ASN1_VALUE * asn1_value; ++ } value; ++ } ASN1_TYPE; ++ ++DECLARE_STACK_OF(ASN1_TYPE) ++DECLARE_ASN1_SET_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) ++ ++typedef struct NETSCAPE_X509_st ++ { ++ ASN1_OCTET_STRING *header; ++ X509 *cert; ++ } NETSCAPE_X509; ++ ++/* This is used to contain a list of bit names */ ++typedef struct BIT_STRING_BITNAME_st { ++ int bitnum; ++ const char *lname; ++ const char *sname; ++} BIT_STRING_BITNAME; ++ ++ ++#define M_ASN1_STRING_length(x) ((x)->length) ++#define M_ASN1_STRING_length_set(x, n) ((x)->length = (n)) ++#define M_ASN1_STRING_type(x) ((x)->type) ++#define M_ASN1_STRING_data(x) ((x)->data) ++ ++/* Macros for string operations */ ++#define M_ASN1_BIT_STRING_new() (ASN1_BIT_STRING *)\ ++ ASN1_STRING_type_new(V_ASN1_BIT_STRING) ++#define M_ASN1_BIT_STRING_free(a) ASN1_STRING_free((ASN1_STRING *)a) ++#define M_ASN1_BIT_STRING_dup(a) (ASN1_BIT_STRING *)\ ++ ASN1_STRING_dup((const ASN1_STRING *)a) ++#define M_ASN1_BIT_STRING_cmp(a,b) ASN1_STRING_cmp(\ ++ (const ASN1_STRING *)a,(const ASN1_STRING *)b) ++#define M_ASN1_BIT_STRING_set(a,b,c) ASN1_STRING_set((ASN1_STRING *)a,b,c) ++ ++#define M_ASN1_INTEGER_new() (ASN1_INTEGER *)\ ++ ASN1_STRING_type_new(V_ASN1_INTEGER) ++#define M_ASN1_INTEGER_free(a) ASN1_STRING_free((ASN1_STRING *)a) ++#define M_ASN1_INTEGER_dup(a) (ASN1_INTEGER *)\ ++ ASN1_STRING_dup((const ASN1_STRING *)a) ++#define M_ASN1_INTEGER_cmp(a,b) ASN1_STRING_cmp(\ ++ (const ASN1_STRING *)a,(const ASN1_STRING *)b) ++ ++#define M_ASN1_ENUMERATED_new() (ASN1_ENUMERATED *)\ ++ ASN1_STRING_type_new(V_ASN1_ENUMERATED) ++#define M_ASN1_ENUMERATED_free(a) ASN1_STRING_free((ASN1_STRING *)a) ++#define M_ASN1_ENUMERATED_dup(a) (ASN1_ENUMERATED *)\ ++ ASN1_STRING_dup((const ASN1_STRING *)a) ++#define M_ASN1_ENUMERATED_cmp(a,b) ASN1_STRING_cmp(\ ++ (const ASN1_STRING *)a,(const ASN1_STRING *)b) ++ ++#define M_ASN1_OCTET_STRING_new() (ASN1_OCTET_STRING *)\ ++ ASN1_STRING_type_new(V_ASN1_OCTET_STRING) ++#define M_ASN1_OCTET_STRING_free(a) ASN1_STRING_free((ASN1_STRING *)a) ++#define M_ASN1_OCTET_STRING_dup(a) (ASN1_OCTET_STRING *)\ ++ ASN1_STRING_dup((const ASN1_STRING *)a) ++#define M_ASN1_OCTET_STRING_cmp(a,b) ASN1_STRING_cmp(\ ++ (const ASN1_STRING *)a,(const ASN1_STRING *)b) ++#define M_ASN1_OCTET_STRING_set(a,b,c) ASN1_STRING_set((ASN1_STRING *)a,b,c) ++#define M_ASN1_OCTET_STRING_print(a,b) ASN1_STRING_print(a,(ASN1_STRING *)b) ++#define M_i2d_ASN1_OCTET_STRING(a,pp) \ ++ i2d_ASN1_bytes((ASN1_STRING *)a,pp,V_ASN1_OCTET_STRING,\ ++ V_ASN1_UNIVERSAL) ++ ++#define B_ASN1_TIME \ ++ B_ASN1_UTCTIME | \ ++ B_ASN1_GENERALIZEDTIME ++ ++#define B_ASN1_PRINTABLE \ ++ B_ASN1_NUMERICSTRING| \ ++ B_ASN1_PRINTABLESTRING| \ ++ B_ASN1_T61STRING| \ ++ B_ASN1_IA5STRING| \ ++ B_ASN1_BIT_STRING| \ ++ B_ASN1_UNIVERSALSTRING|\ ++ B_ASN1_BMPSTRING|\ ++ B_ASN1_UTF8STRING|\ ++ B_ASN1_SEQUENCE|\ ++ B_ASN1_UNKNOWN ++ ++#define B_ASN1_DIRECTORYSTRING \ ++ B_ASN1_PRINTABLESTRING| \ ++ B_ASN1_TELETEXSTRING|\ ++ B_ASN1_BMPSTRING|\ ++ B_ASN1_UNIVERSALSTRING|\ ++ B_ASN1_UTF8STRING ++ ++#define B_ASN1_DISPLAYTEXT \ ++ B_ASN1_IA5STRING| \ ++ B_ASN1_VISIBLESTRING| \ ++ B_ASN1_BMPSTRING|\ ++ B_ASN1_UTF8STRING ++ ++#define M_ASN1_PRINTABLE_new() ASN1_STRING_type_new(V_ASN1_T61STRING) ++#define M_ASN1_PRINTABLE_free(a) ASN1_STRING_free((ASN1_STRING *)a) ++#define M_i2d_ASN1_PRINTABLE(a,pp) i2d_ASN1_bytes((ASN1_STRING *)a,\ ++ pp,a->type,V_ASN1_UNIVERSAL) ++#define M_d2i_ASN1_PRINTABLE(a,pp,l) \ ++ d2i_ASN1_type_bytes((ASN1_STRING **)a,pp,l, \ ++ B_ASN1_PRINTABLE) ++ ++#define M_DIRECTORYSTRING_new() ASN1_STRING_type_new(V_ASN1_PRINTABLESTRING) ++#define M_DIRECTORYSTRING_free(a) ASN1_STRING_free((ASN1_STRING *)a) ++#define M_i2d_DIRECTORYSTRING(a,pp) i2d_ASN1_bytes((ASN1_STRING *)a,\ ++ pp,a->type,V_ASN1_UNIVERSAL) ++#define M_d2i_DIRECTORYSTRING(a,pp,l) \ ++ d2i_ASN1_type_bytes((ASN1_STRING **)a,pp,l, \ ++ B_ASN1_DIRECTORYSTRING) ++ ++#define M_DISPLAYTEXT_new() ASN1_STRING_type_new(V_ASN1_VISIBLESTRING) ++#define M_DISPLAYTEXT_free(a) ASN1_STRING_free((ASN1_STRING *)a) ++#define M_i2d_DISPLAYTEXT(a,pp) i2d_ASN1_bytes((ASN1_STRING *)a,\ ++ pp,a->type,V_ASN1_UNIVERSAL) ++#define M_d2i_DISPLAYTEXT(a,pp,l) \ ++ d2i_ASN1_type_bytes((ASN1_STRING **)a,pp,l, \ ++ B_ASN1_DISPLAYTEXT) ++ ++#define M_ASN1_PRINTABLESTRING_new() (ASN1_PRINTABLESTRING *)\ ++ ASN1_STRING_type_new(V_ASN1_PRINTABLESTRING) ++#define M_ASN1_PRINTABLESTRING_free(a) ASN1_STRING_free((ASN1_STRING *)a) ++#define M_i2d_ASN1_PRINTABLESTRING(a,pp) \ ++ i2d_ASN1_bytes((ASN1_STRING *)a,pp,V_ASN1_PRINTABLESTRING,\ ++ V_ASN1_UNIVERSAL) ++#define M_d2i_ASN1_PRINTABLESTRING(a,pp,l) \ ++ (ASN1_PRINTABLESTRING *)d2i_ASN1_type_bytes\ ++ ((ASN1_STRING **)a,pp,l,B_ASN1_PRINTABLESTRING) ++ ++#define M_ASN1_T61STRING_new() (ASN1_T61STRING *)\ ++ ASN1_STRING_type_new(V_ASN1_T61STRING) ++#define M_ASN1_T61STRING_free(a) ASN1_STRING_free((ASN1_STRING *)a) ++#define M_i2d_ASN1_T61STRING(a,pp) \ ++ i2d_ASN1_bytes((ASN1_STRING *)a,pp,V_ASN1_T61STRING,\ ++ V_ASN1_UNIVERSAL) ++#define M_d2i_ASN1_T61STRING(a,pp,l) \ ++ (ASN1_T61STRING *)d2i_ASN1_type_bytes\ ++ ((ASN1_STRING **)a,pp,l,B_ASN1_T61STRING) ++ ++#define M_ASN1_IA5STRING_new() (ASN1_IA5STRING *)\ ++ ASN1_STRING_type_new(V_ASN1_IA5STRING) ++#define M_ASN1_IA5STRING_free(a) ASN1_STRING_free((ASN1_STRING *)a) ++#define M_ASN1_IA5STRING_dup(a) \ ++ (ASN1_IA5STRING *)ASN1_STRING_dup((const ASN1_STRING *)a) ++#define M_i2d_ASN1_IA5STRING(a,pp) \ ++ i2d_ASN1_bytes((ASN1_STRING *)a,pp,V_ASN1_IA5STRING,\ ++ V_ASN1_UNIVERSAL) ++#define M_d2i_ASN1_IA5STRING(a,pp,l) \ ++ (ASN1_IA5STRING *)d2i_ASN1_type_bytes((ASN1_STRING **)a,pp,l,\ ++ B_ASN1_IA5STRING) ++ ++#define M_ASN1_UTCTIME_new() (ASN1_UTCTIME *)\ ++ ASN1_STRING_type_new(V_ASN1_UTCTIME) ++#define M_ASN1_UTCTIME_free(a) ASN1_STRING_free((ASN1_STRING *)a) ++#define M_ASN1_UTCTIME_dup(a) (ASN1_UTCTIME *)\ ++ ASN1_STRING_dup((const ASN1_STRING *)a) ++ ++#define M_ASN1_GENERALIZEDTIME_new() (ASN1_GENERALIZEDTIME *)\ ++ ASN1_STRING_type_new(V_ASN1_GENERALIZEDTIME) ++#define M_ASN1_GENERALIZEDTIME_free(a) ASN1_STRING_free((ASN1_STRING *)a) ++#define M_ASN1_GENERALIZEDTIME_dup(a) (ASN1_GENERALIZEDTIME *)ASN1_STRING_dup(\ ++ (const ASN1_STRING *)a) ++ ++#define M_ASN1_TIME_new() (ASN1_TIME *)\ ++ ASN1_STRING_type_new(V_ASN1_UTCTIME) ++#define M_ASN1_TIME_free(a) ASN1_STRING_free((ASN1_STRING *)a) ++#define M_ASN1_TIME_dup(a) (ASN1_TIME *)\ ++ ASN1_STRING_dup((const ASN1_STRING *)a) ++ ++#define M_ASN1_GENERALSTRING_new() (ASN1_GENERALSTRING *)\ ++ ASN1_STRING_type_new(V_ASN1_GENERALSTRING) ++#define M_ASN1_GENERALSTRING_free(a) ASN1_STRING_free((ASN1_STRING *)a) ++#define M_i2d_ASN1_GENERALSTRING(a,pp) \ ++ i2d_ASN1_bytes((ASN1_STRING *)a,pp,V_ASN1_GENERALSTRING,\ ++ V_ASN1_UNIVERSAL) ++#define M_d2i_ASN1_GENERALSTRING(a,pp,l) \ ++ (ASN1_GENERALSTRING *)d2i_ASN1_type_bytes\ ++ ((ASN1_STRING **)a,pp,l,B_ASN1_GENERALSTRING) ++ ++#define M_ASN1_UNIVERSALSTRING_new() (ASN1_UNIVERSALSTRING *)\ ++ ASN1_STRING_type_new(V_ASN1_UNIVERSALSTRING) ++#define M_ASN1_UNIVERSALSTRING_free(a) ASN1_STRING_free((ASN1_STRING *)a) ++#define M_i2d_ASN1_UNIVERSALSTRING(a,pp) \ ++ i2d_ASN1_bytes((ASN1_STRING *)a,pp,V_ASN1_UNIVERSALSTRING,\ ++ V_ASN1_UNIVERSAL) ++#define M_d2i_ASN1_UNIVERSALSTRING(a,pp,l) \ ++ (ASN1_UNIVERSALSTRING *)d2i_ASN1_type_bytes\ ++ ((ASN1_STRING **)a,pp,l,B_ASN1_UNIVERSALSTRING) ++ ++#define M_ASN1_BMPSTRING_new() (ASN1_BMPSTRING *)\ ++ ASN1_STRING_type_new(V_ASN1_BMPSTRING) ++#define M_ASN1_BMPSTRING_free(a) ASN1_STRING_free((ASN1_STRING *)a) ++#define M_i2d_ASN1_BMPSTRING(a,pp) \ ++ i2d_ASN1_bytes((ASN1_STRING *)a,pp,V_ASN1_BMPSTRING,\ ++ V_ASN1_UNIVERSAL) ++#define M_d2i_ASN1_BMPSTRING(a,pp,l) \ ++ (ASN1_BMPSTRING *)d2i_ASN1_type_bytes\ ++ ((ASN1_STRING **)a,pp,l,B_ASN1_BMPSTRING) ++ ++#define M_ASN1_VISIBLESTRING_new() (ASN1_VISIBLESTRING *)\ ++ ASN1_STRING_type_new(V_ASN1_VISIBLESTRING) ++#define M_ASN1_VISIBLESTRING_free(a) ASN1_STRING_free((ASN1_STRING *)a) ++#define M_i2d_ASN1_VISIBLESTRING(a,pp) \ ++ i2d_ASN1_bytes((ASN1_STRING *)a,pp,V_ASN1_VISIBLESTRING,\ ++ V_ASN1_UNIVERSAL) ++#define M_d2i_ASN1_VISIBLESTRING(a,pp,l) \ ++ (ASN1_VISIBLESTRING *)d2i_ASN1_type_bytes\ ++ ((ASN1_STRING **)a,pp,l,B_ASN1_VISIBLESTRING) ++ ++#define M_ASN1_UTF8STRING_new() (ASN1_UTF8STRING *)\ ++ ASN1_STRING_type_new(V_ASN1_UTF8STRING) ++#define M_ASN1_UTF8STRING_free(a) ASN1_STRING_free((ASN1_STRING *)a) ++#define M_i2d_ASN1_UTF8STRING(a,pp) \ ++ i2d_ASN1_bytes((ASN1_STRING *)a,pp,V_ASN1_UTF8STRING,\ ++ V_ASN1_UNIVERSAL) ++#define M_d2i_ASN1_UTF8STRING(a,pp,l) \ ++ (ASN1_UTF8STRING *)d2i_ASN1_type_bytes\ ++ ((ASN1_STRING **)a,pp,l,B_ASN1_UTF8STRING) ++ ++ /* for the is_set parameter to i2d_ASN1_SET */ ++#define IS_SEQUENCE 0 ++#define IS_SET 1 ++ ++DECLARE_ASN1_FUNCTIONS_fname(ASN1_TYPE, ASN1_ANY, ASN1_TYPE) ++ ++int ASN1_TYPE_get(ASN1_TYPE *a); ++void ASN1_TYPE_set(ASN1_TYPE *a, int type, void *value); ++int ASN1_TYPE_set1(ASN1_TYPE *a, int type, const void *value); ++int ASN1_TYPE_cmp(ASN1_TYPE *a, ASN1_TYPE *b); ++ ++ASN1_OBJECT * ASN1_OBJECT_new(void ); ++void ASN1_OBJECT_free(ASN1_OBJECT *a); ++int i2d_ASN1_OBJECT(ASN1_OBJECT *a,unsigned char **pp); ++ASN1_OBJECT * c2i_ASN1_OBJECT(ASN1_OBJECT **a,const unsigned char **pp, ++ long length); ++ASN1_OBJECT * d2i_ASN1_OBJECT(ASN1_OBJECT **a,const unsigned char **pp, ++ long length); ++ ++DECLARE_ASN1_ITEM(ASN1_OBJECT) ++ ++DECLARE_STACK_OF(ASN1_OBJECT) ++DECLARE_ASN1_SET_OF(ASN1_OBJECT) ++ ++ASN1_STRING * ASN1_STRING_new(void); ++void ASN1_STRING_free(ASN1_STRING *a); ++int ASN1_STRING_copy(ASN1_STRING *dst, const ASN1_STRING *str); ++ASN1_STRING * ASN1_STRING_dup(const ASN1_STRING *a); ++ASN1_STRING * ASN1_STRING_type_new(int type ); ++int ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b); ++ /* Since this is used to store all sorts of things, via macros, for now, make ++ its data void * */ ++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); ++int ASN1_STRING_type(ASN1_STRING *x); ++unsigned char * ASN1_STRING_data(ASN1_STRING *x); ++ ++DECLARE_ASN1_FUNCTIONS(ASN1_BIT_STRING) ++int i2c_ASN1_BIT_STRING(ASN1_BIT_STRING *a,unsigned char **pp); ++ASN1_BIT_STRING *c2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a,const unsigned char **pp, ++ long length); ++int ASN1_BIT_STRING_set(ASN1_BIT_STRING *a, unsigned char *d, ++ int length ); ++int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value); ++int ASN1_BIT_STRING_get_bit(ASN1_BIT_STRING *a, int n); ++int ASN1_BIT_STRING_check(ASN1_BIT_STRING *a, ++ unsigned char *flags, int flags_len); ++ ++#ifndef OPENSSL_NO_BIO ++int ASN1_BIT_STRING_name_print(BIO *out, ASN1_BIT_STRING *bs, ++ BIT_STRING_BITNAME *tbl, int indent); ++#endif ++int ASN1_BIT_STRING_num_asc(char *name, BIT_STRING_BITNAME *tbl); ++int ASN1_BIT_STRING_set_asc(ASN1_BIT_STRING *bs, char *name, int value, ++ BIT_STRING_BITNAME *tbl); ++ ++int i2d_ASN1_BOOLEAN(int a,unsigned char **pp); ++int d2i_ASN1_BOOLEAN(int *a,const unsigned char **pp,long length); ++ ++DECLARE_ASN1_FUNCTIONS(ASN1_INTEGER) ++int i2c_ASN1_INTEGER(ASN1_INTEGER *a,unsigned char **pp); ++ASN1_INTEGER *c2i_ASN1_INTEGER(ASN1_INTEGER **a,const unsigned char **pp, ++ long length); ++ASN1_INTEGER *d2i_ASN1_UINTEGER(ASN1_INTEGER **a,const unsigned char **pp, ++ long length); ++ASN1_INTEGER * ASN1_INTEGER_dup(const ASN1_INTEGER *x); ++int ASN1_INTEGER_cmp(const ASN1_INTEGER *x, const ASN1_INTEGER *y); ++ ++DECLARE_ASN1_FUNCTIONS(ASN1_ENUMERATED) ++ ++int ASN1_UTCTIME_check(ASN1_UTCTIME *a); ++ASN1_UTCTIME *ASN1_UTCTIME_set(ASN1_UTCTIME *s,time_t t); ++ASN1_UTCTIME *ASN1_UTCTIME_adj(ASN1_UTCTIME *s, time_t t, ++ int offset_day, long offset_sec); ++int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str); ++int ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME *s, time_t t); ++#if 0 ++time_t ASN1_UTCTIME_get(const ASN1_UTCTIME *s); ++#endif ++ ++int ASN1_GENERALIZEDTIME_check(ASN1_GENERALIZEDTIME *a); ++ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME *s,time_t t); ++ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s, ++ time_t t, int offset_day, long offset_sec); ++int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str); ++ ++DECLARE_ASN1_FUNCTIONS(ASN1_OCTET_STRING) ++ASN1_OCTET_STRING * ASN1_OCTET_STRING_dup(const ASN1_OCTET_STRING *a); ++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); ++ ++DECLARE_ASN1_FUNCTIONS(ASN1_VISIBLESTRING) ++DECLARE_ASN1_FUNCTIONS(ASN1_UNIVERSALSTRING) ++DECLARE_ASN1_FUNCTIONS(ASN1_UTF8STRING) ++DECLARE_ASN1_FUNCTIONS(ASN1_NULL) ++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); ++ ++DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, ASN1_PRINTABLE) ++ ++DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DIRECTORYSTRING) ++DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DISPLAYTEXT) ++DECLARE_ASN1_FUNCTIONS(ASN1_PRINTABLESTRING) ++DECLARE_ASN1_FUNCTIONS(ASN1_T61STRING) ++DECLARE_ASN1_FUNCTIONS(ASN1_IA5STRING) ++DECLARE_ASN1_FUNCTIONS(ASN1_GENERALSTRING) ++DECLARE_ASN1_FUNCTIONS(ASN1_UTCTIME) ++DECLARE_ASN1_FUNCTIONS(ASN1_GENERALIZEDTIME) ++DECLARE_ASN1_FUNCTIONS(ASN1_TIME) ++ ++DECLARE_ASN1_ITEM(ASN1_OCTET_STRING_NDEF) ++ ++ASN1_TIME *ASN1_TIME_set(ASN1_TIME *s,time_t t); ++ASN1_TIME *ASN1_TIME_adj(ASN1_TIME *s,time_t t, ++ int offset_day, long offset_sec); ++int ASN1_TIME_check(ASN1_TIME *t); ++ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(ASN1_TIME *t, ASN1_GENERALIZEDTIME **out); ++int ASN1_TIME_set_string(ASN1_TIME *s, const char *str); ++ ++int i2d_ASN1_SET(STACK_OF(OPENSSL_BLOCK) *a, unsigned char **pp, ++ i2d_of_void *i2d, int ex_tag, int ex_class, ++ int is_set); ++STACK_OF(OPENSSL_BLOCK) *d2i_ASN1_SET(STACK_OF(OPENSSL_BLOCK) **a, ++ const unsigned char **pp, ++ long length, d2i_of_void *d2i, ++ void (*free_func)(OPENSSL_BLOCK), int ex_tag, ++ int ex_class); ++ ++#ifndef OPENSSL_NO_BIO ++int i2a_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *a); ++int a2i_ASN1_INTEGER(BIO *bp,ASN1_INTEGER *bs,char *buf,int size); ++int i2a_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *a); ++int a2i_ASN1_ENUMERATED(BIO *bp,ASN1_ENUMERATED *bs,char *buf,int size); ++int i2a_ASN1_OBJECT(BIO *bp,ASN1_OBJECT *a); ++int a2i_ASN1_STRING(BIO *bp,ASN1_STRING *bs,char *buf,int size); ++int i2a_ASN1_STRING(BIO *bp, ASN1_STRING *a, int type); ++#endif ++int i2t_ASN1_OBJECT(char *buf,int buf_len,ASN1_OBJECT *a); ++ ++int a2d_ASN1_OBJECT(unsigned char *out,int olen, const char *buf, int num); ++ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data,int len, ++ const char *sn, const char *ln); ++ ++int ASN1_INTEGER_set(ASN1_INTEGER *a, long v); ++long ASN1_INTEGER_get(const ASN1_INTEGER *a); ++ASN1_INTEGER *BN_to_ASN1_INTEGER(const BIGNUM *bn, ASN1_INTEGER *ai); ++BIGNUM *ASN1_INTEGER_to_BN(const ASN1_INTEGER *ai,BIGNUM *bn); ++ ++int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v); ++long ASN1_ENUMERATED_get(ASN1_ENUMERATED *a); ++ASN1_ENUMERATED *BN_to_ASN1_ENUMERATED(BIGNUM *bn, ASN1_ENUMERATED *ai); ++BIGNUM *ASN1_ENUMERATED_to_BN(ASN1_ENUMERATED *ai,BIGNUM *bn); ++ ++/* General */ ++/* given a string, return the correct type, max is the maximum length */ ++int ASN1_PRINTABLE_type(const unsigned char *s, int max); ++ ++int i2d_ASN1_bytes(ASN1_STRING *a, unsigned char **pp, int tag, int xclass); ++ASN1_STRING *d2i_ASN1_bytes(ASN1_STRING **a, const unsigned char **pp, ++ long length, int Ptag, int Pclass); ++unsigned long ASN1_tag2bit(int tag); ++/* type is one or more of the B_ASN1_ values. */ ++ASN1_STRING *d2i_ASN1_type_bytes(ASN1_STRING **a,const unsigned char **pp, ++ long length,int type); ++ ++/* PARSING */ ++int asn1_Finish(ASN1_CTX *c); ++int asn1_const_Finish(ASN1_const_CTX *c); ++ ++/* SPECIALS */ ++int ASN1_get_object(const unsigned char **pp, long *plength, int *ptag, ++ int *pclass, long omax); ++int ASN1_check_infinite_end(unsigned char **p,long len); ++int ASN1_const_check_infinite_end(const unsigned char **p,long len); ++void ASN1_put_object(unsigned char **pp, int constructed, int length, ++ int tag, int xclass); ++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); ++ ++#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); ++ ++/* ASN1 alloc/free macros for when a type is only used internally */ ++ ++#define M_ASN1_new_of(type) (type *)ASN1_item_new(ASN1_ITEM_rptr(type)) ++#define M_ASN1_free_of(x, type) \ ++ ASN1_item_free(CHECKED_PTR_OF(type, x), ASN1_ITEM_rptr(type)) ++ ++#ifndef OPENSSL_NO_FP_API ++void *ASN1_d2i_fp(void *(*xnew)(void), d2i_of_void *d2i, FILE *in, void **x); ++ ++#define ASN1_d2i_fp_of(type,xnew,d2i,in,x) \ ++ ((type*)ASN1_d2i_fp(CHECKED_NEW_OF(type, xnew), \ ++ CHECKED_D2I_OF(type, d2i), \ ++ in, \ ++ CHECKED_PPTR_OF(type, x))) ++ ++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); ++ ++#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_STRING_print_ex_fp(FILE *fp, ASN1_STRING *str, unsigned long flags); ++#endif ++ ++int ASN1_STRING_to_UTF8(unsigned char **out, ASN1_STRING *in); ++ ++#ifndef OPENSSL_NO_BIO ++void *ASN1_d2i_bio(void *(*xnew)(void), d2i_of_void *d2i, BIO *in, void **x); ++ ++#define ASN1_d2i_bio_of(type,xnew,d2i,in,x) \ ++ ((type*)ASN1_d2i_bio( CHECKED_NEW_OF(type, xnew), \ ++ CHECKED_D2I_OF(type, d2i), \ ++ 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); ++ ++#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_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_STRING_print(BIO *bp, const ASN1_STRING *v); ++int ASN1_STRING_print_ex(BIO *out, ASN1_STRING *str, unsigned long flags); ++int ASN1_bn_print(BIO *bp, const char *number, const BIGNUM *num, ++ unsigned char *buf, int off); ++int ASN1_parse(BIO *bp,const unsigned char *pp,long len,int indent); ++int ASN1_parse_dump(BIO *bp,const unsigned char *pp,long len,int indent,int dump); ++#endif ++const char *ASN1_tag2str(int tag); ++ ++/* Used to load and write netscape format cert */ ++ ++DECLARE_ASN1_FUNCTIONS(NETSCAPE_X509) ++ ++int ASN1_UNIVERSALSTRING_to_string(ASN1_UNIVERSALSTRING *s); ++ ++int ASN1_TYPE_set_octetstring(ASN1_TYPE *a, ++ unsigned char *data, int len); ++int ASN1_TYPE_get_octetstring(ASN1_TYPE *a, ++ unsigned char *data, int max_len); ++int ASN1_TYPE_set_int_octetstring(ASN1_TYPE *a, long num, ++ unsigned char *data, int len); ++int ASN1_TYPE_get_int_octetstring(ASN1_TYPE *a,long *num, ++ unsigned char *data, int max_len); ++ ++STACK_OF(OPENSSL_BLOCK) *ASN1_seq_unpack(const unsigned char *buf, int len, ++ d2i_of_void *d2i, void (*free_func)(OPENSSL_BLOCK)); ++unsigned char *ASN1_seq_pack(STACK_OF(OPENSSL_BLOCK) *safes, i2d_of_void *i2d, ++ unsigned char **buf, int *len ); ++void *ASN1_unpack_string(ASN1_STRING *oct, d2i_of_void *d2i); ++void *ASN1_item_unpack(ASN1_STRING *oct, const ASN1_ITEM *it); ++ASN1_STRING *ASN1_pack_string(void *obj, i2d_of_void *i2d, ++ ASN1_OCTET_STRING **oct); ++ ++#define ASN1_pack_string_of(type,obj,i2d,oct) \ ++ (ASN1_pack_string(CHECKED_PTR_OF(type, obj), \ ++ CHECKED_I2D_OF(type, i2d), \ ++ oct)) ++ ++ASN1_STRING *ASN1_item_pack(void *obj, const ASN1_ITEM *it, ASN1_OCTET_STRING **oct); ++ ++void ASN1_STRING_set_default_mask(unsigned long mask); ++int ASN1_STRING_set_default_mask_asc(char *p); ++unsigned long ASN1_STRING_get_default_mask(void); ++int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len, ++ int inform, unsigned long mask); ++int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len, ++ int inform, unsigned long mask, ++ long minsize, long maxsize); ++ ++ASN1_STRING *ASN1_STRING_set_by_NID(ASN1_STRING **out, ++ const unsigned char *in, int inlen, int inform, int nid); ++ASN1_STRING_TABLE *ASN1_STRING_TABLE_get(int nid); ++int ASN1_STRING_TABLE_add(int, long, long, unsigned long, unsigned long); ++void ASN1_STRING_TABLE_cleanup(void); ++ ++/* ASN1 template functions */ ++ ++/* Old API compatible functions */ ++ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it); ++void ASN1_item_free(ASN1_VALUE *val, const ASN1_ITEM *it); ++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, const ASN1_ITEM *it); ++ ++void ASN1_add_oid_module(void); ++ ++ASN1_TYPE *ASN1_generate_nconf(char *str, CONF *nconf); ++ASN1_TYPE *ASN1_generate_v3(char *str, X509V3_CTX *cnf); ++ ++/* ASN1 Print flags */ ++ ++/* Indicate missing OPTIONAL fields */ ++#define ASN1_PCTX_FLAGS_SHOW_ABSENT 0x001 ++/* Mark start and end of SEQUENCE */ ++#define ASN1_PCTX_FLAGS_SHOW_SEQUENCE 0x002 ++/* Mark start and end of SEQUENCE/SET OF */ ++#define ASN1_PCTX_FLAGS_SHOW_SSOF 0x004 ++/* Show the ASN1 type of primitives */ ++#define ASN1_PCTX_FLAGS_SHOW_TYPE 0x008 ++/* Don't show ASN1 type of ANY */ ++#define ASN1_PCTX_FLAGS_NO_ANY_TYPE 0x010 ++/* Don't show ASN1 type of MSTRINGs */ ++#define ASN1_PCTX_FLAGS_NO_MSTRING_TYPE 0x020 ++/* Don't show field names in SEQUENCE */ ++#define ASN1_PCTX_FLAGS_NO_FIELD_NAME 0x040 ++/* Show structure names of each SEQUENCE field */ ++#define ASN1_PCTX_FLAGS_SHOW_FIELD_STRUCT_NAME 0x080 ++/* 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, ++ const ASN1_ITEM *it, const ASN1_PCTX *pctx); ++ASN1_PCTX *ASN1_PCTX_new(void); ++void ASN1_PCTX_free(ASN1_PCTX *p); ++unsigned long ASN1_PCTX_get_flags(ASN1_PCTX *p); ++void ASN1_PCTX_set_flags(ASN1_PCTX *p, unsigned long flags); ++unsigned long ASN1_PCTX_get_nm_flags(ASN1_PCTX *p); ++void ASN1_PCTX_set_nm_flags(ASN1_PCTX *p, unsigned long flags); ++unsigned long ASN1_PCTX_get_cert_flags(ASN1_PCTX *p); ++void ASN1_PCTX_set_cert_flags(ASN1_PCTX *p, unsigned long flags); ++unsigned long ASN1_PCTX_get_oid_flags(ASN1_PCTX *p); ++void ASN1_PCTX_set_oid_flags(ASN1_PCTX *p, unsigned long flags); ++unsigned long ASN1_PCTX_get_str_flags(ASN1_PCTX *p); ++void ASN1_PCTX_set_str_flags(ASN1_PCTX *p, unsigned long flags); ++ ++BIO_METHOD *BIO_f_asn1(void); ++ ++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); ++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); ++ASN1_VALUE *SMIME_read_ASN1(BIO *bio, BIO **bcont, const ASN1_ITEM *it); ++int SMIME_crlf_copy(BIO *in, BIO *out, int flags); ++int SMIME_text(BIO *in, BIO *out); ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_ASN1_strings(void); ++ ++/* Error codes for the ASN1 functions. */ ++ ++/* Function codes. */ ++#define ASN1_F_A2D_ASN1_OBJECT 100 ++#define ASN1_F_A2I_ASN1_ENUMERATED 101 ++#define ASN1_F_A2I_ASN1_INTEGER 102 ++#define ASN1_F_A2I_ASN1_STRING 103 ++#define ASN1_F_APPEND_EXP 176 ++#define ASN1_F_ASN1_BIT_STRING_SET_BIT 183 ++#define ASN1_F_ASN1_CB 177 ++#define ASN1_F_ASN1_CHECK_TLEN 104 ++#define ASN1_F_ASN1_COLLATE_PRIMITIVE 105 ++#define ASN1_F_ASN1_COLLECT 106 ++#define ASN1_F_ASN1_D2I_EX_PRIMITIVE 108 ++#define ASN1_F_ASN1_D2I_FP 109 ++#define ASN1_F_ASN1_D2I_READ_BIO 107 ++#define ASN1_F_ASN1_DIGEST 184 ++#define ASN1_F_ASN1_DO_ADB 110 ++#define ASN1_F_ASN1_DUP 111 ++#define ASN1_F_ASN1_ENUMERATED_SET 112 ++#define ASN1_F_ASN1_ENUMERATED_TO_BN 113 ++#define ASN1_F_ASN1_EX_C2I 204 ++#define ASN1_F_ASN1_FIND_END 190 ++#define ASN1_F_ASN1_GENERALIZEDTIME_ADJ 216 ++#define ASN1_F_ASN1_GENERALIZEDTIME_SET 185 ++#define ASN1_F_ASN1_GENERATE_V3 178 ++#define ASN1_F_ASN1_GET_OBJECT 114 ++#define ASN1_F_ASN1_HEADER_NEW 115 ++#define ASN1_F_ASN1_I2D_BIO 116 ++#define ASN1_F_ASN1_I2D_FP 117 ++#define ASN1_F_ASN1_INTEGER_SET 118 ++#define ASN1_F_ASN1_INTEGER_TO_BN 119 ++#define ASN1_F_ASN1_ITEM_D2I_FP 206 ++#define ASN1_F_ASN1_ITEM_DUP 191 ++#define ASN1_F_ASN1_ITEM_EX_COMBINE_NEW 121 ++#define ASN1_F_ASN1_ITEM_EX_D2I 120 ++#define ASN1_F_ASN1_ITEM_I2D_BIO 192 ++#define ASN1_F_ASN1_ITEM_I2D_FP 193 ++#define ASN1_F_ASN1_ITEM_PACK 198 ++#define ASN1_F_ASN1_ITEM_SIGN 195 ++#define ASN1_F_ASN1_ITEM_UNPACK 199 ++#define ASN1_F_ASN1_ITEM_VERIFY 197 ++#define ASN1_F_ASN1_MBSTRING_NCOPY 122 ++#define ASN1_F_ASN1_OBJECT_NEW 123 ++#define ASN1_F_ASN1_OUTPUT_DATA 214 ++#define ASN1_F_ASN1_PACK_STRING 124 ++#define ASN1_F_ASN1_PCTX_NEW 205 ++#define ASN1_F_ASN1_PKCS5_PBE_SET 125 ++#define ASN1_F_ASN1_SEQ_PACK 126 ++#define ASN1_F_ASN1_SEQ_UNPACK 127 ++#define ASN1_F_ASN1_SIGN 128 ++#define ASN1_F_ASN1_STR2TYPE 179 ++#define ASN1_F_ASN1_STRING_SET 186 ++#define ASN1_F_ASN1_STRING_TABLE_ADD 129 ++#define ASN1_F_ASN1_STRING_TYPE_NEW 130 ++#define ASN1_F_ASN1_TEMPLATE_EX_D2I 132 ++#define ASN1_F_ASN1_TEMPLATE_NEW 133 ++#define ASN1_F_ASN1_TEMPLATE_NOEXP_D2I 131 ++#define ASN1_F_ASN1_TIME_ADJ 217 ++#define ASN1_F_ASN1_TIME_SET 175 ++#define ASN1_F_ASN1_TYPE_GET_INT_OCTETSTRING 134 ++#define ASN1_F_ASN1_TYPE_GET_OCTETSTRING 135 ++#define ASN1_F_ASN1_UNPACK_STRING 136 ++#define ASN1_F_ASN1_UTCTIME_ADJ 218 ++#define ASN1_F_ASN1_UTCTIME_SET 187 ++#define ASN1_F_ASN1_VERIFY 137 ++#define ASN1_F_B64_READ_ASN1 209 ++#define ASN1_F_B64_WRITE_ASN1 210 ++#define ASN1_F_BIO_NEW_NDEF 208 ++#define ASN1_F_BITSTR_CB 180 ++#define ASN1_F_BN_TO_ASN1_ENUMERATED 138 ++#define ASN1_F_BN_TO_ASN1_INTEGER 139 ++#define ASN1_F_C2I_ASN1_BIT_STRING 189 ++#define ASN1_F_C2I_ASN1_INTEGER 194 ++#define ASN1_F_C2I_ASN1_OBJECT 196 ++#define ASN1_F_COLLECT_DATA 140 ++#define ASN1_F_D2I_ASN1_BIT_STRING 141 ++#define ASN1_F_D2I_ASN1_BOOLEAN 142 ++#define ASN1_F_D2I_ASN1_BYTES 143 ++#define ASN1_F_D2I_ASN1_GENERALIZEDTIME 144 ++#define ASN1_F_D2I_ASN1_HEADER 145 ++#define ASN1_F_D2I_ASN1_INTEGER 146 ++#define ASN1_F_D2I_ASN1_OBJECT 147 ++#define ASN1_F_D2I_ASN1_SET 148 ++#define ASN1_F_D2I_ASN1_TYPE_BYTES 149 ++#define ASN1_F_D2I_ASN1_UINTEGER 150 ++#define ASN1_F_D2I_ASN1_UTCTIME 151 ++#define ASN1_F_D2I_AUTOPRIVATEKEY 207 ++#define ASN1_F_D2I_NETSCAPE_RSA 152 ++#define ASN1_F_D2I_NETSCAPE_RSA_2 153 ++#define ASN1_F_D2I_PRIVATEKEY 154 ++#define ASN1_F_D2I_PUBLICKEY 155 ++#define ASN1_F_D2I_RSA_NET 200 ++#define ASN1_F_D2I_RSA_NET_2 201 ++#define ASN1_F_D2I_X509 156 ++#define ASN1_F_D2I_X509_CINF 157 ++#define ASN1_F_D2I_X509_PKEY 159 ++#define ASN1_F_I2D_ASN1_BIO_STREAM 211 ++#define ASN1_F_I2D_ASN1_SET 188 ++#define ASN1_F_I2D_ASN1_TIME 160 ++#define ASN1_F_I2D_DSA_PUBKEY 161 ++#define ASN1_F_I2D_EC_PUBKEY 181 ++#define ASN1_F_I2D_PRIVATEKEY 163 ++#define ASN1_F_I2D_PUBLICKEY 164 ++#define ASN1_F_I2D_RSA_NET 162 ++#define ASN1_F_I2D_RSA_PUBKEY 165 ++#define ASN1_F_LONG_C2I 166 ++#define ASN1_F_OID_MODULE_INIT 174 ++#define ASN1_F_PARSE_TAGGING 182 ++#define ASN1_F_PKCS5_PBE2_SET_IV 167 ++#define ASN1_F_PKCS5_PBE_SET 202 ++#define ASN1_F_PKCS5_PBE_SET0_ALGOR 215 ++#define ASN1_F_SMIME_READ_ASN1 212 ++#define ASN1_F_SMIME_TEXT 213 ++#define ASN1_F_X509_CINF_NEW 168 ++#define ASN1_F_X509_CRL_ADD0_REVOKED 169 ++#define ASN1_F_X509_INFO_NEW 170 ++#define ASN1_F_X509_NAME_ENCODE 203 ++#define ASN1_F_X509_NAME_EX_D2I 158 ++#define ASN1_F_X509_NAME_EX_NEW 171 ++#define ASN1_F_X509_NEW 172 ++#define ASN1_F_X509_PKEY_NEW 173 ++ ++/* Reason codes. */ ++#define ASN1_R_ADDING_OBJECT 171 ++#define ASN1_R_ASN1_PARSE_ERROR 203 ++#define ASN1_R_ASN1_SIG_PARSE_ERROR 204 ++#define ASN1_R_AUX_ERROR 100 ++#define ASN1_R_BAD_CLASS 101 ++#define ASN1_R_BAD_OBJECT_HEADER 102 ++#define ASN1_R_BAD_PASSWORD_READ 103 ++#define ASN1_R_BAD_TAG 104 ++#define ASN1_R_BMPSTRING_IS_WRONG_LENGTH 214 ++#define ASN1_R_BN_LIB 105 ++#define ASN1_R_BOOLEAN_IS_WRONG_LENGTH 106 ++#define ASN1_R_BUFFER_TOO_SMALL 107 ++#define ASN1_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER 108 ++#define ASN1_R_DATA_IS_WRONG 109 ++#define ASN1_R_DECODE_ERROR 110 ++#define ASN1_R_DECODING_ERROR 111 ++#define ASN1_R_DEPTH_EXCEEDED 174 ++#define ASN1_R_DIGEST_AND_KEY_TYPE_NOT_SUPPORTED 198 ++#define ASN1_R_ENCODE_ERROR 112 ++#define ASN1_R_ERROR_GETTING_TIME 173 ++#define ASN1_R_ERROR_LOADING_SECTION 172 ++#define ASN1_R_ERROR_PARSING_SET_ELEMENT 113 ++#define ASN1_R_ERROR_SETTING_CIPHER_PARAMS 114 ++#define ASN1_R_EXPECTING_AN_INTEGER 115 ++#define ASN1_R_EXPECTING_AN_OBJECT 116 ++#define ASN1_R_EXPECTING_A_BOOLEAN 117 ++#define ASN1_R_EXPECTING_A_TIME 118 ++#define ASN1_R_EXPLICIT_LENGTH_MISMATCH 119 ++#define ASN1_R_EXPLICIT_TAG_NOT_CONSTRUCTED 120 ++#define ASN1_R_FIELD_MISSING 121 ++#define ASN1_R_FIRST_NUM_TOO_LARGE 122 ++#define ASN1_R_HEADER_TOO_LONG 123 ++#define ASN1_R_ILLEGAL_BITSTRING_FORMAT 175 ++#define ASN1_R_ILLEGAL_BOOLEAN 176 ++#define ASN1_R_ILLEGAL_CHARACTERS 124 ++#define ASN1_R_ILLEGAL_FORMAT 177 ++#define ASN1_R_ILLEGAL_HEX 178 ++#define ASN1_R_ILLEGAL_IMPLICIT_TAG 179 ++#define ASN1_R_ILLEGAL_INTEGER 180 ++#define ASN1_R_ILLEGAL_NESTED_TAGGING 181 ++#define ASN1_R_ILLEGAL_NULL 125 ++#define ASN1_R_ILLEGAL_NULL_VALUE 182 ++#define ASN1_R_ILLEGAL_OBJECT 183 ++#define ASN1_R_ILLEGAL_OPTIONAL_ANY 126 ++#define ASN1_R_ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE 170 ++#define ASN1_R_ILLEGAL_TAGGED_ANY 127 ++#define ASN1_R_ILLEGAL_TIME_VALUE 184 ++#define ASN1_R_INTEGER_NOT_ASCII_FORMAT 185 ++#define ASN1_R_INTEGER_TOO_LARGE_FOR_LONG 128 ++#define ASN1_R_INVALID_BMPSTRING_LENGTH 129 ++#define ASN1_R_INVALID_DIGIT 130 ++#define ASN1_R_INVALID_MIME_TYPE 205 ++#define ASN1_R_INVALID_MODIFIER 186 ++#define ASN1_R_INVALID_NUMBER 187 ++#define ASN1_R_INVALID_OBJECT_ENCODING 216 ++#define ASN1_R_INVALID_SEPARATOR 131 ++#define ASN1_R_INVALID_TIME_FORMAT 132 ++#define ASN1_R_INVALID_UNIVERSALSTRING_LENGTH 133 ++#define ASN1_R_INVALID_UTF8STRING 134 ++#define ASN1_R_IV_TOO_LARGE 135 ++#define ASN1_R_LENGTH_ERROR 136 ++#define ASN1_R_LIST_ERROR 188 ++#define ASN1_R_MIME_NO_CONTENT_TYPE 206 ++#define ASN1_R_MIME_PARSE_ERROR 207 ++#define ASN1_R_MIME_SIG_PARSE_ERROR 208 ++#define ASN1_R_MISSING_EOC 137 ++#define ASN1_R_MISSING_SECOND_NUMBER 138 ++#define ASN1_R_MISSING_VALUE 189 ++#define ASN1_R_MSTRING_NOT_UNIVERSAL 139 ++#define ASN1_R_MSTRING_WRONG_TAG 140 ++#define ASN1_R_NESTED_ASN1_STRING 197 ++#define ASN1_R_NON_HEX_CHARACTERS 141 ++#define ASN1_R_NOT_ASCII_FORMAT 190 ++#define ASN1_R_NOT_ENOUGH_DATA 142 ++#define ASN1_R_NO_CONTENT_TYPE 209 ++#define ASN1_R_NO_DEFAULT_DIGEST 201 ++#define ASN1_R_NO_MATCHING_CHOICE_TYPE 143 ++#define ASN1_R_NO_MULTIPART_BODY_FAILURE 210 ++#define ASN1_R_NO_MULTIPART_BOUNDARY 211 ++#define ASN1_R_NO_SIG_CONTENT_TYPE 212 ++#define ASN1_R_NULL_IS_WRONG_LENGTH 144 ++#define ASN1_R_OBJECT_NOT_ASCII_FORMAT 191 ++#define ASN1_R_ODD_NUMBER_OF_CHARS 145 ++#define ASN1_R_PRIVATE_KEY_HEADER_MISSING 146 ++#define ASN1_R_SECOND_NUMBER_TOO_LARGE 147 ++#define ASN1_R_SEQUENCE_LENGTH_MISMATCH 148 ++#define ASN1_R_SEQUENCE_NOT_CONSTRUCTED 149 ++#define ASN1_R_SEQUENCE_OR_SET_NEEDS_CONFIG 192 ++#define ASN1_R_SHORT_LINE 150 ++#define ASN1_R_SIG_INVALID_MIME_TYPE 213 ++#define ASN1_R_STREAMING_NOT_SUPPORTED 202 ++#define ASN1_R_STRING_TOO_LONG 151 ++#define ASN1_R_STRING_TOO_SHORT 152 ++#define ASN1_R_TAG_VALUE_TOO_HIGH 153 ++#define ASN1_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD 154 ++#define ASN1_R_TIME_NOT_ASCII_FORMAT 193 ++#define ASN1_R_TOO_LONG 155 ++#define ASN1_R_TYPE_NOT_CONSTRUCTED 156 ++#define ASN1_R_UNABLE_TO_DECODE_RSA_KEY 157 ++#define ASN1_R_UNABLE_TO_DECODE_RSA_PRIVATE_KEY 158 ++#define ASN1_R_UNEXPECTED_EOC 159 ++#define ASN1_R_UNIVERSALSTRING_IS_WRONG_LENGTH 215 ++#define ASN1_R_UNKNOWN_FORMAT 160 ++#define ASN1_R_UNKNOWN_MESSAGE_DIGEST_ALGORITHM 161 ++#define ASN1_R_UNKNOWN_OBJECT_TYPE 162 ++#define ASN1_R_UNKNOWN_PUBLIC_KEY_TYPE 163 ++#define ASN1_R_UNKNOWN_SIGNATURE_ALGORITHM 199 ++#define ASN1_R_UNKNOWN_TAG 194 ++#define ASN1_R_UNKOWN_FORMAT 195 ++#define ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE 164 ++#define ASN1_R_UNSUPPORTED_CIPHER 165 ++#define ASN1_R_UNSUPPORTED_ENCRYPTION_ALGORITHM 166 ++#define ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE 167 ++#define ASN1_R_UNSUPPORTED_TYPE 196 ++#define ASN1_R_WRONG_PUBLIC_KEY_TYPE 200 ++#define ASN1_R_WRONG_TAG 168 ++#define ASN1_R_WRONG_TYPE 169 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/asn1_mac.h qt.patched/include/openssl/asn1_mac.h +--- qt.orig/include/openssl/asn1_mac.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/asn1_mac.h 2010-08-27 12:01:44.977669900 +0200 +@@ -0,0 +1,578 @@ ++/* crypto/asn1/asn1_mac.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_ASN1_MAC_H ++#define HEADER_ASN1_MAC_H ++ ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#ifndef ASN1_MAC_ERR_LIB ++#define ASN1_MAC_ERR_LIB ERR_LIB_ASN1 ++#endif ++ ++#define ASN1_MAC_H_err(f,r,line) \ ++ ERR_PUT_error(ASN1_MAC_ERR_LIB,(f),(r),__FILE__,(line)) ++ ++#define M_ASN1_D2I_vars(a,type,func) \ ++ ASN1_const_CTX c; \ ++ type ret=NULL; \ ++ \ ++ c.pp=(const unsigned char **)pp; \ ++ c.q= *(const unsigned char **)pp; \ ++ c.error=ERR_R_NESTED_ASN1_ERROR; \ ++ if ((a == NULL) || ((*a) == NULL)) \ ++ { if ((ret=(type)func()) == NULL) \ ++ { c.line=__LINE__; goto err; } } \ ++ else ret=(*a); ++ ++#define M_ASN1_D2I_Init() \ ++ c.p= *(const unsigned char **)pp; \ ++ c.max=(length == 0)?0:(c.p+length); ++ ++#define M_ASN1_D2I_Finish_2(a) \ ++ if (!asn1_const_Finish(&c)) \ ++ { c.line=__LINE__; goto err; } \ ++ *(const unsigned char **)pp=c.p; \ ++ if (a != NULL) (*a)=ret; \ ++ return(ret); ++ ++#define M_ASN1_D2I_Finish(a,func,e) \ ++ M_ASN1_D2I_Finish_2(a); \ ++err:\ ++ ASN1_MAC_H_err((e),c.error,c.line); \ ++ asn1_add_error(*(const unsigned char **)pp,(int)(c.q- *pp)); \ ++ if ((ret != NULL) && ((a == NULL) || (*a != ret))) func(ret); \ ++ return(NULL) ++ ++#define M_ASN1_D2I_start_sequence() \ ++ if (!asn1_GetSequence(&c,&length)) \ ++ { c.line=__LINE__; goto err; } ++/* Begin reading ASN1 without a surrounding sequence */ ++#define M_ASN1_D2I_begin() \ ++ c.slen = length; ++ ++/* End reading ASN1 with no check on length */ ++#define M_ASN1_D2I_Finish_nolen(a, func, e) \ ++ *pp=c.p; \ ++ if (a != NULL) (*a)=ret; \ ++ return(ret); \ ++err:\ ++ ASN1_MAC_H_err((e),c.error,c.line); \ ++ asn1_add_error(*pp,(int)(c.q- *pp)); \ ++ if ((ret != NULL) && ((a == NULL) || (*a != ret))) func(ret); \ ++ return(NULL) ++ ++#define M_ASN1_D2I_end_sequence() \ ++ (((c.inf&1) == 0)?(c.slen <= 0): \ ++ (c.eos=ASN1_const_check_infinite_end(&c.p,c.slen))) ++ ++/* Don't use this with d2i_ASN1_BOOLEAN() */ ++#define M_ASN1_D2I_get(b, func) \ ++ c.q=c.p; \ ++ if (func(&(b),&c.p,c.slen) == NULL) \ ++ {c.line=__LINE__; goto err; } \ ++ c.slen-=(c.p-c.q); ++ ++/* Don't use this with d2i_ASN1_BOOLEAN() */ ++#define M_ASN1_D2I_get_x(type,b,func) \ ++ c.q=c.p; \ ++ if (((D2I_OF(type))func)(&(b),&c.p,c.slen) == NULL) \ ++ {c.line=__LINE__; goto err; } \ ++ c.slen-=(c.p-c.q); ++ ++/* use this instead () */ ++#define M_ASN1_D2I_get_int(b,func) \ ++ c.q=c.p; \ ++ if (func(&(b),&c.p,c.slen) < 0) \ ++ {c.line=__LINE__; goto err; } \ ++ c.slen-=(c.p-c.q); ++ ++#define M_ASN1_D2I_get_opt(b,func,type) \ ++ if ((c.slen != 0) && ((M_ASN1_next & (~V_ASN1_CONSTRUCTED)) \ ++ == (V_ASN1_UNIVERSAL|(type)))) \ ++ { \ ++ M_ASN1_D2I_get(b,func); \ ++ } ++ ++#define M_ASN1_D2I_get_int_opt(b,func,type) \ ++ if ((c.slen != 0) && ((M_ASN1_next & (~V_ASN1_CONSTRUCTED)) \ ++ == (V_ASN1_UNIVERSAL|(type)))) \ ++ { \ ++ M_ASN1_D2I_get_int(b,func); \ ++ } ++ ++#define M_ASN1_D2I_get_imp(b,func, type) \ ++ M_ASN1_next=(_tmp& V_ASN1_CONSTRUCTED)|type; \ ++ c.q=c.p; \ ++ if (func(&(b),&c.p,c.slen) == NULL) \ ++ {c.line=__LINE__; M_ASN1_next_prev = _tmp; goto err; } \ ++ c.slen-=(c.p-c.q);\ ++ M_ASN1_next_prev=_tmp; ++ ++#define M_ASN1_D2I_get_IMP_opt(b,func,tag,type) \ ++ if ((c.slen != 0) && ((M_ASN1_next & (~V_ASN1_CONSTRUCTED)) == \ ++ (V_ASN1_CONTEXT_SPECIFIC|(tag)))) \ ++ { \ ++ unsigned char _tmp = M_ASN1_next; \ ++ M_ASN1_D2I_get_imp(b,func, type);\ ++ } ++ ++#define M_ASN1_D2I_get_set(r,func,free_func) \ ++ M_ASN1_D2I_get_imp_set(r,func,free_func, \ ++ V_ASN1_SET,V_ASN1_UNIVERSAL); ++ ++#define M_ASN1_D2I_get_set_type(type,r,func,free_func) \ ++ M_ASN1_D2I_get_imp_set_type(type,r,func,free_func, \ ++ V_ASN1_SET,V_ASN1_UNIVERSAL); ++ ++#define M_ASN1_D2I_get_set_opt(r,func,free_func) \ ++ if ((c.slen != 0) && (M_ASN1_next == (V_ASN1_UNIVERSAL| \ ++ V_ASN1_CONSTRUCTED|V_ASN1_SET)))\ ++ { M_ASN1_D2I_get_set(r,func,free_func); } ++ ++#define M_ASN1_D2I_get_set_opt_type(type,r,func,free_func) \ ++ if ((c.slen != 0) && (M_ASN1_next == (V_ASN1_UNIVERSAL| \ ++ V_ASN1_CONSTRUCTED|V_ASN1_SET)))\ ++ { M_ASN1_D2I_get_set_type(type,r,func,free_func); } ++ ++#define M_ASN1_I2D_len_SET_opt(a,f) \ ++ if ((a != NULL) && (sk_num(a) != 0)) \ ++ M_ASN1_I2D_len_SET(a,f); ++ ++#define M_ASN1_I2D_put_SET_opt(a,f) \ ++ if ((a != NULL) && (sk_num(a) != 0)) \ ++ M_ASN1_I2D_put_SET(a,f); ++ ++#define M_ASN1_I2D_put_SEQUENCE_opt(a,f) \ ++ if ((a != NULL) && (sk_num(a) != 0)) \ ++ M_ASN1_I2D_put_SEQUENCE(a,f); ++ ++#define M_ASN1_I2D_put_SEQUENCE_opt_type(type,a,f) \ ++ if ((a != NULL) && (sk_##type##_num(a) != 0)) \ ++ M_ASN1_I2D_put_SEQUENCE_type(type,a,f); ++ ++#define M_ASN1_D2I_get_IMP_set_opt(b,func,free_func,tag) \ ++ if ((c.slen != 0) && \ ++ (M_ASN1_next == \ ++ (V_ASN1_CONTEXT_SPECIFIC|V_ASN1_CONSTRUCTED|(tag))))\ ++ { \ ++ M_ASN1_D2I_get_imp_set(b,func,free_func,\ ++ tag,V_ASN1_CONTEXT_SPECIFIC); \ ++ } ++ ++#define M_ASN1_D2I_get_IMP_set_opt_type(type,b,func,free_func,tag) \ ++ if ((c.slen != 0) && \ ++ (M_ASN1_next == \ ++ (V_ASN1_CONTEXT_SPECIFIC|V_ASN1_CONSTRUCTED|(tag))))\ ++ { \ ++ M_ASN1_D2I_get_imp_set_type(type,b,func,free_func,\ ++ tag,V_ASN1_CONTEXT_SPECIFIC); \ ++ } ++ ++#define M_ASN1_D2I_get_seq(r,func,free_func) \ ++ M_ASN1_D2I_get_imp_set(r,func,free_func,\ ++ V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL); ++ ++#define M_ASN1_D2I_get_seq_type(type,r,func,free_func) \ ++ M_ASN1_D2I_get_imp_set_type(type,r,func,free_func,\ ++ V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL) ++ ++#define M_ASN1_D2I_get_seq_opt(r,func,free_func) \ ++ if ((c.slen != 0) && (M_ASN1_next == (V_ASN1_UNIVERSAL| \ ++ V_ASN1_CONSTRUCTED|V_ASN1_SEQUENCE)))\ ++ { M_ASN1_D2I_get_seq(r,func,free_func); } ++ ++#define M_ASN1_D2I_get_seq_opt_type(type,r,func,free_func) \ ++ if ((c.slen != 0) && (M_ASN1_next == (V_ASN1_UNIVERSAL| \ ++ V_ASN1_CONSTRUCTED|V_ASN1_SEQUENCE)))\ ++ { M_ASN1_D2I_get_seq_type(type,r,func,free_func); } ++ ++#define M_ASN1_D2I_get_IMP_set(r,func,free_func,x) \ ++ M_ASN1_D2I_get_imp_set(r,func,free_func,\ ++ x,V_ASN1_CONTEXT_SPECIFIC); ++ ++#define M_ASN1_D2I_get_IMP_set_type(type,r,func,free_func,x) \ ++ M_ASN1_D2I_get_imp_set_type(type,r,func,free_func,\ ++ x,V_ASN1_CONTEXT_SPECIFIC); ++ ++#define M_ASN1_D2I_get_imp_set(r,func,free_func,a,b) \ ++ c.q=c.p; \ ++ if (d2i_ASN1_SET(&(r),&c.p,c.slen,(char *(*)())func,\ ++ (void (*)())free_func,a,b) == NULL) \ ++ { c.line=__LINE__; goto err; } \ ++ c.slen-=(c.p-c.q); ++ ++#define M_ASN1_D2I_get_imp_set_type(type,r,func,free_func,a,b) \ ++ c.q=c.p; \ ++ if (d2i_ASN1_SET_OF_##type(&(r),&c.p,c.slen,func,\ ++ free_func,a,b) == NULL) \ ++ { c.line=__LINE__; goto err; } \ ++ c.slen-=(c.p-c.q); ++ ++#define M_ASN1_D2I_get_set_strings(r,func,a,b) \ ++ c.q=c.p; \ ++ if (d2i_ASN1_STRING_SET(&(r),&c.p,c.slen,a,b) == NULL) \ ++ { c.line=__LINE__; goto err; } \ ++ c.slen-=(c.p-c.q); ++ ++#define M_ASN1_D2I_get_EXP_opt(r,func,tag) \ ++ if ((c.slen != 0L) && (M_ASN1_next == \ ++ (V_ASN1_CONSTRUCTED|V_ASN1_CONTEXT_SPECIFIC|tag))) \ ++ { \ ++ int Tinf,Ttag,Tclass; \ ++ long Tlen; \ ++ \ ++ c.q=c.p; \ ++ Tinf=ASN1_get_object(&c.p,&Tlen,&Ttag,&Tclass,c.slen); \ ++ if (Tinf & 0x80) \ ++ { c.error=ERR_R_BAD_ASN1_OBJECT_HEADER; \ ++ c.line=__LINE__; goto err; } \ ++ if (Tinf == (V_ASN1_CONSTRUCTED+1)) \ ++ Tlen = c.slen - (c.p - c.q) - 2; \ ++ if (func(&(r),&c.p,Tlen) == NULL) \ ++ { c.line=__LINE__; goto err; } \ ++ if (Tinf == (V_ASN1_CONSTRUCTED+1)) { \ ++ Tlen = c.slen - (c.p - c.q); \ ++ if(!ASN1_const_check_infinite_end(&c.p, Tlen)) \ ++ { c.error=ERR_R_MISSING_ASN1_EOS; \ ++ c.line=__LINE__; goto err; } \ ++ }\ ++ c.slen-=(c.p-c.q); \ ++ } ++ ++#define M_ASN1_D2I_get_EXP_set_opt(r,func,free_func,tag,b) \ ++ if ((c.slen != 0) && (M_ASN1_next == \ ++ (V_ASN1_CONSTRUCTED|V_ASN1_CONTEXT_SPECIFIC|tag))) \ ++ { \ ++ int Tinf,Ttag,Tclass; \ ++ long Tlen; \ ++ \ ++ c.q=c.p; \ ++ Tinf=ASN1_get_object(&c.p,&Tlen,&Ttag,&Tclass,c.slen); \ ++ if (Tinf & 0x80) \ ++ { c.error=ERR_R_BAD_ASN1_OBJECT_HEADER; \ ++ c.line=__LINE__; goto err; } \ ++ if (Tinf == (V_ASN1_CONSTRUCTED+1)) \ ++ Tlen = c.slen - (c.p - c.q) - 2; \ ++ if (d2i_ASN1_SET(&(r),&c.p,Tlen,(char *(*)())func, \ ++ (void (*)())free_func, \ ++ b,V_ASN1_UNIVERSAL) == NULL) \ ++ { c.line=__LINE__; goto err; } \ ++ if (Tinf == (V_ASN1_CONSTRUCTED+1)) { \ ++ Tlen = c.slen - (c.p - c.q); \ ++ if(!ASN1_check_infinite_end(&c.p, Tlen)) \ ++ { c.error=ERR_R_MISSING_ASN1_EOS; \ ++ c.line=__LINE__; goto err; } \ ++ }\ ++ c.slen-=(c.p-c.q); \ ++ } ++ ++#define M_ASN1_D2I_get_EXP_set_opt_type(type,r,func,free_func,tag,b) \ ++ if ((c.slen != 0) && (M_ASN1_next == \ ++ (V_ASN1_CONSTRUCTED|V_ASN1_CONTEXT_SPECIFIC|tag))) \ ++ { \ ++ int Tinf,Ttag,Tclass; \ ++ long Tlen; \ ++ \ ++ c.q=c.p; \ ++ Tinf=ASN1_get_object(&c.p,&Tlen,&Ttag,&Tclass,c.slen); \ ++ if (Tinf & 0x80) \ ++ { c.error=ERR_R_BAD_ASN1_OBJECT_HEADER; \ ++ c.line=__LINE__; goto err; } \ ++ if (Tinf == (V_ASN1_CONSTRUCTED+1)) \ ++ Tlen = c.slen - (c.p - c.q) - 2; \ ++ if (d2i_ASN1_SET_OF_##type(&(r),&c.p,Tlen,func, \ ++ free_func,b,V_ASN1_UNIVERSAL) == NULL) \ ++ { c.line=__LINE__; goto err; } \ ++ if (Tinf == (V_ASN1_CONSTRUCTED+1)) { \ ++ Tlen = c.slen - (c.p - c.q); \ ++ if(!ASN1_check_infinite_end(&c.p, Tlen)) \ ++ { c.error=ERR_R_MISSING_ASN1_EOS; \ ++ c.line=__LINE__; goto err; } \ ++ }\ ++ c.slen-=(c.p-c.q); \ ++ } ++ ++/* New macros */ ++#define M_ASN1_New_Malloc(ret,type) \ ++ if ((ret=(type *)OPENSSL_malloc(sizeof(type))) == NULL) \ ++ { c.line=__LINE__; goto err2; } ++ ++#define M_ASN1_New(arg,func) \ ++ if (((arg)=func()) == NULL) return(NULL) ++ ++#define M_ASN1_New_Error(a) \ ++/* err: ASN1_MAC_H_err((a),ERR_R_NESTED_ASN1_ERROR,c.line); \ ++ return(NULL);*/ \ ++ err2: ASN1_MAC_H_err((a),ERR_R_MALLOC_FAILURE,c.line); \ ++ return(NULL) ++ ++ ++/* BIG UGLY WARNING! This is so damn ugly I wanna puke. Unfortunately, ++ some macros that use ASN1_const_CTX still insist on writing in the input ++ stream. ARGH! ARGH! ARGH! Let's get rid of this macro package. ++ Please? -- Richard Levitte */ ++#define M_ASN1_next (*((unsigned char *)(c.p))) ++#define M_ASN1_next_prev (*((unsigned char *)(c.q))) ++ ++/*************************************************/ ++ ++#define M_ASN1_I2D_vars(a) int r=0,ret=0; \ ++ unsigned char *p; \ ++ if (a == NULL) return(0) ++ ++/* Length Macros */ ++#define M_ASN1_I2D_len(a,f) ret+=f(a,NULL) ++#define M_ASN1_I2D_len_IMP_opt(a,f) if (a != NULL) M_ASN1_I2D_len(a,f) ++ ++#define M_ASN1_I2D_len_SET(a,f) \ ++ ret+=i2d_ASN1_SET(a,NULL,f,V_ASN1_SET,V_ASN1_UNIVERSAL,IS_SET); ++ ++#define M_ASN1_I2D_len_SET_type(type,a,f) \ ++ ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,V_ASN1_SET, \ ++ V_ASN1_UNIVERSAL,IS_SET); ++ ++#define M_ASN1_I2D_len_SEQUENCE(a,f) \ ++ ret+=i2d_ASN1_SET(a,NULL,f,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL, \ ++ IS_SEQUENCE); ++ ++#define M_ASN1_I2D_len_SEQUENCE_type(type,a,f) \ ++ ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,V_ASN1_SEQUENCE, \ ++ V_ASN1_UNIVERSAL,IS_SEQUENCE) ++ ++#define M_ASN1_I2D_len_SEQUENCE_opt(a,f) \ ++ if ((a != NULL) && (sk_num(a) != 0)) \ ++ M_ASN1_I2D_len_SEQUENCE(a,f); ++ ++#define M_ASN1_I2D_len_SEQUENCE_opt_type(type,a,f) \ ++ if ((a != NULL) && (sk_##type##_num(a) != 0)) \ ++ M_ASN1_I2D_len_SEQUENCE_type(type,a,f); ++ ++#define M_ASN1_I2D_len_IMP_SET(a,f,x) \ ++ ret+=i2d_ASN1_SET(a,NULL,f,x,V_ASN1_CONTEXT_SPECIFIC,IS_SET); ++ ++#define M_ASN1_I2D_len_IMP_SET_type(type,a,f,x) \ ++ ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,x, \ ++ V_ASN1_CONTEXT_SPECIFIC,IS_SET); ++ ++#define M_ASN1_I2D_len_IMP_SET_opt(a,f,x) \ ++ if ((a != NULL) && (sk_num(a) != 0)) \ ++ ret+=i2d_ASN1_SET(a,NULL,f,x,V_ASN1_CONTEXT_SPECIFIC, \ ++ IS_SET); ++ ++#define M_ASN1_I2D_len_IMP_SET_opt_type(type,a,f,x) \ ++ if ((a != NULL) && (sk_##type##_num(a) != 0)) \ ++ ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,x, \ ++ V_ASN1_CONTEXT_SPECIFIC,IS_SET); ++ ++#define M_ASN1_I2D_len_IMP_SEQUENCE(a,f,x) \ ++ ret+=i2d_ASN1_SET(a,NULL,f,x,V_ASN1_CONTEXT_SPECIFIC, \ ++ IS_SEQUENCE); ++ ++#define M_ASN1_I2D_len_IMP_SEQUENCE_opt(a,f,x) \ ++ if ((a != NULL) && (sk_num(a) != 0)) \ ++ ret+=i2d_ASN1_SET(a,NULL,f,x,V_ASN1_CONTEXT_SPECIFIC, \ ++ IS_SEQUENCE); ++ ++#define M_ASN1_I2D_len_IMP_SEQUENCE_opt_type(type,a,f,x) \ ++ if ((a != NULL) && (sk_##type##_num(a) != 0)) \ ++ ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,x, \ ++ V_ASN1_CONTEXT_SPECIFIC, \ ++ IS_SEQUENCE); ++ ++#define M_ASN1_I2D_len_EXP_opt(a,f,mtag,v) \ ++ if (a != NULL)\ ++ { \ ++ v=f(a,NULL); \ ++ ret+=ASN1_object_size(1,v,mtag); \ ++ } ++ ++#define M_ASN1_I2D_len_EXP_SET_opt(a,f,mtag,tag,v) \ ++ if ((a != NULL) && (sk_num(a) != 0))\ ++ { \ ++ v=i2d_ASN1_SET(a,NULL,f,tag,V_ASN1_UNIVERSAL,IS_SET); \ ++ ret+=ASN1_object_size(1,v,mtag); \ ++ } ++ ++#define M_ASN1_I2D_len_EXP_SEQUENCE_opt(a,f,mtag,tag,v) \ ++ if ((a != NULL) && (sk_num(a) != 0))\ ++ { \ ++ v=i2d_ASN1_SET(a,NULL,f,tag,V_ASN1_UNIVERSAL, \ ++ IS_SEQUENCE); \ ++ ret+=ASN1_object_size(1,v,mtag); \ ++ } ++ ++#define M_ASN1_I2D_len_EXP_SEQUENCE_opt_type(type,a,f,mtag,tag,v) \ ++ if ((a != NULL) && (sk_##type##_num(a) != 0))\ ++ { \ ++ v=i2d_ASN1_SET_OF_##type(a,NULL,f,tag, \ ++ V_ASN1_UNIVERSAL, \ ++ IS_SEQUENCE); \ ++ ret+=ASN1_object_size(1,v,mtag); \ ++ } ++ ++/* Put Macros */ ++#define M_ASN1_I2D_put(a,f) f(a,&p) ++ ++#define M_ASN1_I2D_put_IMP_opt(a,f,t) \ ++ if (a != NULL) \ ++ { \ ++ unsigned char *q=p; \ ++ f(a,&p); \ ++ *q=(V_ASN1_CONTEXT_SPECIFIC|t|(*q&V_ASN1_CONSTRUCTED));\ ++ } ++ ++#define M_ASN1_I2D_put_SET(a,f) i2d_ASN1_SET(a,&p,f,V_ASN1_SET,\ ++ V_ASN1_UNIVERSAL,IS_SET) ++#define M_ASN1_I2D_put_SET_type(type,a,f) \ ++ i2d_ASN1_SET_OF_##type(a,&p,f,V_ASN1_SET,V_ASN1_UNIVERSAL,IS_SET) ++#define M_ASN1_I2D_put_IMP_SET(a,f,x) i2d_ASN1_SET(a,&p,f,x,\ ++ V_ASN1_CONTEXT_SPECIFIC,IS_SET) ++#define M_ASN1_I2D_put_IMP_SET_type(type,a,f,x) \ ++ i2d_ASN1_SET_OF_##type(a,&p,f,x,V_ASN1_CONTEXT_SPECIFIC,IS_SET) ++#define M_ASN1_I2D_put_IMP_SEQUENCE(a,f,x) i2d_ASN1_SET(a,&p,f,x,\ ++ V_ASN1_CONTEXT_SPECIFIC,IS_SEQUENCE) ++ ++#define M_ASN1_I2D_put_SEQUENCE(a,f) i2d_ASN1_SET(a,&p,f,V_ASN1_SEQUENCE,\ ++ V_ASN1_UNIVERSAL,IS_SEQUENCE) ++ ++#define M_ASN1_I2D_put_SEQUENCE_type(type,a,f) \ ++ i2d_ASN1_SET_OF_##type(a,&p,f,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL, \ ++ IS_SEQUENCE) ++ ++#define M_ASN1_I2D_put_SEQUENCE_opt(a,f) \ ++ if ((a != NULL) && (sk_num(a) != 0)) \ ++ M_ASN1_I2D_put_SEQUENCE(a,f); ++ ++#define M_ASN1_I2D_put_IMP_SET_opt(a,f,x) \ ++ if ((a != NULL) && (sk_num(a) != 0)) \ ++ { i2d_ASN1_SET(a,&p,f,x,V_ASN1_CONTEXT_SPECIFIC, \ ++ IS_SET); } ++ ++#define M_ASN1_I2D_put_IMP_SET_opt_type(type,a,f,x) \ ++ if ((a != NULL) && (sk_##type##_num(a) != 0)) \ ++ { i2d_ASN1_SET_OF_##type(a,&p,f,x, \ ++ V_ASN1_CONTEXT_SPECIFIC, \ ++ IS_SET); } ++ ++#define M_ASN1_I2D_put_IMP_SEQUENCE_opt(a,f,x) \ ++ if ((a != NULL) && (sk_num(a) != 0)) \ ++ { i2d_ASN1_SET(a,&p,f,x,V_ASN1_CONTEXT_SPECIFIC, \ ++ IS_SEQUENCE); } ++ ++#define M_ASN1_I2D_put_IMP_SEQUENCE_opt_type(type,a,f,x) \ ++ if ((a != NULL) && (sk_##type##_num(a) != 0)) \ ++ { i2d_ASN1_SET_OF_##type(a,&p,f,x, \ ++ V_ASN1_CONTEXT_SPECIFIC, \ ++ IS_SEQUENCE); } ++ ++#define M_ASN1_I2D_put_EXP_opt(a,f,tag,v) \ ++ if (a != NULL) \ ++ { \ ++ ASN1_put_object(&p,1,v,tag,V_ASN1_CONTEXT_SPECIFIC); \ ++ f(a,&p); \ ++ } ++ ++#define M_ASN1_I2D_put_EXP_SET_opt(a,f,mtag,tag,v) \ ++ if ((a != NULL) && (sk_num(a) != 0)) \ ++ { \ ++ ASN1_put_object(&p,1,v,mtag,V_ASN1_CONTEXT_SPECIFIC); \ ++ i2d_ASN1_SET(a,&p,f,tag,V_ASN1_UNIVERSAL,IS_SET); \ ++ } ++ ++#define M_ASN1_I2D_put_EXP_SEQUENCE_opt(a,f,mtag,tag,v) \ ++ if ((a != NULL) && (sk_num(a) != 0)) \ ++ { \ ++ ASN1_put_object(&p,1,v,mtag,V_ASN1_CONTEXT_SPECIFIC); \ ++ i2d_ASN1_SET(a,&p,f,tag,V_ASN1_UNIVERSAL,IS_SEQUENCE); \ ++ } ++ ++#define M_ASN1_I2D_put_EXP_SEQUENCE_opt_type(type,a,f,mtag,tag,v) \ ++ if ((a != NULL) && (sk_##type##_num(a) != 0)) \ ++ { \ ++ ASN1_put_object(&p,1,v,mtag,V_ASN1_CONTEXT_SPECIFIC); \ ++ i2d_ASN1_SET_OF_##type(a,&p,f,tag,V_ASN1_UNIVERSAL, \ ++ IS_SEQUENCE); \ ++ } ++ ++#define M_ASN1_I2D_seq_total() \ ++ r=ASN1_object_size(1,ret,V_ASN1_SEQUENCE); \ ++ if (pp == NULL) return(r); \ ++ p= *pp; \ ++ ASN1_put_object(&p,1,ret,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL) ++ ++#define M_ASN1_I2D_INF_seq_start(tag,ctx) \ ++ *(p++)=(V_ASN1_CONSTRUCTED|(tag)|(ctx)); \ ++ *(p++)=0x80 ++ ++#define M_ASN1_I2D_INF_seq_end() *(p++)=0x00; *(p++)=0x00 ++ ++#define M_ASN1_I2D_finish() *pp=p; \ ++ return(r); ++ ++int asn1_GetSequence(ASN1_const_CTX *c, long *length); ++void asn1_add_error(const unsigned char *address,int offset); ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff -urN qt.orig/include/openssl/asn1t.h qt.patched/include/openssl/asn1t.h +--- qt.orig/include/openssl/asn1t.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/asn1t.h 2010-08-27 12:01:44.993294300 +0200 +@@ -0,0 +1,960 @@ ++/* asn1t.h */ ++/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL ++ * project 2000. ++ */ ++/* ==================================================================== ++ * Copyright (c) 2000-2005 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * licensing@OpenSSL.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++#ifndef HEADER_ASN1T_H ++#define HEADER_ASN1T_H ++ ++#include ++#include ++#include ++ ++#ifdef OPENSSL_BUILD_SHLIBCRYPTO ++# undef OPENSSL_EXTERN ++# define OPENSSL_EXTERN OPENSSL_EXPORT ++#endif ++ ++/* ASN1 template defines, structures and functions */ ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++ ++#ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION ++ ++/* Macro to obtain ASN1_ADB pointer from a type (only used internally) */ ++#define ASN1_ADB_ptr(iptr) ((const ASN1_ADB *)(iptr)) ++ ++ ++/* Macros for start and end of ASN1_ITEM definition */ ++ ++#define ASN1_ITEM_start(itname) \ ++ OPENSSL_GLOBAL const ASN1_ITEM itname##_it = { ++ ++#define ASN1_ITEM_end(itname) \ ++ }; ++ ++#else ++ ++/* Macro to obtain ASN1_ADB pointer from a type (only used internally) */ ++#define ASN1_ADB_ptr(iptr) ((const ASN1_ADB *)(iptr())) ++ ++ ++/* Macros for start and end of ASN1_ITEM definition */ ++ ++#define ASN1_ITEM_start(itname) \ ++ const ASN1_ITEM * itname##_it(void) \ ++ { \ ++ static const ASN1_ITEM local_it = { ++ ++#define ASN1_ITEM_end(itname) \ ++ }; \ ++ return &local_it; \ ++ } ++ ++#endif ++ ++ ++/* Macros to aid ASN1 template writing */ ++ ++#define ASN1_ITEM_TEMPLATE(tname) \ ++ static const ASN1_TEMPLATE tname##_item_tt ++ ++#define ASN1_ITEM_TEMPLATE_END(tname) \ ++ ;\ ++ ASN1_ITEM_start(tname) \ ++ ASN1_ITYPE_PRIMITIVE,\ ++ -1,\ ++ &tname##_item_tt,\ ++ 0,\ ++ NULL,\ ++ 0,\ ++ #tname \ ++ ASN1_ITEM_end(tname) ++ ++ ++/* This is a ASN1 type which just embeds a template */ ++ ++/* This pair helps declare a SEQUENCE. We can do: ++ * ++ * ASN1_SEQUENCE(stname) = { ++ * ... SEQUENCE components ... ++ * } ASN1_SEQUENCE_END(stname) ++ * ++ * This will produce an ASN1_ITEM called stname_it ++ * for a structure called stname. ++ * ++ * If you want the same structure but a different ++ * name then use: ++ * ++ * ASN1_SEQUENCE(itname) = { ++ * ... SEQUENCE components ... ++ * } ASN1_SEQUENCE_END_name(stname, itname) ++ * ++ * This will create an item called itname_it using ++ * a structure called stname. ++ */ ++ ++#define ASN1_SEQUENCE(tname) \ ++ static const ASN1_TEMPLATE tname##_seq_tt[] ++ ++#define ASN1_SEQUENCE_END(stname) ASN1_SEQUENCE_END_name(stname, stname) ++ ++#define ASN1_SEQUENCE_END_name(stname, tname) \ ++ ;\ ++ ASN1_ITEM_start(tname) \ ++ ASN1_ITYPE_SEQUENCE,\ ++ V_ASN1_SEQUENCE,\ ++ tname##_seq_tt,\ ++ sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ ++ NULL,\ ++ sizeof(stname),\ ++ #stname \ ++ ASN1_ITEM_end(tname) ++ ++#define ASN1_NDEF_SEQUENCE(tname) \ ++ ASN1_SEQUENCE(tname) ++ ++#define ASN1_NDEF_SEQUENCE_cb(tname, cb) \ ++ ASN1_SEQUENCE_cb(tname, cb) ++ ++#define ASN1_SEQUENCE_cb(tname, cb) \ ++ static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0}; \ ++ ASN1_SEQUENCE(tname) ++ ++#define ASN1_BROKEN_SEQUENCE(tname) \ ++ static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_BROKEN, 0, 0, 0, 0}; \ ++ ASN1_SEQUENCE(tname) ++ ++#define ASN1_SEQUENCE_ref(tname, cb, lck) \ ++ static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_REFCOUNT, offsetof(tname, references), lck, cb, 0}; \ ++ ASN1_SEQUENCE(tname) ++ ++#define ASN1_SEQUENCE_enc(tname, enc, cb) \ ++ static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_ENCODING, 0, 0, cb, offsetof(tname, enc)}; \ ++ ASN1_SEQUENCE(tname) ++ ++#define ASN1_NDEF_SEQUENCE_END(tname) \ ++ ;\ ++ ASN1_ITEM_start(tname) \ ++ ASN1_ITYPE_NDEF_SEQUENCE,\ ++ V_ASN1_SEQUENCE,\ ++ tname##_seq_tt,\ ++ sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ ++ NULL,\ ++ sizeof(tname),\ ++ #tname \ ++ ASN1_ITEM_end(tname) ++ ++#define ASN1_BROKEN_SEQUENCE_END(stname) ASN1_SEQUENCE_END_ref(stname, stname) ++ ++#define ASN1_SEQUENCE_END_enc(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname) ++ ++#define ASN1_SEQUENCE_END_cb(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname) ++ ++#define ASN1_SEQUENCE_END_ref(stname, tname) \ ++ ;\ ++ ASN1_ITEM_start(tname) \ ++ ASN1_ITYPE_SEQUENCE,\ ++ V_ASN1_SEQUENCE,\ ++ tname##_seq_tt,\ ++ sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ ++ &tname##_aux,\ ++ sizeof(stname),\ ++ #stname \ ++ ASN1_ITEM_end(tname) ++ ++#define ASN1_NDEF_SEQUENCE_END_cb(stname, tname) \ ++ ;\ ++ ASN1_ITEM_start(tname) \ ++ ASN1_ITYPE_NDEF_SEQUENCE,\ ++ V_ASN1_SEQUENCE,\ ++ tname##_seq_tt,\ ++ sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ ++ &tname##_aux,\ ++ sizeof(stname),\ ++ #stname \ ++ ASN1_ITEM_end(tname) ++ ++ ++/* This pair helps declare a CHOICE type. We can do: ++ * ++ * ASN1_CHOICE(chname) = { ++ * ... CHOICE options ... ++ * ASN1_CHOICE_END(chname) ++ * ++ * This will produce an ASN1_ITEM called chname_it ++ * for a structure called chname. The structure ++ * definition must look like this: ++ * typedef struct { ++ * int type; ++ * union { ++ * ASN1_SOMETHING *opt1; ++ * ASN1_SOMEOTHER *opt2; ++ * } value; ++ * } chname; ++ * ++ * the name of the selector must be 'type'. ++ * to use an alternative selector name use the ++ * ASN1_CHOICE_END_selector() version. ++ */ ++ ++#define ASN1_CHOICE(tname) \ ++ static const ASN1_TEMPLATE tname##_ch_tt[] ++ ++#define ASN1_CHOICE_cb(tname, cb) \ ++ static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0}; \ ++ ASN1_CHOICE(tname) ++ ++#define ASN1_CHOICE_END(stname) ASN1_CHOICE_END_name(stname, stname) ++ ++#define ASN1_CHOICE_END_name(stname, tname) ASN1_CHOICE_END_selector(stname, tname, type) ++ ++#define ASN1_CHOICE_END_selector(stname, tname, selname) \ ++ ;\ ++ ASN1_ITEM_start(tname) \ ++ ASN1_ITYPE_CHOICE,\ ++ offsetof(stname,selname) ,\ ++ tname##_ch_tt,\ ++ sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\ ++ NULL,\ ++ sizeof(stname),\ ++ #stname \ ++ ASN1_ITEM_end(tname) ++ ++#define ASN1_CHOICE_END_cb(stname, tname, selname) \ ++ ;\ ++ ASN1_ITEM_start(tname) \ ++ ASN1_ITYPE_CHOICE,\ ++ offsetof(stname,selname) ,\ ++ tname##_ch_tt,\ ++ sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\ ++ &tname##_aux,\ ++ sizeof(stname),\ ++ #stname \ ++ ASN1_ITEM_end(tname) ++ ++/* This helps with the template wrapper form of ASN1_ITEM */ ++ ++#define ASN1_EX_TEMPLATE_TYPE(flags, tag, name, type) { \ ++ (flags), (tag), 0,\ ++ #name, ASN1_ITEM_ref(type) } ++ ++/* These help with SEQUENCE or CHOICE components */ ++ ++/* used to declare other types */ ++ ++#define ASN1_EX_TYPE(flags, tag, stname, field, type) { \ ++ (flags), (tag), offsetof(stname, field),\ ++ #field, ASN1_ITEM_ref(type) } ++ ++/* used when the structure is combined with the parent */ ++ ++#define ASN1_EX_COMBINE(flags, tag, type) { \ ++ (flags)|ASN1_TFLG_COMBINE, (tag), 0, NULL, ASN1_ITEM_ref(type) } ++ ++/* implicit and explicit helper macros */ ++ ++#define ASN1_IMP_EX(stname, field, type, tag, ex) \ ++ ASN1_EX_TYPE(ASN1_TFLG_IMPLICIT | ex, tag, stname, field, type) ++ ++#define ASN1_EXP_EX(stname, field, type, tag, ex) \ ++ ASN1_EX_TYPE(ASN1_TFLG_EXPLICIT | ex, tag, stname, field, type) ++ ++/* Any defined by macros: the field used is in the table itself */ ++ ++#ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION ++#define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, (const ASN1_ITEM *)&(tblname##_adb) } ++#define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, (const ASN1_ITEM *)&(tblname##_adb) } ++#else ++#define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, tblname##_adb } ++#define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, tblname##_adb } ++#endif ++/* Plain simple type */ ++#define ASN1_SIMPLE(stname, field, type) ASN1_EX_TYPE(0,0, stname, field, type) ++ ++/* OPTIONAL simple type */ ++#define ASN1_OPT(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL, 0, stname, field, type) ++ ++/* IMPLICIT tagged simple type */ ++#define ASN1_IMP(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, 0) ++ ++/* IMPLICIT tagged OPTIONAL simple type */ ++#define ASN1_IMP_OPT(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL) ++ ++/* Same as above but EXPLICIT */ ++ ++#define ASN1_EXP(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, 0) ++#define ASN1_EXP_OPT(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL) ++ ++/* SEQUENCE OF type */ ++#define ASN1_SEQUENCE_OF(stname, field, type) \ ++ ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, stname, field, type) ++ ++/* OPTIONAL SEQUENCE OF */ ++#define ASN1_SEQUENCE_OF_OPT(stname, field, type) \ ++ ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type) ++ ++/* Same as above but for SET OF */ ++ ++#define ASN1_SET_OF(stname, field, type) \ ++ ASN1_EX_TYPE(ASN1_TFLG_SET_OF, 0, stname, field, type) ++ ++#define ASN1_SET_OF_OPT(stname, field, type) \ ++ ASN1_EX_TYPE(ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type) ++ ++/* Finally compound types of SEQUENCE, SET, IMPLICIT, EXPLICIT and OPTIONAL */ ++ ++#define ASN1_IMP_SET_OF(stname, field, type, tag) \ ++ ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF) ++ ++#define ASN1_EXP_SET_OF(stname, field, type, tag) \ ++ ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF) ++ ++#define ASN1_IMP_SET_OF_OPT(stname, field, type, tag) \ ++ ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL) ++ ++#define ASN1_EXP_SET_OF_OPT(stname, field, type, tag) \ ++ ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL) ++ ++#define ASN1_IMP_SEQUENCE_OF(stname, field, type, tag) \ ++ ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF) ++ ++#define ASN1_IMP_SEQUENCE_OF_OPT(stname, field, type, tag) \ ++ ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL) ++ ++#define ASN1_EXP_SEQUENCE_OF(stname, field, type, tag) \ ++ ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF) ++ ++#define ASN1_EXP_SEQUENCE_OF_OPT(stname, field, type, tag) \ ++ ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL) ++ ++/* EXPLICIT using indefinite length constructed form */ ++#define ASN1_NDEF_EXP(stname, field, type, tag) \ ++ ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_NDEF) ++ ++/* EXPLICIT OPTIONAL using indefinite length constructed form */ ++#define ASN1_NDEF_EXP_OPT(stname, field, type, tag) \ ++ ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_NDEF) ++ ++/* Macros for the ASN1_ADB structure */ ++ ++#define ASN1_ADB(name) \ ++ static const ASN1_ADB_TABLE name##_adbtbl[] ++ ++#ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION ++ ++#define ASN1_ADB_END(name, flags, field, app_table, def, none) \ ++ ;\ ++ static const ASN1_ADB name##_adb = {\ ++ flags,\ ++ offsetof(name, field),\ ++ app_table,\ ++ name##_adbtbl,\ ++ sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\ ++ def,\ ++ none\ ++ } ++ ++#else ++ ++#define ASN1_ADB_END(name, flags, field, app_table, def, none) \ ++ ;\ ++ static const ASN1_ITEM *name##_adb(void) \ ++ { \ ++ static const ASN1_ADB internal_adb = \ ++ {\ ++ flags,\ ++ offsetof(name, field),\ ++ app_table,\ ++ name##_adbtbl,\ ++ sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\ ++ def,\ ++ none\ ++ }; \ ++ return (const ASN1_ITEM *) &internal_adb; \ ++ } \ ++ void dummy_function(void) ++ ++#endif ++ ++#define ADB_ENTRY(val, template) {val, template} ++ ++#define ASN1_ADB_TEMPLATE(name) \ ++ static const ASN1_TEMPLATE name##_tt ++ ++/* This is the ASN1 template structure that defines ++ * a wrapper round the actual type. It determines the ++ * actual position of the field in the value structure, ++ * various flags such as OPTIONAL and the field name. ++ */ ++ ++struct ASN1_TEMPLATE_st { ++unsigned long flags; /* Various flags */ ++long tag; /* tag, not used if no tagging */ ++unsigned long offset; /* Offset of this field in structure */ ++#ifndef NO_ASN1_FIELD_NAMES ++const char *field_name; /* Field name */ ++#endif ++ASN1_ITEM_EXP *item; /* Relevant ASN1_ITEM or ASN1_ADB */ ++}; ++ ++/* Macro to extract ASN1_ITEM and ASN1_ADB pointer from ASN1_TEMPLATE */ ++ ++#define ASN1_TEMPLATE_item(t) (t->item_ptr) ++#define ASN1_TEMPLATE_adb(t) (t->item_ptr) ++ ++typedef struct ASN1_ADB_TABLE_st ASN1_ADB_TABLE; ++typedef struct ASN1_ADB_st ASN1_ADB; ++ ++struct ASN1_ADB_st { ++ unsigned long flags; /* Various flags */ ++ unsigned long offset; /* Offset of selector field */ ++ STACK_OF(ASN1_ADB_TABLE) **app_items; /* Application defined items */ ++ const ASN1_ADB_TABLE *tbl; /* Table of possible types */ ++ long tblcount; /* Number of entries in tbl */ ++ const ASN1_TEMPLATE *default_tt; /* Type to use if no match */ ++ const ASN1_TEMPLATE *null_tt; /* Type to use if selector is NULL */ ++}; ++ ++struct ASN1_ADB_TABLE_st { ++ long value; /* NID for an object or value for an int */ ++ const ASN1_TEMPLATE tt; /* item for this value */ ++}; ++ ++/* template flags */ ++ ++/* Field is optional */ ++#define ASN1_TFLG_OPTIONAL (0x1) ++ ++/* Field is a SET OF */ ++#define ASN1_TFLG_SET_OF (0x1 << 1) ++ ++/* Field is a SEQUENCE OF */ ++#define ASN1_TFLG_SEQUENCE_OF (0x2 << 1) ++ ++/* Special case: this refers to a SET OF that ++ * will be sorted into DER order when encoded *and* ++ * the corresponding STACK will be modified to match ++ * the new order. ++ */ ++#define ASN1_TFLG_SET_ORDER (0x3 << 1) ++ ++/* Mask for SET OF or SEQUENCE OF */ ++#define ASN1_TFLG_SK_MASK (0x3 << 1) ++ ++/* These flags mean the tag should be taken from the ++ * tag field. If EXPLICIT then the underlying type ++ * is used for the inner tag. ++ */ ++ ++/* IMPLICIT tagging */ ++#define ASN1_TFLG_IMPTAG (0x1 << 3) ++ ++ ++/* EXPLICIT tagging, inner tag from underlying type */ ++#define ASN1_TFLG_EXPTAG (0x2 << 3) ++ ++#define ASN1_TFLG_TAG_MASK (0x3 << 3) ++ ++/* context specific IMPLICIT */ ++#define ASN1_TFLG_IMPLICIT ASN1_TFLG_IMPTAG|ASN1_TFLG_CONTEXT ++ ++/* context specific EXPLICIT */ ++#define ASN1_TFLG_EXPLICIT ASN1_TFLG_EXPTAG|ASN1_TFLG_CONTEXT ++ ++/* If tagging is in force these determine the ++ * type of tag to use. Otherwise the tag is ++ * determined by the underlying type. These ++ * values reflect the actual octet format. ++ */ ++ ++/* Universal tag */ ++#define ASN1_TFLG_UNIVERSAL (0x0<<6) ++/* Application tag */ ++#define ASN1_TFLG_APPLICATION (0x1<<6) ++/* Context specific tag */ ++#define ASN1_TFLG_CONTEXT (0x2<<6) ++/* Private tag */ ++#define ASN1_TFLG_PRIVATE (0x3<<6) ++ ++#define ASN1_TFLG_TAG_CLASS (0x3<<6) ++ ++/* These are for ANY DEFINED BY type. In this case ++ * the 'item' field points to an ASN1_ADB structure ++ * which contains a table of values to decode the ++ * relevant type ++ */ ++ ++#define ASN1_TFLG_ADB_MASK (0x3<<8) ++ ++#define ASN1_TFLG_ADB_OID (0x1<<8) ++ ++#define ASN1_TFLG_ADB_INT (0x1<<9) ++ ++/* This flag means a parent structure is passed ++ * instead of the field: this is useful is a ++ * SEQUENCE is being combined with a CHOICE for ++ * example. Since this means the structure and ++ * item name will differ we need to use the ++ * ASN1_CHOICE_END_name() macro for example. ++ */ ++ ++#define ASN1_TFLG_COMBINE (0x1<<10) ++ ++/* This flag when present in a SEQUENCE OF, SET OF ++ * or EXPLICIT causes indefinite length constructed ++ * encoding to be used if required. ++ */ ++ ++#define ASN1_TFLG_NDEF (0x1<<11) ++ ++/* This is the actual ASN1 item itself */ ++ ++struct ASN1_ITEM_st { ++char itype; /* The item type, primitive, SEQUENCE, CHOICE or extern */ ++long utype; /* underlying type */ ++const ASN1_TEMPLATE *templates; /* If SEQUENCE or CHOICE this contains the contents */ ++long tcount; /* Number of templates if SEQUENCE or CHOICE */ ++const void *funcs; /* functions that handle this type */ ++long size; /* Structure size (usually)*/ ++#ifndef NO_ASN1_FIELD_NAMES ++const char *sname; /* Structure name */ ++#endif ++}; ++ ++/* These are values for the itype field and ++ * determine how the type is interpreted. ++ * ++ * For PRIMITIVE types the underlying type ++ * determines the behaviour if items is NULL. ++ * ++ * Otherwise templates must contain a single ++ * template and the type is treated in the ++ * same way as the type specified in the template. ++ * ++ * For SEQUENCE types the templates field points ++ * to the members, the size field is the ++ * structure size. ++ * ++ * For CHOICE types the templates field points ++ * to each possible member (typically a union) ++ * and the 'size' field is the offset of the ++ * selector. ++ * ++ * The 'funcs' field is used for application ++ * specific functions. ++ * ++ * For COMPAT types the funcs field gives a ++ * set of functions that handle this type, this ++ * supports the old d2i, i2d convention. ++ * ++ * The EXTERN type uses a new style d2i/i2d. ++ * The new style should be used where possible ++ * because it avoids things like the d2i IMPLICIT ++ * hack. ++ * ++ * MSTRING is a multiple string type, it is used ++ * for a CHOICE of character strings where the ++ * actual strings all occupy an ASN1_STRING ++ * structure. In this case the 'utype' field ++ * has a special meaning, it is used as a mask ++ * of acceptable types using the B_ASN1 constants. ++ * ++ * NDEF_SEQUENCE is the same as SEQUENCE except ++ * that it will use indefinite length constructed ++ * encoding if requested. ++ * ++ */ ++ ++#define ASN1_ITYPE_PRIMITIVE 0x0 ++ ++#define ASN1_ITYPE_SEQUENCE 0x1 ++ ++#define ASN1_ITYPE_CHOICE 0x2 ++ ++#define ASN1_ITYPE_COMPAT 0x3 ++ ++#define ASN1_ITYPE_EXTERN 0x4 ++ ++#define ASN1_ITYPE_MSTRING 0x5 ++ ++#define ASN1_ITYPE_NDEF_SEQUENCE 0x6 ++ ++/* Cache for ASN1 tag and length, so we ++ * don't keep re-reading it for things ++ * like CHOICE ++ */ ++ ++struct ASN1_TLC_st{ ++ char valid; /* Values below are valid */ ++ int ret; /* return value */ ++ long plen; /* length */ ++ int ptag; /* class value */ ++ int pclass; /* class value */ ++ int hdrlen; /* header length */ ++}; ++ ++/* Typedefs for ASN1 function pointers */ ++ ++typedef ASN1_VALUE * ASN1_new_func(void); ++typedef void ASN1_free_func(ASN1_VALUE *a); ++typedef ASN1_VALUE * ASN1_d2i_func(ASN1_VALUE **a, const unsigned char ** in, long length); ++typedef int ASN1_i2d_func(ASN1_VALUE * a, unsigned char **in); ++ ++typedef int ASN1_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, const ASN1_ITEM *it, ++ int tag, int aclass, char opt, ASN1_TLC *ctx); ++ ++typedef int ASN1_ex_i2d(ASN1_VALUE **pval, unsigned char **out, const ASN1_ITEM *it, int tag, int aclass); ++typedef int ASN1_ex_new_func(ASN1_VALUE **pval, const ASN1_ITEM *it); ++typedef void ASN1_ex_free_func(ASN1_VALUE **pval, const ASN1_ITEM *it); ++ ++typedef int ASN1_ex_print_func(BIO *out, ASN1_VALUE **pval, ++ int indent, const char *fname, ++ const ASN1_PCTX *pctx); ++ ++typedef int ASN1_primitive_i2c(ASN1_VALUE **pval, unsigned char *cont, int *putype, const ASN1_ITEM *it); ++typedef int ASN1_primitive_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len, int utype, char *free_cont, const ASN1_ITEM *it); ++typedef int ASN1_primitive_print(BIO *out, ASN1_VALUE **pval, const ASN1_ITEM *it, int indent, const ASN1_PCTX *pctx); ++ ++typedef struct ASN1_COMPAT_FUNCS_st { ++ ASN1_new_func *asn1_new; ++ ASN1_free_func *asn1_free; ++ ASN1_d2i_func *asn1_d2i; ++ ASN1_i2d_func *asn1_i2d; ++} ASN1_COMPAT_FUNCS; ++ ++typedef struct ASN1_EXTERN_FUNCS_st { ++ void *app_data; ++ ASN1_ex_new_func *asn1_ex_new; ++ ASN1_ex_free_func *asn1_ex_free; ++ ASN1_ex_free_func *asn1_ex_clear; ++ ASN1_ex_d2i *asn1_ex_d2i; ++ ASN1_ex_i2d *asn1_ex_i2d; ++ ASN1_ex_print_func *asn1_ex_print; ++} ASN1_EXTERN_FUNCS; ++ ++typedef struct ASN1_PRIMITIVE_FUNCS_st { ++ void *app_data; ++ unsigned long flags; ++ ASN1_ex_new_func *prim_new; ++ ASN1_ex_free_func *prim_free; ++ ASN1_ex_free_func *prim_clear; ++ ASN1_primitive_c2i *prim_c2i; ++ ASN1_primitive_i2c *prim_i2c; ++ ASN1_primitive_print *prim_print; ++} ASN1_PRIMITIVE_FUNCS; ++ ++/* This is the ASN1_AUX structure: it handles various ++ * miscellaneous requirements. For example the use of ++ * reference counts and an informational callback. ++ * ++ * The "informational callback" is called at various ++ * points during the ASN1 encoding and decoding. It can ++ * be used to provide minor customisation of the structures ++ * used. This is most useful where the supplied routines ++ * *almost* do the right thing but need some extra help ++ * at a few points. If the callback returns zero then ++ * it is assumed a fatal error has occurred and the ++ * main operation should be abandoned. ++ * ++ * If major changes in the default behaviour are required ++ * then an external type is more appropriate. ++ */ ++ ++typedef int ASN1_aux_cb(int operation, ASN1_VALUE **in, const ASN1_ITEM *it, ++ void *exarg); ++ ++typedef struct ASN1_AUX_st { ++ void *app_data; ++ int flags; ++ int ref_offset; /* Offset of reference value */ ++ int ref_lock; /* Lock type to use */ ++ ASN1_aux_cb *asn1_cb; ++ int enc_offset; /* Offset of ASN1_ENCODING structure */ ++} ASN1_AUX; ++ ++/* For print related callbacks exarg points to this structure */ ++typedef struct ASN1_PRINT_ARG_st { ++ BIO *out; ++ int indent; ++ const ASN1_PCTX *pctx; ++} ASN1_PRINT_ARG; ++ ++/* For streaming related callbacks exarg points to this structure */ ++typedef struct ASN1_STREAM_ARG_st { ++ /* BIO to stream through */ ++ BIO *out; ++ /* BIO with filters appended */ ++ BIO *ndef_bio; ++ /* Streaming I/O boundary */ ++ unsigned char **boundary; ++} ASN1_STREAM_ARG; ++ ++/* Flags in ASN1_AUX */ ++ ++/* Use a reference count */ ++#define ASN1_AFLG_REFCOUNT 1 ++/* Save the encoding of structure (useful for signatures) */ ++#define ASN1_AFLG_ENCODING 2 ++/* The Sequence length is invalid */ ++#define ASN1_AFLG_BROKEN 4 ++ ++/* operation values for asn1_cb */ ++ ++#define ASN1_OP_NEW_PRE 0 ++#define ASN1_OP_NEW_POST 1 ++#define ASN1_OP_FREE_PRE 2 ++#define ASN1_OP_FREE_POST 3 ++#define ASN1_OP_D2I_PRE 4 ++#define ASN1_OP_D2I_POST 5 ++#define ASN1_OP_I2D_PRE 6 ++#define ASN1_OP_I2D_POST 7 ++#define ASN1_OP_PRINT_PRE 8 ++#define ASN1_OP_PRINT_POST 9 ++#define ASN1_OP_STREAM_PRE 10 ++#define ASN1_OP_STREAM_POST 11 ++#define ASN1_OP_DETACHED_PRE 12 ++#define ASN1_OP_DETACHED_POST 13 ++ ++/* Macro to implement a primitive type */ ++#define IMPLEMENT_ASN1_TYPE(stname) IMPLEMENT_ASN1_TYPE_ex(stname, stname, 0) ++#define IMPLEMENT_ASN1_TYPE_ex(itname, vname, ex) \ ++ ASN1_ITEM_start(itname) \ ++ ASN1_ITYPE_PRIMITIVE, V_##vname, NULL, 0, NULL, ex, #itname \ ++ ASN1_ITEM_end(itname) ++ ++/* Macro to implement a multi string type */ ++#define IMPLEMENT_ASN1_MSTRING(itname, mask) \ ++ ASN1_ITEM_start(itname) \ ++ ASN1_ITYPE_MSTRING, mask, NULL, 0, NULL, sizeof(ASN1_STRING), #itname \ ++ ASN1_ITEM_end(itname) ++ ++/* Macro to implement an ASN1_ITEM in terms of old style funcs */ ++ ++#define IMPLEMENT_COMPAT_ASN1(sname) IMPLEMENT_COMPAT_ASN1_type(sname, V_ASN1_SEQUENCE) ++ ++#define IMPLEMENT_COMPAT_ASN1_type(sname, tag) \ ++ static const ASN1_COMPAT_FUNCS sname##_ff = { \ ++ (ASN1_new_func *)sname##_new, \ ++ (ASN1_free_func *)sname##_free, \ ++ (ASN1_d2i_func *)d2i_##sname, \ ++ (ASN1_i2d_func *)i2d_##sname, \ ++ }; \ ++ ASN1_ITEM_start(sname) \ ++ ASN1_ITYPE_COMPAT, \ ++ tag, \ ++ NULL, \ ++ 0, \ ++ &sname##_ff, \ ++ 0, \ ++ #sname \ ++ ASN1_ITEM_end(sname) ++ ++#define IMPLEMENT_EXTERN_ASN1(sname, tag, fptrs) \ ++ ASN1_ITEM_start(sname) \ ++ ASN1_ITYPE_EXTERN, \ ++ tag, \ ++ NULL, \ ++ 0, \ ++ &fptrs, \ ++ 0, \ ++ #sname \ ++ ASN1_ITEM_end(sname) ++ ++/* Macro to implement standard functions in terms of ASN1_ITEM structures */ ++ ++#define IMPLEMENT_ASN1_FUNCTIONS(stname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, stname, stname) ++ ++#define IMPLEMENT_ASN1_FUNCTIONS_name(stname, itname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, itname) ++ ++#define IMPLEMENT_ASN1_FUNCTIONS_ENCODE_name(stname, itname) \ ++ IMPLEMENT_ASN1_FUNCTIONS_ENCODE_fname(stname, itname, itname) ++ ++#define IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(stname) \ ++ IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(static, stname, stname, stname) ++ ++#define IMPLEMENT_ASN1_ALLOC_FUNCTIONS(stname) \ ++ IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, stname, stname) ++ ++#define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(pre, stname, itname, fname) \ ++ pre stname *fname##_new(void) \ ++ { \ ++ return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \ ++ } \ ++ pre void fname##_free(stname *a) \ ++ { \ ++ ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \ ++ } ++ ++#define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) \ ++ stname *fname##_new(void) \ ++ { \ ++ return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \ ++ } \ ++ void fname##_free(stname *a) \ ++ { \ ++ ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \ ++ } ++ ++#define IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, fname) \ ++ IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \ ++ IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) ++ ++#define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \ ++ stname *d2i_##fname(stname **a, const unsigned char **in, long len) \ ++ { \ ++ return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\ ++ } \ ++ int i2d_##fname(stname *a, unsigned char **out) \ ++ { \ ++ return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\ ++ } ++ ++#define IMPLEMENT_ASN1_NDEF_FUNCTION(stname) \ ++ int i2d_##stname##_NDEF(stname *a, unsigned char **out) \ ++ { \ ++ return ASN1_item_ndef_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(stname));\ ++ } ++ ++/* This includes evil casts to remove const: they will go away when full ++ * ASN1 constification is done. ++ */ ++#define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \ ++ stname *d2i_##fname(stname **a, const unsigned char **in, long len) \ ++ { \ ++ return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\ ++ } \ ++ int i2d_##fname(const stname *a, unsigned char **out) \ ++ { \ ++ return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\ ++ } ++ ++#define IMPLEMENT_ASN1_DUP_FUNCTION(stname) \ ++ stname * stname##_dup(stname *x) \ ++ { \ ++ return ASN1_item_dup(ASN1_ITEM_rptr(stname), x); \ ++ } ++ ++#define IMPLEMENT_ASN1_PRINT_FUNCTION(stname) \ ++ IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, stname, stname) ++ ++#define IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, itname, fname) \ ++ int fname##_print_ctx(BIO *out, stname *x, int indent, \ ++ const ASN1_PCTX *pctx) \ ++ { \ ++ return ASN1_item_print(out, (ASN1_VALUE *)x, indent, \ ++ ASN1_ITEM_rptr(itname), pctx); \ ++ } ++ ++#define IMPLEMENT_ASN1_FUNCTIONS_const(name) \ ++ IMPLEMENT_ASN1_FUNCTIONS_const_fname(name, name, name) ++ ++#define IMPLEMENT_ASN1_FUNCTIONS_const_fname(stname, itname, fname) \ ++ IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \ ++ IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) ++ ++/* external definitions for primitive types */ ++ ++DECLARE_ASN1_ITEM(ASN1_BOOLEAN) ++DECLARE_ASN1_ITEM(ASN1_TBOOLEAN) ++DECLARE_ASN1_ITEM(ASN1_FBOOLEAN) ++DECLARE_ASN1_ITEM(ASN1_SEQUENCE) ++DECLARE_ASN1_ITEM(CBIGNUM) ++DECLARE_ASN1_ITEM(BIGNUM) ++DECLARE_ASN1_ITEM(LONG) ++DECLARE_ASN1_ITEM(ZLONG) ++ ++DECLARE_STACK_OF(ASN1_VALUE) ++ ++/* Functions used internally by the ASN1 code */ ++ ++int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it); ++void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it); ++int ASN1_template_new(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt); ++int ASN1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it); ++ ++void ASN1_template_free(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt); ++int ASN1_template_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, const ASN1_TEMPLATE *tt); ++int ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, const ASN1_ITEM *it, ++ int tag, int aclass, char opt, ASN1_TLC *ctx); ++ ++int ASN1_item_ex_i2d(ASN1_VALUE **pval, unsigned char **out, const ASN1_ITEM *it, int tag, int aclass); ++int ASN1_template_i2d(ASN1_VALUE **pval, unsigned char **out, const ASN1_TEMPLATE *tt); ++void ASN1_primitive_free(ASN1_VALUE **pval, const ASN1_ITEM *it); ++ ++int asn1_ex_i2c(ASN1_VALUE **pval, unsigned char *cont, int *putype, const ASN1_ITEM *it); ++int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len, int utype, char *free_cont, const ASN1_ITEM *it); ++ ++int asn1_get_choice_selector(ASN1_VALUE **pval, const ASN1_ITEM *it); ++int asn1_set_choice_selector(ASN1_VALUE **pval, int value, const ASN1_ITEM *it); ++ ++ASN1_VALUE ** asn1_get_field_ptr(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt); ++ ++const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt, int nullerr); ++ ++int asn1_do_lock(ASN1_VALUE **pval, int op, const ASN1_ITEM *it); ++ ++void asn1_enc_init(ASN1_VALUE **pval, const ASN1_ITEM *it); ++void asn1_enc_free(ASN1_VALUE **pval, const ASN1_ITEM *it); ++int asn1_enc_restore(int *len, unsigned char **out, ASN1_VALUE **pval, const ASN1_ITEM *it); ++int asn1_enc_save(ASN1_VALUE **pval, const unsigned char *in, int inlen, const ASN1_ITEM *it); ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/bio.h qt.patched/include/openssl/bio.h +--- qt.orig/include/openssl/bio.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/bio.h 2010-08-27 12:01:45.008918700 +0200 +@@ -0,0 +1,770 @@ ++/* crypto/bio/bio.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_BIO_H ++#define HEADER_BIO_H ++ ++#include ++ ++#ifndef OPENSSL_NO_FP_API ++# include ++#endif ++#include ++ ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* These are the 'types' of BIOs */ ++#define BIO_TYPE_NONE 0 ++#define BIO_TYPE_MEM (1|0x0400) ++#define BIO_TYPE_FILE (2|0x0400) ++ ++#define BIO_TYPE_FD (4|0x0400|0x0100) ++#define BIO_TYPE_SOCKET (5|0x0400|0x0100) ++#define BIO_TYPE_NULL (6|0x0400) ++#define BIO_TYPE_SSL (7|0x0200) ++#define BIO_TYPE_MD (8|0x0200) /* passive filter */ ++#define BIO_TYPE_BUFFER (9|0x0200) /* filter */ ++#define BIO_TYPE_CIPHER (10|0x0200) /* filter */ ++#define BIO_TYPE_BASE64 (11|0x0200) /* filter */ ++#define BIO_TYPE_CONNECT (12|0x0400|0x0100) /* socket - connect */ ++#define BIO_TYPE_ACCEPT (13|0x0400|0x0100) /* socket for accept */ ++#define BIO_TYPE_PROXY_CLIENT (14|0x0200) /* client proxy BIO */ ++#define BIO_TYPE_PROXY_SERVER (15|0x0200) /* server proxy BIO */ ++#define BIO_TYPE_NBIO_TEST (16|0x0200) /* server proxy BIO */ ++#define BIO_TYPE_NULL_FILTER (17|0x0200) ++#define BIO_TYPE_BER (18|0x0200) /* BER -> bin filter */ ++#define BIO_TYPE_BIO (19|0x0400) /* (half a) BIO pair */ ++#define BIO_TYPE_LINEBUFFER (20|0x0200) /* filter */ ++#define BIO_TYPE_DGRAM (21|0x0400|0x0100) ++#define BIO_TYPE_ASN1 (22|0x0200) /* filter */ ++#define BIO_TYPE_COMP (23|0x0200) /* filter */ ++ ++#define BIO_TYPE_DESCRIPTOR 0x0100 /* socket, fd, connect or accept */ ++#define BIO_TYPE_FILTER 0x0200 ++#define BIO_TYPE_SOURCE_SINK 0x0400 ++ ++/* BIO_FILENAME_READ|BIO_CLOSE to open or close on free. ++ * BIO_set_fp(in,stdin,BIO_NOCLOSE); */ ++#define BIO_NOCLOSE 0x00 ++#define BIO_CLOSE 0x01 ++ ++/* These are used in the following macros and are passed to ++ * BIO_ctrl() */ ++#define BIO_CTRL_RESET 1 /* opt - rewind/zero etc */ ++#define BIO_CTRL_EOF 2 /* opt - are we at the eof */ ++#define BIO_CTRL_INFO 3 /* opt - extra tit-bits */ ++#define BIO_CTRL_SET 4 /* man - set the 'IO' type */ ++#define BIO_CTRL_GET 5 /* man - get the 'IO' type */ ++#define BIO_CTRL_PUSH 6 /* opt - internal, used to signify change */ ++#define BIO_CTRL_POP 7 /* opt - internal, used to signify change */ ++#define BIO_CTRL_GET_CLOSE 8 /* man - set the 'close' on free */ ++#define BIO_CTRL_SET_CLOSE 9 /* man - set the 'close' on free */ ++#define BIO_CTRL_PENDING 10 /* opt - is their more data buffered */ ++#define BIO_CTRL_FLUSH 11 /* opt - 'flush' buffered output */ ++#define BIO_CTRL_DUP 12 /* man - extra stuff for 'duped' BIO */ ++#define BIO_CTRL_WPENDING 13 /* opt - number of bytes still to write */ ++/* callback is int cb(BIO *bio,state,ret); */ ++#define BIO_CTRL_SET_CALLBACK 14 /* opt - set callback function */ ++#define BIO_CTRL_GET_CALLBACK 15 /* opt - set callback function */ ++ ++#define BIO_CTRL_SET_FILENAME 30 /* BIO_s_file special */ ++ ++/* dgram BIO stuff */ ++#define BIO_CTRL_DGRAM_CONNECT 31 /* BIO dgram special */ ++#define BIO_CTRL_DGRAM_SET_CONNECTED 32 /* allow for an externally ++ * connected socket to be ++ * passed in */ ++#define BIO_CTRL_DGRAM_SET_RECV_TIMEOUT 33 /* setsockopt, essentially */ ++#define BIO_CTRL_DGRAM_GET_RECV_TIMEOUT 34 /* getsockopt, essentially */ ++#define BIO_CTRL_DGRAM_SET_SEND_TIMEOUT 35 /* setsockopt, essentially */ ++#define BIO_CTRL_DGRAM_GET_SEND_TIMEOUT 36 /* getsockopt, essentially */ ++ ++#define BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP 37 /* flag whether the last */ ++#define BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP 38 /* I/O operation tiemd out */ ++ ++/* #ifdef IP_MTU_DISCOVER */ ++#define BIO_CTRL_DGRAM_MTU_DISCOVER 39 /* set DF bit on egress packets */ ++/* #endif */ ++ ++#define BIO_CTRL_DGRAM_QUERY_MTU 40 /* as kernel for current MTU */ ++#define BIO_CTRL_DGRAM_GET_MTU 41 /* get cached value for MTU */ ++#define BIO_CTRL_DGRAM_SET_MTU 42 /* set cached value for ++ * MTU. want to use this ++ * if asking the kernel ++ * fails */ ++ ++#define BIO_CTRL_DGRAM_MTU_EXCEEDED 43 /* check whether the MTU ++ * was exceed in the ++ * previous write ++ * operation */ ++ ++#define BIO_CTRL_DGRAM_GET_PEER 46 ++#define BIO_CTRL_DGRAM_SET_PEER 44 /* Destination for the data */ ++ ++#define BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT 45 /* Next DTLS handshake timeout to ++ * adjust socket timeouts */ ++ ++/* modifiers */ ++#define BIO_FP_READ 0x02 ++#define BIO_FP_WRITE 0x04 ++#define BIO_FP_APPEND 0x08 ++#define BIO_FP_TEXT 0x10 ++ ++#define BIO_FLAGS_READ 0x01 ++#define BIO_FLAGS_WRITE 0x02 ++#define BIO_FLAGS_IO_SPECIAL 0x04 ++#define BIO_FLAGS_RWS (BIO_FLAGS_READ|BIO_FLAGS_WRITE|BIO_FLAGS_IO_SPECIAL) ++#define BIO_FLAGS_SHOULD_RETRY 0x08 ++#ifndef BIO_FLAGS_UPLINK ++/* "UPLINK" flag denotes file descriptors provided by application. ++ It defaults to 0, as most platforms don't require UPLINK interface. */ ++#define BIO_FLAGS_UPLINK 0 ++#endif ++ ++/* Used in BIO_gethostbyname() */ ++#define BIO_GHBN_CTRL_HITS 1 ++#define BIO_GHBN_CTRL_MISSES 2 ++#define BIO_GHBN_CTRL_CACHE_SIZE 3 ++#define BIO_GHBN_CTRL_GET_ENTRY 4 ++#define BIO_GHBN_CTRL_FLUSH 5 ++ ++/* Mostly used in the SSL BIO */ ++/* Not used anymore ++ * #define BIO_FLAGS_PROTOCOL_DELAYED_READ 0x10 ++ * #define BIO_FLAGS_PROTOCOL_DELAYED_WRITE 0x20 ++ * #define BIO_FLAGS_PROTOCOL_STARTUP 0x40 ++ */ ++ ++#define BIO_FLAGS_BASE64_NO_NL 0x100 ++ ++/* This is used with memory BIOs: it means we shouldn't free up or change the ++ * data in any way. ++ */ ++#define BIO_FLAGS_MEM_RDONLY 0x200 ++ ++typedef struct bio_st BIO; ++ ++void BIO_set_flags(BIO *b, int flags); ++int BIO_test_flags(const BIO *b, int flags); ++void BIO_clear_flags(BIO *b, int flags); ++ ++#define BIO_get_flags(b) BIO_test_flags(b, ~(0x0)) ++#define BIO_set_retry_special(b) \ ++ BIO_set_flags(b, (BIO_FLAGS_IO_SPECIAL|BIO_FLAGS_SHOULD_RETRY)) ++#define BIO_set_retry_read(b) \ ++ BIO_set_flags(b, (BIO_FLAGS_READ|BIO_FLAGS_SHOULD_RETRY)) ++#define BIO_set_retry_write(b) \ ++ BIO_set_flags(b, (BIO_FLAGS_WRITE|BIO_FLAGS_SHOULD_RETRY)) ++ ++/* These are normally used internally in BIOs */ ++#define BIO_clear_retry_flags(b) \ ++ BIO_clear_flags(b, (BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY)) ++#define BIO_get_retry_flags(b) \ ++ BIO_test_flags(b, (BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY)) ++ ++/* These should be used by the application to tell why we should retry */ ++#define BIO_should_read(a) BIO_test_flags(a, BIO_FLAGS_READ) ++#define BIO_should_write(a) BIO_test_flags(a, BIO_FLAGS_WRITE) ++#define BIO_should_io_special(a) BIO_test_flags(a, BIO_FLAGS_IO_SPECIAL) ++#define BIO_retry_type(a) BIO_test_flags(a, BIO_FLAGS_RWS) ++#define BIO_should_retry(a) BIO_test_flags(a, BIO_FLAGS_SHOULD_RETRY) ++ ++/* The next three are used in conjunction with the ++ * BIO_should_io_special() condition. After this returns true, ++ * BIO *BIO_get_retry_BIO(BIO *bio, int *reason); will walk the BIO ++ * stack and return the 'reason' for the special and the offending BIO. ++ * Given a BIO, BIO_get_retry_reason(bio) will return the code. */ ++/* Returned from the SSL bio when the certificate retrieval code had an error */ ++#define BIO_RR_SSL_X509_LOOKUP 0x01 ++/* Returned from the connect BIO when a connect would have blocked */ ++#define BIO_RR_CONNECT 0x02 ++/* Returned from the accept BIO when an accept would have blocked */ ++#define BIO_RR_ACCEPT 0x03 ++ ++/* These are passed by the BIO callback */ ++#define BIO_CB_FREE 0x01 ++#define BIO_CB_READ 0x02 ++#define BIO_CB_WRITE 0x03 ++#define BIO_CB_PUTS 0x04 ++#define BIO_CB_GETS 0x05 ++#define BIO_CB_CTRL 0x06 ++ ++/* The callback is called before and after the underling operation, ++ * The BIO_CB_RETURN flag indicates if it is after the call */ ++#define BIO_CB_RETURN 0x80 ++#define BIO_CB_return(a) ((a)|BIO_CB_RETURN)) ++#define BIO_cb_pre(a) (!((a)&BIO_CB_RETURN)) ++#define BIO_cb_post(a) ((a)&BIO_CB_RETURN) ++ ++long (*BIO_get_callback(const BIO *b)) (struct bio_st *,int,const char *,int, long,long); ++void BIO_set_callback(BIO *b, ++ long (*callback)(struct bio_st *,int,const char *,int, long,long)); ++char *BIO_get_callback_arg(const BIO *b); ++void BIO_set_callback_arg(BIO *b, char *arg); ++ ++const char * BIO_method_name(const BIO *b); ++int BIO_method_type(const BIO *b); ++ ++typedef void bio_info_cb(struct bio_st *, int, const char *, int, long, long); ++ ++typedef struct bio_method_st ++ { ++ int type; ++ const char *name; ++ int (*bwrite)(BIO *, const char *, int); ++ int (*bread)(BIO *, char *, int); ++ int (*bputs)(BIO *, const char *); ++ int (*bgets)(BIO *, char *, int); ++ long (*ctrl)(BIO *, int, long, void *); ++ int (*create)(BIO *); ++ int (*destroy)(BIO *); ++ long (*callback_ctrl)(BIO *, int, bio_info_cb *); ++ } BIO_METHOD; ++ ++struct bio_st ++ { ++ BIO_METHOD *method; ++ /* bio, mode, argp, argi, argl, ret */ ++ long (*callback)(struct bio_st *,int,const char *,int, long,long); ++ char *cb_arg; /* first argument for the callback */ ++ ++ int init; ++ int shutdown; ++ int flags; /* extra storage */ ++ int retry_reason; ++ int num; ++ void *ptr; ++ struct bio_st *next_bio; /* used by filter BIOs */ ++ struct bio_st *prev_bio; /* used by filter BIOs */ ++ int references; ++ unsigned long num_read; ++ unsigned long num_write; ++ ++ CRYPTO_EX_DATA ex_data; ++ }; ++ ++DECLARE_STACK_OF(BIO) ++ ++typedef struct bio_f_buffer_ctx_struct ++ { ++ /* BIO *bio; */ /* this is now in the BIO struct */ ++ int ibuf_size; /* how big is the input buffer */ ++ int obuf_size; /* how big is the output buffer */ ++ ++ char *ibuf; /* the char array */ ++ int ibuf_len; /* how many bytes are in it */ ++ int ibuf_off; /* write/read offset */ ++ ++ char *obuf; /* the char array */ ++ int obuf_len; /* how many bytes are in it */ ++ int obuf_off; /* write/read offset */ ++ } BIO_F_BUFFER_CTX; ++ ++/* Prefix and suffix callback in ASN1 BIO */ ++typedef int asn1_ps_func(BIO *b, unsigned char **pbuf, int *plen, void *parg); ++ ++/* connect BIO stuff */ ++#define BIO_CONN_S_BEFORE 1 ++#define BIO_CONN_S_GET_IP 2 ++#define BIO_CONN_S_GET_PORT 3 ++#define BIO_CONN_S_CREATE_SOCKET 4 ++#define BIO_CONN_S_CONNECT 5 ++#define BIO_CONN_S_OK 6 ++#define BIO_CONN_S_BLOCKED_CONNECT 7 ++#define BIO_CONN_S_NBIO 8 ++/*#define BIO_CONN_get_param_hostname BIO_ctrl */ ++ ++#define BIO_C_SET_CONNECT 100 ++#define BIO_C_DO_STATE_MACHINE 101 ++#define BIO_C_SET_NBIO 102 ++#define BIO_C_SET_PROXY_PARAM 103 ++#define BIO_C_SET_FD 104 ++#define BIO_C_GET_FD 105 ++#define BIO_C_SET_FILE_PTR 106 ++#define BIO_C_GET_FILE_PTR 107 ++#define BIO_C_SET_FILENAME 108 ++#define BIO_C_SET_SSL 109 ++#define BIO_C_GET_SSL 110 ++#define BIO_C_SET_MD 111 ++#define BIO_C_GET_MD 112 ++#define BIO_C_GET_CIPHER_STATUS 113 ++#define BIO_C_SET_BUF_MEM 114 ++#define BIO_C_GET_BUF_MEM_PTR 115 ++#define BIO_C_GET_BUFF_NUM_LINES 116 ++#define BIO_C_SET_BUFF_SIZE 117 ++#define BIO_C_SET_ACCEPT 118 ++#define BIO_C_SSL_MODE 119 ++#define BIO_C_GET_MD_CTX 120 ++#define BIO_C_GET_PROXY_PARAM 121 ++#define BIO_C_SET_BUFF_READ_DATA 122 /* data to read first */ ++#define BIO_C_GET_CONNECT 123 ++#define BIO_C_GET_ACCEPT 124 ++#define BIO_C_SET_SSL_RENEGOTIATE_BYTES 125 ++#define BIO_C_GET_SSL_NUM_RENEGOTIATES 126 ++#define BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT 127 ++#define BIO_C_FILE_SEEK 128 ++#define BIO_C_GET_CIPHER_CTX 129 ++#define BIO_C_SET_BUF_MEM_EOF_RETURN 130/*return end of input value*/ ++#define BIO_C_SET_BIND_MODE 131 ++#define BIO_C_GET_BIND_MODE 132 ++#define BIO_C_FILE_TELL 133 ++#define BIO_C_GET_SOCKS 134 ++#define BIO_C_SET_SOCKS 135 ++ ++#define BIO_C_SET_WRITE_BUF_SIZE 136/* for BIO_s_bio */ ++#define BIO_C_GET_WRITE_BUF_SIZE 137 ++#define BIO_C_MAKE_BIO_PAIR 138 ++#define BIO_C_DESTROY_BIO_PAIR 139 ++#define BIO_C_GET_WRITE_GUARANTEE 140 ++#define BIO_C_GET_READ_REQUEST 141 ++#define BIO_C_SHUTDOWN_WR 142 ++#define BIO_C_NREAD0 143 ++#define BIO_C_NREAD 144 ++#define BIO_C_NWRITE0 145 ++#define BIO_C_NWRITE 146 ++#define BIO_C_RESET_READ_REQUEST 147 ++#define BIO_C_SET_MD_CTX 148 ++ ++#define BIO_C_SET_PREFIX 149 ++#define BIO_C_GET_PREFIX 150 ++#define BIO_C_SET_SUFFIX 151 ++#define BIO_C_GET_SUFFIX 152 ++ ++#define BIO_C_SET_EX_ARG 153 ++#define BIO_C_GET_EX_ARG 154 ++ ++#define BIO_set_app_data(s,arg) BIO_set_ex_data(s,0,arg) ++#define BIO_get_app_data(s) BIO_get_ex_data(s,0) ++ ++/* BIO_s_connect() and BIO_s_socks4a_connect() */ ++#define BIO_set_conn_hostname(b,name) BIO_ctrl(b,BIO_C_SET_CONNECT,0,(char *)name) ++#define BIO_set_conn_port(b,port) BIO_ctrl(b,BIO_C_SET_CONNECT,1,(char *)port) ++#define BIO_set_conn_ip(b,ip) BIO_ctrl(b,BIO_C_SET_CONNECT,2,(char *)ip) ++#define BIO_set_conn_int_port(b,port) BIO_ctrl(b,BIO_C_SET_CONNECT,3,(char *)port) ++#define BIO_get_conn_hostname(b) BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,0) ++#define BIO_get_conn_port(b) BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,1) ++#define BIO_get_conn_ip(b) BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,2) ++#define BIO_get_conn_int_port(b) BIO_int_ctrl(b,BIO_C_GET_CONNECT,3,0) ++ ++ ++#define BIO_set_nbio(b,n) BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL) ++ ++/* BIO_s_accept_socket() */ ++#define BIO_set_accept_port(b,name) BIO_ctrl(b,BIO_C_SET_ACCEPT,0,(char *)name) ++#define BIO_get_accept_port(b) BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,0) ++/* #define BIO_set_nbio(b,n) BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL) */ ++#define BIO_set_nbio_accept(b,n) BIO_ctrl(b,BIO_C_SET_ACCEPT,1,(n)?(void *)"a":NULL) ++#define BIO_set_accept_bios(b,bio) BIO_ctrl(b,BIO_C_SET_ACCEPT,2,(char *)bio) ++ ++#define BIO_BIND_NORMAL 0 ++#define BIO_BIND_REUSEADDR_IF_UNUSED 1 ++#define BIO_BIND_REUSEADDR 2 ++#define BIO_set_bind_mode(b,mode) BIO_ctrl(b,BIO_C_SET_BIND_MODE,mode,NULL) ++#define BIO_get_bind_mode(b,mode) BIO_ctrl(b,BIO_C_GET_BIND_MODE,0,NULL) ++ ++#define BIO_do_connect(b) BIO_do_handshake(b) ++#define BIO_do_accept(b) BIO_do_handshake(b) ++#define BIO_do_handshake(b) BIO_ctrl(b,BIO_C_DO_STATE_MACHINE,0,NULL) ++ ++/* BIO_s_proxy_client() */ ++#define BIO_set_url(b,url) BIO_ctrl(b,BIO_C_SET_PROXY_PARAM,0,(char *)(url)) ++#define BIO_set_proxies(b,p) BIO_ctrl(b,BIO_C_SET_PROXY_PARAM,1,(char *)(p)) ++/* BIO_set_nbio(b,n) */ ++#define BIO_set_filter_bio(b,s) BIO_ctrl(b,BIO_C_SET_PROXY_PARAM,2,(char *)(s)) ++/* BIO *BIO_get_filter_bio(BIO *bio); */ ++#define BIO_set_proxy_cb(b,cb) BIO_callback_ctrl(b,BIO_C_SET_PROXY_PARAM,3,(void *(*cb)())) ++#define BIO_set_proxy_header(b,sk) BIO_ctrl(b,BIO_C_SET_PROXY_PARAM,4,(char *)sk) ++#define BIO_set_no_connect_return(b,bool) BIO_int_ctrl(b,BIO_C_SET_PROXY_PARAM,5,bool) ++ ++#define BIO_get_proxy_header(b,skp) BIO_ctrl(b,BIO_C_GET_PROXY_PARAM,0,(char *)skp) ++#define BIO_get_proxies(b,pxy_p) BIO_ctrl(b,BIO_C_GET_PROXY_PARAM,1,(char *)(pxy_p)) ++#define BIO_get_url(b,url) BIO_ctrl(b,BIO_C_GET_PROXY_PARAM,2,(char *)(url)) ++#define BIO_get_no_connect_return(b) BIO_ctrl(b,BIO_C_GET_PROXY_PARAM,5,NULL) ++ ++#define BIO_set_fd(b,fd,c) BIO_int_ctrl(b,BIO_C_SET_FD,c,fd) ++#define BIO_get_fd(b,c) BIO_ctrl(b,BIO_C_GET_FD,0,(char *)c) ++ ++#define BIO_set_fp(b,fp,c) BIO_ctrl(b,BIO_C_SET_FILE_PTR,c,(char *)fp) ++#define BIO_get_fp(b,fpp) BIO_ctrl(b,BIO_C_GET_FILE_PTR,0,(char *)fpp) ++ ++#define BIO_seek(b,ofs) (int)BIO_ctrl(b,BIO_C_FILE_SEEK,ofs,NULL) ++#define BIO_tell(b) (int)BIO_ctrl(b,BIO_C_FILE_TELL,0,NULL) ++ ++/* name is cast to lose const, but might be better to route through a function ++ so we can do it safely */ ++#ifdef CONST_STRICT ++/* If you are wondering why this isn't defined, its because CONST_STRICT is ++ * purely a compile-time kludge to allow const to be checked. ++ */ ++int BIO_read_filename(BIO *b,const char *name); ++#else ++#define BIO_read_filename(b,name) BIO_ctrl(b,BIO_C_SET_FILENAME, \ ++ BIO_CLOSE|BIO_FP_READ,(char *)name) ++#endif ++#define BIO_write_filename(b,name) BIO_ctrl(b,BIO_C_SET_FILENAME, \ ++ BIO_CLOSE|BIO_FP_WRITE,name) ++#define BIO_append_filename(b,name) BIO_ctrl(b,BIO_C_SET_FILENAME, \ ++ BIO_CLOSE|BIO_FP_APPEND,name) ++#define BIO_rw_filename(b,name) BIO_ctrl(b,BIO_C_SET_FILENAME, \ ++ BIO_CLOSE|BIO_FP_READ|BIO_FP_WRITE,name) ++ ++/* WARNING WARNING, this ups the reference count on the read bio of the ++ * SSL structure. This is because the ssl read BIO is now pointed to by ++ * the next_bio field in the bio. So when you free the BIO, make sure ++ * you are doing a BIO_free_all() to catch the underlying BIO. */ ++#define BIO_set_ssl(b,ssl,c) BIO_ctrl(b,BIO_C_SET_SSL,c,(char *)ssl) ++#define BIO_get_ssl(b,sslp) BIO_ctrl(b,BIO_C_GET_SSL,0,(char *)sslp) ++#define BIO_set_ssl_mode(b,client) BIO_ctrl(b,BIO_C_SSL_MODE,client,NULL) ++#define BIO_set_ssl_renegotiate_bytes(b,num) \ ++ BIO_ctrl(b,BIO_C_SET_SSL_RENEGOTIATE_BYTES,num,NULL); ++#define BIO_get_num_renegotiates(b) \ ++ BIO_ctrl(b,BIO_C_GET_SSL_NUM_RENEGOTIATES,0,NULL); ++#define BIO_set_ssl_renegotiate_timeout(b,seconds) \ ++ BIO_ctrl(b,BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT,seconds,NULL); ++ ++/* defined in evp.h */ ++/* #define BIO_set_md(b,md) BIO_ctrl(b,BIO_C_SET_MD,1,(char *)md) */ ++ ++#define BIO_get_mem_data(b,pp) BIO_ctrl(b,BIO_CTRL_INFO,0,(char *)pp) ++#define BIO_set_mem_buf(b,bm,c) BIO_ctrl(b,BIO_C_SET_BUF_MEM,c,(char *)bm) ++#define BIO_get_mem_ptr(b,pp) BIO_ctrl(b,BIO_C_GET_BUF_MEM_PTR,0,(char *)pp) ++#define BIO_set_mem_eof_return(b,v) \ ++ BIO_ctrl(b,BIO_C_SET_BUF_MEM_EOF_RETURN,v,NULL) ++ ++/* For the BIO_f_buffer() type */ ++#define BIO_get_buffer_num_lines(b) BIO_ctrl(b,BIO_C_GET_BUFF_NUM_LINES,0,NULL) ++#define BIO_set_buffer_size(b,size) BIO_ctrl(b,BIO_C_SET_BUFF_SIZE,size,NULL) ++#define BIO_set_read_buffer_size(b,size) BIO_int_ctrl(b,BIO_C_SET_BUFF_SIZE,size,0) ++#define BIO_set_write_buffer_size(b,size) BIO_int_ctrl(b,BIO_C_SET_BUFF_SIZE,size,1) ++#define BIO_set_buffer_read_data(b,buf,num) BIO_ctrl(b,BIO_C_SET_BUFF_READ_DATA,num,buf) ++ ++/* Don't use the next one unless you know what you are doing :-) */ ++#define BIO_dup_state(b,ret) BIO_ctrl(b,BIO_CTRL_DUP,0,(char *)(ret)) ++ ++#define BIO_reset(b) (int)BIO_ctrl(b,BIO_CTRL_RESET,0,NULL) ++#define BIO_eof(b) (int)BIO_ctrl(b,BIO_CTRL_EOF,0,NULL) ++#define BIO_set_close(b,c) (int)BIO_ctrl(b,BIO_CTRL_SET_CLOSE,(c),NULL) ++#define BIO_get_close(b) (int)BIO_ctrl(b,BIO_CTRL_GET_CLOSE,0,NULL) ++#define BIO_pending(b) (int)BIO_ctrl(b,BIO_CTRL_PENDING,0,NULL) ++#define BIO_wpending(b) (int)BIO_ctrl(b,BIO_CTRL_WPENDING,0,NULL) ++/* ...pending macros have inappropriate return type */ ++size_t BIO_ctrl_pending(BIO *b); ++size_t BIO_ctrl_wpending(BIO *b); ++#define BIO_flush(b) (int)BIO_ctrl(b,BIO_CTRL_FLUSH,0,NULL) ++#define BIO_get_info_callback(b,cbp) (int)BIO_ctrl(b,BIO_CTRL_GET_CALLBACK,0, \ ++ cbp) ++#define BIO_set_info_callback(b,cb) (int)BIO_callback_ctrl(b,BIO_CTRL_SET_CALLBACK,cb) ++ ++/* For the BIO_f_buffer() type */ ++#define BIO_buffer_get_num_lines(b) BIO_ctrl(b,BIO_CTRL_GET,0,NULL) ++ ++/* For BIO_s_bio() */ ++#define BIO_set_write_buf_size(b,size) (int)BIO_ctrl(b,BIO_C_SET_WRITE_BUF_SIZE,size,NULL) ++#define BIO_get_write_buf_size(b,size) (size_t)BIO_ctrl(b,BIO_C_GET_WRITE_BUF_SIZE,size,NULL) ++#define BIO_make_bio_pair(b1,b2) (int)BIO_ctrl(b1,BIO_C_MAKE_BIO_PAIR,0,b2) ++#define BIO_destroy_bio_pair(b) (int)BIO_ctrl(b,BIO_C_DESTROY_BIO_PAIR,0,NULL) ++#define BIO_shutdown_wr(b) (int)BIO_ctrl(b, BIO_C_SHUTDOWN_WR, 0, NULL) ++/* macros with inappropriate type -- but ...pending macros use int too: */ ++#define BIO_get_write_guarantee(b) (int)BIO_ctrl(b,BIO_C_GET_WRITE_GUARANTEE,0,NULL) ++#define BIO_get_read_request(b) (int)BIO_ctrl(b,BIO_C_GET_READ_REQUEST,0,NULL) ++size_t BIO_ctrl_get_write_guarantee(BIO *b); ++size_t BIO_ctrl_get_read_request(BIO *b); ++int BIO_ctrl_reset_read_request(BIO *b); ++ ++/* ctrl macros for dgram */ ++#define BIO_ctrl_dgram_connect(b,peer) \ ++ (int)BIO_ctrl(b,BIO_CTRL_DGRAM_CONNECT,0, (char *)peer) ++#define BIO_ctrl_set_connected(b, state, peer) \ ++ (int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_CONNECTED, state, (char *)peer) ++#define BIO_dgram_recv_timedout(b) \ ++ (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP, 0, NULL) ++#define BIO_dgram_send_timedout(b) \ ++ (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP, 0, NULL) ++#define BIO_dgram_get_peer(b,peer) \ ++ (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_PEER, 0, (char *)peer) ++#define BIO_dgram_set_peer(b,peer) \ ++ (int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_PEER, 0, (char *)peer) ++ ++/* These two aren't currently implemented */ ++/* int BIO_get_ex_num(BIO *bio); */ ++/* void BIO_set_ex_free_func(BIO *bio,int idx,void (*cb)()); */ ++int BIO_set_ex_data(BIO *bio,int idx,void *data); ++void *BIO_get_ex_data(BIO *bio,int idx); ++int BIO_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, ++ CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func); ++unsigned long BIO_number_read(BIO *bio); ++unsigned long BIO_number_written(BIO *bio); ++ ++/* For BIO_f_asn1() */ ++int BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix, ++ asn1_ps_func *prefix_free); ++int BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix, ++ asn1_ps_func **pprefix_free); ++int BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix, ++ asn1_ps_func *suffix_free); ++int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix, ++ asn1_ps_func **psuffix_free); ++ ++# ifndef OPENSSL_NO_FP_API ++BIO_METHOD *BIO_s_file(void ); ++BIO *BIO_new_file(const char *filename, const char *mode); ++BIO *BIO_new_fp(FILE *stream, int close_flag); ++# define BIO_s_file_internal BIO_s_file ++# endif ++BIO * BIO_new(BIO_METHOD *type); ++int BIO_set(BIO *a,BIO_METHOD *type); ++int BIO_free(BIO *a); ++void BIO_vfree(BIO *a); ++int BIO_read(BIO *b, void *data, int len); ++int BIO_gets(BIO *bp,char *buf, int size); ++int BIO_write(BIO *b, const void *data, int len); ++int BIO_puts(BIO *bp,const char *buf); ++int BIO_indent(BIO *b,int indent,int max); ++long BIO_ctrl(BIO *bp,int cmd,long larg,void *parg); ++long BIO_callback_ctrl(BIO *b, int cmd, void (*fp)(struct bio_st *, int, const char *, int, long, long)); ++char * BIO_ptr_ctrl(BIO *bp,int cmd,long larg); ++long BIO_int_ctrl(BIO *bp,int cmd,long larg,int iarg); ++BIO * BIO_push(BIO *b,BIO *append); ++BIO * BIO_pop(BIO *b); ++void BIO_free_all(BIO *a); ++BIO * BIO_find_type(BIO *b,int bio_type); ++BIO * BIO_next(BIO *b); ++BIO * BIO_get_retry_BIO(BIO *bio, int *reason); ++int BIO_get_retry_reason(BIO *bio); ++BIO * BIO_dup_chain(BIO *in); ++ ++int BIO_nread0(BIO *bio, char **buf); ++int BIO_nread(BIO *bio, char **buf, int num); ++int BIO_nwrite0(BIO *bio, char **buf); ++int BIO_nwrite(BIO *bio, char **buf, int num); ++ ++long BIO_debug_callback(BIO *bio,int cmd,const char *argp,int argi, ++ long argl,long ret); ++ ++BIO_METHOD *BIO_s_mem(void); ++BIO *BIO_new_mem_buf(void *buf, int len); ++BIO_METHOD *BIO_s_socket(void); ++BIO_METHOD *BIO_s_connect(void); ++BIO_METHOD *BIO_s_accept(void); ++BIO_METHOD *BIO_s_fd(void); ++#ifndef OPENSSL_SYS_OS2 ++BIO_METHOD *BIO_s_log(void); ++#endif ++BIO_METHOD *BIO_s_bio(void); ++BIO_METHOD *BIO_s_null(void); ++BIO_METHOD *BIO_f_null(void); ++BIO_METHOD *BIO_f_buffer(void); ++#ifdef OPENSSL_SYS_VMS ++BIO_METHOD *BIO_f_linebuffer(void); ++#endif ++BIO_METHOD *BIO_f_nbio_test(void); ++#ifndef OPENSSL_NO_DGRAM ++BIO_METHOD *BIO_s_datagram(void); ++#endif ++ ++/* BIO_METHOD *BIO_f_ber(void); */ ++ ++int BIO_sock_should_retry(int i); ++int BIO_sock_non_fatal_error(int error); ++int BIO_dgram_non_fatal_error(int error); ++ ++int BIO_fd_should_retry(int i); ++int BIO_fd_non_fatal_error(int error); ++int BIO_dump_cb(int (*cb)(const void *data, size_t len, void *u), ++ void *u, const char *s, int len); ++int BIO_dump_indent_cb(int (*cb)(const void *data, size_t len, void *u), ++ void *u, const char *s, int len, int indent); ++int BIO_dump(BIO *b,const char *bytes,int len); ++int BIO_dump_indent(BIO *b,const char *bytes,int len,int indent); ++#ifndef OPENSSL_NO_FP_API ++int BIO_dump_fp(FILE *fp, const char *s, int len); ++int BIO_dump_indent_fp(FILE *fp, const char *s, int len, int indent); ++#endif ++struct hostent *BIO_gethostbyname(const char *name); ++/* We might want a thread-safe interface too: ++ * struct hostent *BIO_gethostbyname_r(const char *name, ++ * struct hostent *result, void *buffer, size_t buflen); ++ * or something similar (caller allocates a struct hostent, ++ * pointed to by "result", and additional buffer space for the various ++ * substructures; if the buffer does not suffice, NULL is returned ++ * and an appropriate error code is set). ++ */ ++int BIO_sock_error(int sock); ++int BIO_socket_ioctl(int fd, long type, void *arg); ++int BIO_socket_nbio(int fd,int mode); ++int BIO_get_port(const char *str, unsigned short *port_ptr); ++int BIO_get_host_ip(const char *str, unsigned char *ip); ++int BIO_get_accept_socket(char *host_port,int mode); ++int BIO_accept(int sock,char **ip_port); ++int BIO_sock_init(void ); ++void BIO_sock_cleanup(void); ++int BIO_set_tcp_ndelay(int sock,int turn_on); ++ ++BIO *BIO_new_socket(int sock, int close_flag); ++BIO *BIO_new_dgram(int fd, int close_flag); ++BIO *BIO_new_fd(int fd, int close_flag); ++BIO *BIO_new_connect(char *host_port); ++BIO *BIO_new_accept(char *host_port); ++ ++int BIO_new_bio_pair(BIO **bio1, size_t writebuf1, ++ BIO **bio2, size_t writebuf2); ++/* If successful, returns 1 and in *bio1, *bio2 two BIO pair endpoints. ++ * Otherwise returns 0 and sets *bio1 and *bio2 to NULL. ++ * Size 0 uses default value. ++ */ ++ ++void BIO_copy_next_retry(BIO *b); ++ ++/*long BIO_ghbn_ctrl(int cmd,int iarg,char *parg);*/ ++ ++#ifdef __GNUC__ ++# define __bio_h__attr__ __attribute__ ++#else ++# define __bio_h__attr__(x) ++#endif ++int BIO_printf(BIO *bio, const char *format, ...) ++ __bio_h__attr__((__format__(__printf__,2,3))); ++int BIO_vprintf(BIO *bio, const char *format, va_list args) ++ __bio_h__attr__((__format__(__printf__,2,0))); ++int BIO_snprintf(char *buf, size_t n, const char *format, ...) ++ __bio_h__attr__((__format__(__printf__,3,4))); ++int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args) ++ __bio_h__attr__((__format__(__printf__,3,0))); ++#undef __bio_h__attr__ ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_BIO_strings(void); ++ ++/* Error codes for the BIO functions. */ ++ ++/* Function codes. */ ++#define BIO_F_ACPT_STATE 100 ++#define BIO_F_BIO_ACCEPT 101 ++#define BIO_F_BIO_BER_GET_HEADER 102 ++#define BIO_F_BIO_CALLBACK_CTRL 131 ++#define BIO_F_BIO_CTRL 103 ++#define BIO_F_BIO_GETHOSTBYNAME 120 ++#define BIO_F_BIO_GETS 104 ++#define BIO_F_BIO_GET_ACCEPT_SOCKET 105 ++#define BIO_F_BIO_GET_HOST_IP 106 ++#define BIO_F_BIO_GET_PORT 107 ++#define BIO_F_BIO_MAKE_PAIR 121 ++#define BIO_F_BIO_NEW 108 ++#define BIO_F_BIO_NEW_FILE 109 ++#define BIO_F_BIO_NEW_MEM_BUF 126 ++#define BIO_F_BIO_NREAD 123 ++#define BIO_F_BIO_NREAD0 124 ++#define BIO_F_BIO_NWRITE 125 ++#define BIO_F_BIO_NWRITE0 122 ++#define BIO_F_BIO_PUTS 110 ++#define BIO_F_BIO_READ 111 ++#define BIO_F_BIO_SOCK_INIT 112 ++#define BIO_F_BIO_WRITE 113 ++#define BIO_F_BUFFER_CTRL 114 ++#define BIO_F_CONN_CTRL 127 ++#define BIO_F_CONN_STATE 115 ++#define BIO_F_FILE_CTRL 116 ++#define BIO_F_FILE_READ 130 ++#define BIO_F_LINEBUFFER_CTRL 129 ++#define BIO_F_MEM_READ 128 ++#define BIO_F_MEM_WRITE 117 ++#define BIO_F_SSL_NEW 118 ++#define BIO_F_WSASTARTUP 119 ++ ++/* Reason codes. */ ++#define BIO_R_ACCEPT_ERROR 100 ++#define BIO_R_BAD_FOPEN_MODE 101 ++#define BIO_R_BAD_HOSTNAME_LOOKUP 102 ++#define BIO_R_BROKEN_PIPE 124 ++#define BIO_R_CONNECT_ERROR 103 ++#define BIO_R_EOF_ON_MEMORY_BIO 127 ++#define BIO_R_ERROR_SETTING_NBIO 104 ++#define BIO_R_ERROR_SETTING_NBIO_ON_ACCEPTED_SOCKET 105 ++#define BIO_R_ERROR_SETTING_NBIO_ON_ACCEPT_SOCKET 106 ++#define BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET 107 ++#define BIO_R_INVALID_ARGUMENT 125 ++#define BIO_R_INVALID_IP_ADDRESS 108 ++#define BIO_R_IN_USE 123 ++#define BIO_R_KEEPALIVE 109 ++#define BIO_R_NBIO_CONNECT_ERROR 110 ++#define BIO_R_NO_ACCEPT_PORT_SPECIFIED 111 ++#define BIO_R_NO_HOSTNAME_SPECIFIED 112 ++#define BIO_R_NO_PORT_DEFINED 113 ++#define BIO_R_NO_PORT_SPECIFIED 114 ++#define BIO_R_NO_SUCH_FILE 128 ++#define BIO_R_NULL_PARAMETER 115 ++#define BIO_R_TAG_MISMATCH 116 ++#define BIO_R_UNABLE_TO_BIND_SOCKET 117 ++#define BIO_R_UNABLE_TO_CREATE_SOCKET 118 ++#define BIO_R_UNABLE_TO_LISTEN_SOCKET 119 ++#define BIO_R_UNINITIALIZED 120 ++#define BIO_R_UNSUPPORTED_METHOD 121 ++#define BIO_R_WRITE_TO_READ_ONLY_BIO 126 ++#define BIO_R_WSASTARTUP 122 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/blowfish.h qt.patched/include/openssl/blowfish.h +--- qt.orig/include/openssl/blowfish.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/blowfish.h 2010-08-27 12:01:45.008918700 +0200 +@@ -0,0 +1,127 @@ ++/* crypto/bf/blowfish.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_BLOWFISH_H ++#define HEADER_BLOWFISH_H ++ ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#ifdef OPENSSL_NO_BF ++#error BF is disabled. ++#endif ++ ++#define BF_ENCRYPT 1 ++#define BF_DECRYPT 0 ++ ++/* ++ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ++ * ! BF_LONG has to be at least 32 bits wide. If it's wider, then ! ++ * ! BF_LONG_LOG2 has to be defined along. ! ++ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ++ */ ++ ++#if defined(__LP32__) ++#define BF_LONG unsigned long ++#elif defined(OPENSSL_SYS_CRAY) || defined(__ILP64__) ++#define BF_LONG unsigned long ++#define BF_LONG_LOG2 3 ++/* ++ * _CRAY note. I could declare short, but I have no idea what impact ++ * does it have on performance on none-T3E machines. I could declare ++ * int, but at least on C90 sizeof(int) can be chosen at compile time. ++ * So I've chosen long... ++ * ++ */ ++#else ++#define BF_LONG unsigned int ++#endif ++ ++#define BF_ROUNDS 16 ++#define BF_BLOCK 8 ++ ++typedef struct bf_key_st ++ { ++ BF_LONG P[BF_ROUNDS+2]; ++ BF_LONG S[4*256]; ++ } BF_KEY; ++ ++ ++void BF_set_key(BF_KEY *key, int len, const unsigned char *data); ++ ++void BF_encrypt(BF_LONG *data,const BF_KEY *key); ++void BF_decrypt(BF_LONG *data,const BF_KEY *key); ++ ++void BF_ecb_encrypt(const unsigned char *in, unsigned char *out, ++ const BF_KEY *key, int enc); ++void BF_cbc_encrypt(const unsigned char *in, unsigned char *out, long length, ++ const BF_KEY *schedule, unsigned char *ivec, int enc); ++void BF_cfb64_encrypt(const unsigned char *in, unsigned char *out, long length, ++ const BF_KEY *schedule, unsigned char *ivec, int *num, int enc); ++void BF_ofb64_encrypt(const unsigned char *in, unsigned char *out, long length, ++ const BF_KEY *schedule, unsigned char *ivec, int *num); ++const char *BF_options(void); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff -urN qt.orig/include/openssl/bn.h qt.patched/include/openssl/bn.h +--- qt.orig/include/openssl/bn.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/bn.h 2010-08-27 12:01:45.024543100 +0200 +@@ -0,0 +1,858 @@ ++/* crypto/bn/bn.h */ ++/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++/* ==================================================================== ++ * Copyright (c) 1998-2006 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * openssl-core@openssl.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.openssl.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++/* ==================================================================== ++ * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. ++ * ++ * Portions of the attached software ("Contribution") are developed by ++ * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project. ++ * ++ * The Contribution is licensed pursuant to the Eric Young open source ++ * license provided above. ++ * ++ * The binary polynomial arithmetic software is originally written by ++ * Sheueling Chang Shantz and Douglas Stebila of Sun Microsystems Laboratories. ++ * ++ */ ++ ++#ifndef HEADER_BN_H ++#define HEADER_BN_H ++ ++#include ++#ifndef OPENSSL_NO_FP_API ++#include /* FILE */ ++#endif ++#include ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* These preprocessor symbols control various aspects of the bignum headers and ++ * library code. They're not defined by any "normal" configuration, as they are ++ * intended for development and testing purposes. NB: defining all three can be ++ * useful for debugging application code as well as openssl itself. ++ * ++ * BN_DEBUG - turn on various debugging alterations to the bignum code ++ * BN_DEBUG_RAND - uses random poisoning of unused words to trip up ++ * mismanagement of bignum internals. You must also define BN_DEBUG. ++ */ ++/* #define BN_DEBUG */ ++/* #define BN_DEBUG_RAND */ ++ ++#ifndef OPENSSL_SMALL_FOOTPRINT ++#define BN_MUL_COMBA ++#define BN_SQR_COMBA ++#define BN_RECURSION ++#endif ++ ++/* This next option uses the C libraries (2 word)/(1 word) function. ++ * If it is not defined, I use my C version (which is slower). ++ * The reason for this flag is that when the particular C compiler ++ * library routine is used, and the library is linked with a different ++ * compiler, the library is missing. This mostly happens when the ++ * library is built with gcc and then linked using normal cc. This would ++ * be a common occurrence because gcc normally produces code that is ++ * 2 times faster than system compilers for the big number stuff. ++ * For machines with only one compiler (or shared libraries), this should ++ * be on. Again this in only really a problem on machines ++ * using "long long's", are 32bit, and are not using my assembler code. */ ++#if defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_WINDOWS) || \ ++ defined(OPENSSL_SYS_WIN32) || defined(linux) ++# ifndef BN_DIV2W ++# define BN_DIV2W ++# endif ++#endif ++ ++/* assuming long is 64bit - this is the DEC Alpha ++ * unsigned long long is only 64 bits :-(, don't define ++ * BN_LLONG for the DEC Alpha */ ++#ifdef SIXTY_FOUR_BIT_LONG ++#define BN_ULLONG unsigned long long ++#define BN_ULONG unsigned long ++#define BN_LONG long ++#define BN_BITS 128 ++#define BN_BYTES 8 ++#define BN_BITS2 64 ++#define BN_BITS4 32 ++#define BN_MASK (0xffffffffffffffffffffffffffffffffLL) ++#define BN_MASK2 (0xffffffffffffffffL) ++#define BN_MASK2l (0xffffffffL) ++#define BN_MASK2h (0xffffffff00000000L) ++#define BN_MASK2h1 (0xffffffff80000000L) ++#define BN_TBIT (0x8000000000000000L) ++#define BN_DEC_CONV (10000000000000000000UL) ++#define BN_DEC_FMT1 "%lu" ++#define BN_DEC_FMT2 "%019lu" ++#define BN_DEC_NUM 19 ++#define BN_HEX_FMT1 "%lX" ++#define BN_HEX_FMT2 "%016lX" ++#endif ++ ++/* This is where the long long data type is 64 bits, but long is 32. ++ * For machines where there are 64bit registers, this is the mode to use. ++ * IRIX, on R4000 and above should use this mode, along with the relevant ++ * assembler code :-). Do NOT define BN_LLONG. ++ */ ++#ifdef SIXTY_FOUR_BIT ++#undef BN_LLONG ++#undef BN_ULLONG ++#define BN_ULONG unsigned long long ++#define BN_LONG long long ++#define BN_BITS 128 ++#define BN_BYTES 8 ++#define BN_BITS2 64 ++#define BN_BITS4 32 ++#define BN_MASK2 (0xffffffffffffffffLL) ++#define BN_MASK2l (0xffffffffL) ++#define BN_MASK2h (0xffffffff00000000LL) ++#define BN_MASK2h1 (0xffffffff80000000LL) ++#define BN_TBIT (0x8000000000000000LL) ++#define BN_DEC_CONV (10000000000000000000ULL) ++#define BN_DEC_FMT1 "%llu" ++#define BN_DEC_FMT2 "%019llu" ++#define BN_DEC_NUM 19 ++#define BN_HEX_FMT1 "%llX" ++#define BN_HEX_FMT2 "%016llX" ++#endif ++ ++#ifdef THIRTY_TWO_BIT ++#ifdef BN_LLONG ++# if defined(_WIN32) && !defined(__GNUC__) ++# define BN_ULLONG unsigned __int64 ++# define BN_MASK (0xffffffffffffffffI64) ++# else ++# define BN_ULLONG unsigned long long ++# define BN_MASK (0xffffffffffffffffLL) ++# endif ++#endif ++#define BN_ULONG unsigned int ++#define BN_LONG int ++#define BN_BITS 64 ++#define BN_BYTES 4 ++#define BN_BITS2 32 ++#define BN_BITS4 16 ++#define BN_MASK2 (0xffffffffL) ++#define BN_MASK2l (0xffff) ++#define BN_MASK2h1 (0xffff8000L) ++#define BN_MASK2h (0xffff0000L) ++#define BN_TBIT (0x80000000L) ++#define BN_DEC_CONV (1000000000L) ++#define BN_DEC_FMT1 "%u" ++#define BN_DEC_FMT2 "%09u" ++#define BN_DEC_NUM 9 ++#define BN_HEX_FMT1 "%X" ++#define BN_HEX_FMT2 "%08X" ++#endif ++ ++#define BN_DEFAULT_BITS 1280 ++ ++#define BN_FLG_MALLOCED 0x01 ++#define BN_FLG_STATIC_DATA 0x02 ++#define BN_FLG_CONSTTIME 0x04 /* avoid leaking exponent information through timing, ++ * BN_mod_exp_mont() will call BN_mod_exp_mont_consttime, ++ * BN_div() will call BN_div_no_branch, ++ * BN_mod_inverse() will call BN_mod_inverse_no_branch. ++ */ ++ ++#ifndef OPENSSL_NO_DEPRECATED ++#define BN_FLG_EXP_CONSTTIME BN_FLG_CONSTTIME /* deprecated name for the flag */ ++ /* avoid leaking exponent information through timings ++ * (BN_mod_exp_mont() will call BN_mod_exp_mont_consttime) */ ++#endif ++ ++#ifndef OPENSSL_NO_DEPRECATED ++#define BN_FLG_FREE 0x8000 /* used for debuging */ ++#endif ++#define BN_set_flags(b,n) ((b)->flags|=(n)) ++#define BN_get_flags(b,n) ((b)->flags&(n)) ++ ++/* get a clone of a BIGNUM with changed flags, for *temporary* use only ++ * (the two BIGNUMs cannot not be used in parallel!) */ ++#define BN_with_flags(dest,b,n) ((dest)->d=(b)->d, \ ++ (dest)->top=(b)->top, \ ++ (dest)->dmax=(b)->dmax, \ ++ (dest)->neg=(b)->neg, \ ++ (dest)->flags=(((dest)->flags & BN_FLG_MALLOCED) \ ++ | ((b)->flags & ~BN_FLG_MALLOCED) \ ++ | BN_FLG_STATIC_DATA \ ++ | (n))) ++ ++/* Already declared in ossl_typ.h */ ++#if 0 ++typedef struct bignum_st BIGNUM; ++/* Used for temp variables (declaration hidden in bn_lcl.h) */ ++typedef struct bignum_ctx BN_CTX; ++typedef struct bn_blinding_st BN_BLINDING; ++typedef struct bn_mont_ctx_st BN_MONT_CTX; ++typedef struct bn_recp_ctx_st BN_RECP_CTX; ++typedef struct bn_gencb_st BN_GENCB; ++#endif ++ ++struct bignum_st ++ { ++ BN_ULONG *d; /* Pointer to an array of 'BN_BITS2' bit chunks. */ ++ int top; /* Index of last used d +1. */ ++ /* The next are internal book keeping for bn_expand. */ ++ int dmax; /* Size of the d array. */ ++ int neg; /* one if the number is negative */ ++ int flags; ++ }; ++ ++/* Used for montgomery multiplication */ ++struct bn_mont_ctx_st ++ { ++ int ri; /* number of bits in R */ ++ BIGNUM RR; /* used to convert to montgomery form */ ++ BIGNUM N; /* The modulus */ ++ BIGNUM Ni; /* R*(1/R mod N) - N*Ni = 1 ++ * (Ni is only stored for bignum algorithm) */ ++ BN_ULONG n0[2];/* least significant word(s) of Ni; ++ (type changed with 0.9.9, was "BN_ULONG n0;" before) */ ++ int flags; ++ }; ++ ++/* Used for reciprocal division/mod functions ++ * It cannot be shared between threads ++ */ ++struct bn_recp_ctx_st ++ { ++ BIGNUM N; /* the divisor */ ++ BIGNUM Nr; /* the reciprocal */ ++ int num_bits; ++ int shift; ++ int flags; ++ }; ++ ++/* Used for slow "generation" functions. */ ++struct bn_gencb_st ++ { ++ unsigned int ver; /* To handle binary (in)compatibility */ ++ void *arg; /* callback-specific data */ ++ union ++ { ++ /* if(ver==1) - handles old style callbacks */ ++ void (*cb_1)(int, int, void *); ++ /* if(ver==2) - new callback style */ ++ int (*cb_2)(int, int, BN_GENCB *); ++ } cb; ++ }; ++/* Wrapper function to make using BN_GENCB easier, */ ++int BN_GENCB_call(BN_GENCB *cb, int a, int b); ++/* Macro to populate a BN_GENCB structure with an "old"-style callback */ ++#define BN_GENCB_set_old(gencb, callback, cb_arg) { \ ++ BN_GENCB *tmp_gencb = (gencb); \ ++ tmp_gencb->ver = 1; \ ++ tmp_gencb->arg = (cb_arg); \ ++ tmp_gencb->cb.cb_1 = (callback); } ++/* Macro to populate a BN_GENCB structure with a "new"-style callback */ ++#define BN_GENCB_set(gencb, callback, cb_arg) { \ ++ BN_GENCB *tmp_gencb = (gencb); \ ++ tmp_gencb->ver = 2; \ ++ tmp_gencb->arg = (cb_arg); \ ++ tmp_gencb->cb.cb_2 = (callback); } ++ ++#define BN_prime_checks 0 /* default: select number of iterations ++ based on the size of the number */ ++ ++/* number of Miller-Rabin iterations for an error rate of less than 2^-80 ++ * for random 'b'-bit input, b >= 100 (taken from table 4.4 in the Handbook ++ * of Applied Cryptography [Menezes, van Oorschot, Vanstone; CRC Press 1996]; ++ * original paper: Damgaard, Landrock, Pomerance: Average case error estimates ++ * for the strong probable prime test. -- Math. Comp. 61 (1993) 177-194) */ ++#define BN_prime_checks_for_size(b) ((b) >= 1300 ? 2 : \ ++ (b) >= 850 ? 3 : \ ++ (b) >= 650 ? 4 : \ ++ (b) >= 550 ? 5 : \ ++ (b) >= 450 ? 6 : \ ++ (b) >= 400 ? 7 : \ ++ (b) >= 350 ? 8 : \ ++ (b) >= 300 ? 9 : \ ++ (b) >= 250 ? 12 : \ ++ (b) >= 200 ? 15 : \ ++ (b) >= 150 ? 18 : \ ++ /* b >= 100 */ 27) ++ ++#define BN_num_bytes(a) ((BN_num_bits(a)+7)/8) ++ ++/* Note that BN_abs_is_word didn't work reliably for w == 0 until 0.9.8 */ ++#define BN_abs_is_word(a,w) ((((a)->top == 1) && ((a)->d[0] == (BN_ULONG)(w))) || \ ++ (((w) == 0) && ((a)->top == 0))) ++#define BN_is_zero(a) ((a)->top == 0) ++#define BN_is_one(a) (BN_abs_is_word((a),1) && !(a)->neg) ++#define BN_is_word(a,w) (BN_abs_is_word((a),(w)) && (!(w) || !(a)->neg)) ++#define BN_is_odd(a) (((a)->top > 0) && ((a)->d[0] & 1)) ++ ++#define BN_one(a) (BN_set_word((a),1)) ++#define BN_zero_ex(a) \ ++ do { \ ++ BIGNUM *_tmp_bn = (a); \ ++ _tmp_bn->top = 0; \ ++ _tmp_bn->neg = 0; \ ++ } while(0) ++#ifdef OPENSSL_NO_DEPRECATED ++#define BN_zero(a) BN_zero_ex(a) ++#else ++#define BN_zero(a) (BN_set_word((a),0)) ++#endif ++ ++const BIGNUM *BN_value_one(void); ++char * BN_options(void); ++BN_CTX *BN_CTX_new(void); ++#ifndef OPENSSL_NO_DEPRECATED ++void BN_CTX_init(BN_CTX *c); ++#endif ++void BN_CTX_free(BN_CTX *c); ++void BN_CTX_start(BN_CTX *ctx); ++BIGNUM *BN_CTX_get(BN_CTX *ctx); ++void BN_CTX_end(BN_CTX *ctx); ++int BN_rand(BIGNUM *rnd, int bits, int top,int bottom); ++int BN_pseudo_rand(BIGNUM *rnd, int bits, int top,int bottom); ++int BN_rand_range(BIGNUM *rnd, const BIGNUM *range); ++int BN_pseudo_rand_range(BIGNUM *rnd, const BIGNUM *range); ++int BN_num_bits(const BIGNUM *a); ++int BN_num_bits_word(BN_ULONG); ++BIGNUM *BN_new(void); ++void BN_init(BIGNUM *); ++void BN_clear_free(BIGNUM *a); ++BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b); ++void BN_swap(BIGNUM *a, BIGNUM *b); ++BIGNUM *BN_bin2bn(const unsigned char *s,int len,BIGNUM *ret); ++int BN_bn2bin(const BIGNUM *a, unsigned char *to); ++BIGNUM *BN_mpi2bn(const unsigned char *s,int len,BIGNUM *ret); ++int BN_bn2mpi(const BIGNUM *a, unsigned char *to); ++int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); ++int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); ++int BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); ++int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); ++int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); ++int BN_sqr(BIGNUM *r, const BIGNUM *a,BN_CTX *ctx); ++/** BN_set_negative sets sign of a BIGNUM ++ * \param b pointer to the BIGNUM object ++ * \param n 0 if the BIGNUM b should be positive and a value != 0 otherwise ++ */ ++void BN_set_negative(BIGNUM *b, int n); ++/** BN_is_negative returns 1 if the BIGNUM is negative ++ * \param a pointer to the BIGNUM object ++ * \return 1 if a < 0 and 0 otherwise ++ */ ++#define BN_is_negative(a) ((a)->neg != 0) ++ ++int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d, ++ BN_CTX *ctx); ++#define BN_mod(rem,m,d,ctx) BN_div(NULL,(rem),(m),(d),(ctx)) ++int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx); ++int BN_mod_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, BN_CTX *ctx); ++int BN_mod_add_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m); ++int BN_mod_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, BN_CTX *ctx); ++int BN_mod_sub_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m); ++int BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, ++ const BIGNUM *m, BN_CTX *ctx); ++int BN_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx); ++int BN_mod_lshift1(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx); ++int BN_mod_lshift1_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *m); ++int BN_mod_lshift(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m, BN_CTX *ctx); ++int BN_mod_lshift_quick(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m); ++ ++BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w); ++BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w); ++int BN_mul_word(BIGNUM *a, BN_ULONG w); ++int BN_add_word(BIGNUM *a, BN_ULONG w); ++int BN_sub_word(BIGNUM *a, BN_ULONG w); ++int BN_set_word(BIGNUM *a, BN_ULONG w); ++BN_ULONG BN_get_word(const BIGNUM *a); ++ ++int BN_cmp(const BIGNUM *a, const BIGNUM *b); ++void BN_free(BIGNUM *a); ++int BN_is_bit_set(const BIGNUM *a, int n); ++int BN_lshift(BIGNUM *r, const BIGNUM *a, int n); ++int BN_lshift1(BIGNUM *r, const BIGNUM *a); ++int BN_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,BN_CTX *ctx); ++ ++int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, ++ const BIGNUM *m,BN_CTX *ctx); ++int BN_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, ++ const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); ++int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p, ++ const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont); ++int BN_mod_exp_mont_word(BIGNUM *r, BN_ULONG a, const BIGNUM *p, ++ const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); ++int BN_mod_exp2_mont(BIGNUM *r, const BIGNUM *a1, const BIGNUM *p1, ++ const BIGNUM *a2, const BIGNUM *p2,const BIGNUM *m, ++ BN_CTX *ctx,BN_MONT_CTX *m_ctx); ++int BN_mod_exp_simple(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, ++ const BIGNUM *m,BN_CTX *ctx); ++ ++int BN_mask_bits(BIGNUM *a,int n); ++#ifndef OPENSSL_NO_FP_API ++int BN_print_fp(FILE *fp, const BIGNUM *a); ++#endif ++#ifdef HEADER_BIO_H ++int BN_print(BIO *fp, const BIGNUM *a); ++#else ++int BN_print(void *fp, const BIGNUM *a); ++#endif ++int BN_reciprocal(BIGNUM *r, const BIGNUM *m, int len, BN_CTX *ctx); ++int BN_rshift(BIGNUM *r, const BIGNUM *a, int n); ++int BN_rshift1(BIGNUM *r, const BIGNUM *a); ++void BN_clear(BIGNUM *a); ++BIGNUM *BN_dup(const BIGNUM *a); ++int BN_ucmp(const BIGNUM *a, const BIGNUM *b); ++int BN_set_bit(BIGNUM *a, int n); ++int BN_clear_bit(BIGNUM *a, int n); ++char * BN_bn2hex(const BIGNUM *a); ++char * BN_bn2dec(const BIGNUM *a); ++int BN_hex2bn(BIGNUM **a, const char *str); ++int BN_dec2bn(BIGNUM **a, const char *str); ++int BN_asc2bn(BIGNUM **a, const char *str); ++int BN_gcd(BIGNUM *r,const BIGNUM *a,const BIGNUM *b,BN_CTX *ctx); ++int BN_kronecker(const BIGNUM *a,const BIGNUM *b,BN_CTX *ctx); /* returns -2 for error */ ++BIGNUM *BN_mod_inverse(BIGNUM *ret, ++ const BIGNUM *a, const BIGNUM *n,BN_CTX *ctx); ++BIGNUM *BN_mod_sqrt(BIGNUM *ret, ++ const BIGNUM *a, const BIGNUM *n,BN_CTX *ctx); ++ ++/* Deprecated versions */ ++#ifndef OPENSSL_NO_DEPRECATED ++BIGNUM *BN_generate_prime(BIGNUM *ret,int bits,int safe, ++ const BIGNUM *add, const BIGNUM *rem, ++ void (*callback)(int,int,void *),void *cb_arg); ++int BN_is_prime(const BIGNUM *p,int nchecks, ++ void (*callback)(int,int,void *), ++ BN_CTX *ctx,void *cb_arg); ++int BN_is_prime_fasttest(const BIGNUM *p,int nchecks, ++ void (*callback)(int,int,void *),BN_CTX *ctx,void *cb_arg, ++ int do_trial_division); ++#endif /* !defined(OPENSSL_NO_DEPRECATED) */ ++ ++/* Newer versions */ ++int BN_generate_prime_ex(BIGNUM *ret,int bits,int safe, const BIGNUM *add, ++ const BIGNUM *rem, BN_GENCB *cb); ++int BN_is_prime_ex(const BIGNUM *p,int nchecks, BN_CTX *ctx, BN_GENCB *cb); ++int BN_is_prime_fasttest_ex(const BIGNUM *p,int nchecks, BN_CTX *ctx, ++ int do_trial_division, BN_GENCB *cb); ++ ++BN_MONT_CTX *BN_MONT_CTX_new(void ); ++void BN_MONT_CTX_init(BN_MONT_CTX *ctx); ++int BN_mod_mul_montgomery(BIGNUM *r,const BIGNUM *a,const BIGNUM *b, ++ BN_MONT_CTX *mont, BN_CTX *ctx); ++#define BN_to_montgomery(r,a,mont,ctx) BN_mod_mul_montgomery(\ ++ (r),(a),&((mont)->RR),(mont),(ctx)) ++int BN_from_montgomery(BIGNUM *r,const BIGNUM *a, ++ BN_MONT_CTX *mont, BN_CTX *ctx); ++void BN_MONT_CTX_free(BN_MONT_CTX *mont); ++int BN_MONT_CTX_set(BN_MONT_CTX *mont,const BIGNUM *mod,BN_CTX *ctx); ++BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to,BN_MONT_CTX *from); ++BN_MONT_CTX *BN_MONT_CTX_set_locked(BN_MONT_CTX **pmont, int lock, ++ const BIGNUM *mod, BN_CTX *ctx); ++ ++/* BN_BLINDING flags */ ++#define BN_BLINDING_NO_UPDATE 0x00000001 ++#define BN_BLINDING_NO_RECREATE 0x00000002 ++ ++BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod); ++void BN_BLINDING_free(BN_BLINDING *b); ++int BN_BLINDING_update(BN_BLINDING *b,BN_CTX *ctx); ++int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx); ++int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx); ++int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *); ++int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b, BN_CTX *); ++#ifndef OPENSSL_NO_DEPRECATED ++unsigned long BN_BLINDING_get_thread_id(const BN_BLINDING *); ++void BN_BLINDING_set_thread_id(BN_BLINDING *, unsigned long); ++#endif ++CRYPTO_THREADID *BN_BLINDING_thread_id(BN_BLINDING *); ++unsigned long BN_BLINDING_get_flags(const BN_BLINDING *); ++void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long); ++BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b, ++ const BIGNUM *e, BIGNUM *m, BN_CTX *ctx, ++ int (*bn_mod_exp)(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, ++ const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx), ++ BN_MONT_CTX *m_ctx); ++ ++#ifndef OPENSSL_NO_DEPRECATED ++void BN_set_params(int mul,int high,int low,int mont); ++int BN_get_params(int which); /* 0, mul, 1 high, 2 low, 3 mont */ ++#endif ++ ++void BN_RECP_CTX_init(BN_RECP_CTX *recp); ++BN_RECP_CTX *BN_RECP_CTX_new(void); ++void BN_RECP_CTX_free(BN_RECP_CTX *recp); ++int BN_RECP_CTX_set(BN_RECP_CTX *recp,const BIGNUM *rdiv,BN_CTX *ctx); ++int BN_mod_mul_reciprocal(BIGNUM *r, const BIGNUM *x, const BIGNUM *y, ++ BN_RECP_CTX *recp,BN_CTX *ctx); ++int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, ++ const BIGNUM *m, BN_CTX *ctx); ++int BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, ++ BN_RECP_CTX *recp, BN_CTX *ctx); ++ ++/* Functions for arithmetic over binary polynomials represented by BIGNUMs. ++ * ++ * The BIGNUM::neg property of BIGNUMs representing binary polynomials is ++ * ignored. ++ * ++ * Note that input arguments are not const so that their bit arrays can ++ * be expanded to the appropriate size if needed. ++ */ ++ ++int BN_GF2m_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); /*r = a + b*/ ++#define BN_GF2m_sub(r, a, b) BN_GF2m_add(r, a, b) ++int BN_GF2m_mod(BIGNUM *r, const BIGNUM *a, const BIGNUM *p); /*r=a mod p*/ ++int BN_GF2m_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, ++ const BIGNUM *p, BN_CTX *ctx); /* r = (a * b) mod p */ ++int BN_GF2m_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, ++ BN_CTX *ctx); /* r = (a * a) mod p */ ++int BN_GF2m_mod_inv(BIGNUM *r, const BIGNUM *b, const BIGNUM *p, ++ BN_CTX *ctx); /* r = (1 / b) mod p */ ++int BN_GF2m_mod_div(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, ++ const BIGNUM *p, BN_CTX *ctx); /* r = (a / b) mod p */ ++int BN_GF2m_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, ++ const BIGNUM *p, BN_CTX *ctx); /* r = (a ^ b) mod p */ ++int BN_GF2m_mod_sqrt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, ++ BN_CTX *ctx); /* r = sqrt(a) mod p */ ++int BN_GF2m_mod_solve_quad(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, ++ BN_CTX *ctx); /* r^2 + r = a mod p */ ++#define BN_GF2m_cmp(a, b) BN_ucmp((a), (b)) ++/* Some functions allow for representation of the irreducible polynomials ++ * as an unsigned int[], say p. The irreducible f(t) is then of the form: ++ * t^p[0] + t^p[1] + ... + t^p[k] ++ * where m = p[0] > p[1] > ... > p[k] = 0. ++ */ ++int BN_GF2m_mod_arr(BIGNUM *r, const BIGNUM *a, const int p[]); ++ /* r = a mod p */ ++int BN_GF2m_mod_mul_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, ++ const int p[], BN_CTX *ctx); /* r = (a * b) mod p */ ++int BN_GF2m_mod_sqr_arr(BIGNUM *r, const BIGNUM *a, const int p[], ++ BN_CTX *ctx); /* r = (a * a) mod p */ ++int BN_GF2m_mod_inv_arr(BIGNUM *r, const BIGNUM *b, const int p[], ++ BN_CTX *ctx); /* r = (1 / b) mod p */ ++int BN_GF2m_mod_div_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, ++ const int p[], BN_CTX *ctx); /* r = (a / b) mod p */ ++int BN_GF2m_mod_exp_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, ++ const int p[], BN_CTX *ctx); /* r = (a ^ b) mod p */ ++int BN_GF2m_mod_sqrt_arr(BIGNUM *r, const BIGNUM *a, ++ const int p[], BN_CTX *ctx); /* r = sqrt(a) mod p */ ++int BN_GF2m_mod_solve_quad_arr(BIGNUM *r, const BIGNUM *a, ++ const int p[], BN_CTX *ctx); /* r^2 + r = a mod p */ ++int BN_GF2m_poly2arr(const BIGNUM *a, int p[], int max); ++int BN_GF2m_arr2poly(const int p[], BIGNUM *a); ++ ++/* faster mod functions for the 'NIST primes' ++ * 0 <= a < p^2 */ ++int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); ++int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); ++int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); ++int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); ++int BN_nist_mod_521(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); ++ ++const BIGNUM *BN_get0_nist_prime_192(void); ++const BIGNUM *BN_get0_nist_prime_224(void); ++const BIGNUM *BN_get0_nist_prime_256(void); ++const BIGNUM *BN_get0_nist_prime_384(void); ++const BIGNUM *BN_get0_nist_prime_521(void); ++ ++/* library internal functions */ ++ ++#define bn_expand(a,bits) ((((((bits+BN_BITS2-1))/BN_BITS2)) <= (a)->dmax)?\ ++ (a):bn_expand2((a),(bits+BN_BITS2-1)/BN_BITS2)) ++#define bn_wexpand(a,words) (((words) <= (a)->dmax)?(a):bn_expand2((a),(words))) ++BIGNUM *bn_expand2(BIGNUM *a, int words); ++#ifndef OPENSSL_NO_DEPRECATED ++BIGNUM *bn_dup_expand(const BIGNUM *a, int words); /* unused */ ++#endif ++ ++/* Bignum consistency macros ++ * There is one "API" macro, bn_fix_top(), for stripping leading zeroes from ++ * bignum data after direct manipulations on the data. There is also an ++ * "internal" macro, bn_check_top(), for verifying that there are no leading ++ * zeroes. Unfortunately, some auditing is required due to the fact that ++ * bn_fix_top() has become an overabused duct-tape because bignum data is ++ * occasionally passed around in an inconsistent state. So the following ++ * changes have been made to sort this out; ++ * - bn_fix_top()s implementation has been moved to bn_correct_top() ++ * - if BN_DEBUG isn't defined, bn_fix_top() maps to bn_correct_top(), and ++ * bn_check_top() is as before. ++ * - if BN_DEBUG *is* defined; ++ * - bn_check_top() tries to pollute unused words even if the bignum 'top' is ++ * consistent. (ed: only if BN_DEBUG_RAND is defined) ++ * - bn_fix_top() maps to bn_check_top() rather than "fixing" anything. ++ * The idea is to have debug builds flag up inconsistent bignums when they ++ * occur. If that occurs in a bn_fix_top(), we examine the code in question; if ++ * the use of bn_fix_top() was appropriate (ie. it follows directly after code ++ * that manipulates the bignum) it is converted to bn_correct_top(), and if it ++ * was not appropriate, we convert it permanently to bn_check_top() and track ++ * down the cause of the bug. Eventually, no internal code should be using the ++ * bn_fix_top() macro. External applications and libraries should try this with ++ * their own code too, both in terms of building against the openssl headers ++ * with BN_DEBUG defined *and* linking with a version of OpenSSL built with it ++ * defined. This not only improves external code, it provides more test ++ * coverage for openssl's own code. ++ */ ++ ++#ifdef BN_DEBUG ++ ++/* We only need assert() when debugging */ ++#include ++ ++#ifdef BN_DEBUG_RAND ++/* To avoid "make update" cvs wars due to BN_DEBUG, use some tricks */ ++#ifndef RAND_pseudo_bytes ++int RAND_pseudo_bytes(unsigned char *buf,int num); ++#define BN_DEBUG_TRIX ++#endif ++#define bn_pollute(a) \ ++ do { \ ++ const BIGNUM *_bnum1 = (a); \ ++ if(_bnum1->top < _bnum1->dmax) { \ ++ unsigned char _tmp_char; \ ++ /* We cast away const without the compiler knowing, any \ ++ * *genuinely* constant variables that aren't mutable \ ++ * wouldn't be constructed with top!=dmax. */ \ ++ BN_ULONG *_not_const; \ ++ memcpy(&_not_const, &_bnum1->d, sizeof(BN_ULONG*)); \ ++ RAND_pseudo_bytes(&_tmp_char, 1); \ ++ memset((unsigned char *)(_not_const + _bnum1->top), _tmp_char, \ ++ (_bnum1->dmax - _bnum1->top) * sizeof(BN_ULONG)); \ ++ } \ ++ } while(0) ++#ifdef BN_DEBUG_TRIX ++#undef RAND_pseudo_bytes ++#endif ++#else ++#define bn_pollute(a) ++#endif ++#define bn_check_top(a) \ ++ do { \ ++ const BIGNUM *_bnum2 = (a); \ ++ if (_bnum2 != NULL) { \ ++ assert((_bnum2->top == 0) || \ ++ (_bnum2->d[_bnum2->top - 1] != 0)); \ ++ bn_pollute(_bnum2); \ ++ } \ ++ } while(0) ++ ++#define bn_fix_top(a) bn_check_top(a) ++ ++#else /* !BN_DEBUG */ ++ ++#define bn_pollute(a) ++#define bn_check_top(a) ++#define bn_fix_top(a) bn_correct_top(a) ++ ++#endif ++ ++#define bn_correct_top(a) \ ++ { \ ++ BN_ULONG *ftl; \ ++ int tmp_top = (a)->top; \ ++ if (tmp_top > 0) \ ++ { \ ++ for (ftl= &((a)->d[tmp_top-1]); tmp_top > 0; tmp_top--) \ ++ if (*(ftl--)) break; \ ++ (a)->top = tmp_top; \ ++ } \ ++ bn_pollute(a); \ ++ } ++ ++BN_ULONG bn_mul_add_words(BN_ULONG *rp, const BN_ULONG *ap, int num, BN_ULONG w); ++BN_ULONG bn_mul_words(BN_ULONG *rp, const BN_ULONG *ap, int num, BN_ULONG w); ++void bn_sqr_words(BN_ULONG *rp, const BN_ULONG *ap, int num); ++BN_ULONG bn_div_words(BN_ULONG h, BN_ULONG l, BN_ULONG d); ++BN_ULONG bn_add_words(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,int num); ++BN_ULONG bn_sub_words(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,int num); ++ ++/* Primes from RFC 2409 */ ++BIGNUM *get_rfc2409_prime_768(BIGNUM *bn); ++BIGNUM *get_rfc2409_prime_1024(BIGNUM *bn); ++ ++/* Primes from RFC 3526 */ ++BIGNUM *get_rfc3526_prime_1536(BIGNUM *bn); ++BIGNUM *get_rfc3526_prime_2048(BIGNUM *bn); ++BIGNUM *get_rfc3526_prime_3072(BIGNUM *bn); ++BIGNUM *get_rfc3526_prime_4096(BIGNUM *bn); ++BIGNUM *get_rfc3526_prime_6144(BIGNUM *bn); ++BIGNUM *get_rfc3526_prime_8192(BIGNUM *bn); ++ ++int BN_bntest_rand(BIGNUM *rnd, int bits, int top,int bottom); ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_BN_strings(void); ++ ++/* Error codes for the BN functions. */ ++ ++/* Function codes. */ ++#define BN_F_BNRAND 127 ++#define BN_F_BN_BLINDING_CONVERT_EX 100 ++#define BN_F_BN_BLINDING_CREATE_PARAM 128 ++#define BN_F_BN_BLINDING_INVERT_EX 101 ++#define BN_F_BN_BLINDING_NEW 102 ++#define BN_F_BN_BLINDING_UPDATE 103 ++#define BN_F_BN_BN2DEC 104 ++#define BN_F_BN_BN2HEX 105 ++#define BN_F_BN_CTX_GET 116 ++#define BN_F_BN_CTX_NEW 106 ++#define BN_F_BN_CTX_START 129 ++#define BN_F_BN_DIV 107 ++#define BN_F_BN_DIV_NO_BRANCH 138 ++#define BN_F_BN_DIV_RECP 130 ++#define BN_F_BN_EXP 123 ++#define BN_F_BN_EXPAND2 108 ++#define BN_F_BN_EXPAND_INTERNAL 120 ++#define BN_F_BN_GF2M_MOD 131 ++#define BN_F_BN_GF2M_MOD_EXP 132 ++#define BN_F_BN_GF2M_MOD_MUL 133 ++#define BN_F_BN_GF2M_MOD_SOLVE_QUAD 134 ++#define BN_F_BN_GF2M_MOD_SOLVE_QUAD_ARR 135 ++#define BN_F_BN_GF2M_MOD_SQR 136 ++#define BN_F_BN_GF2M_MOD_SQRT 137 ++#define BN_F_BN_MOD_EXP2_MONT 118 ++#define BN_F_BN_MOD_EXP_MONT 109 ++#define BN_F_BN_MOD_EXP_MONT_CONSTTIME 124 ++#define BN_F_BN_MOD_EXP_MONT_WORD 117 ++#define BN_F_BN_MOD_EXP_RECP 125 ++#define BN_F_BN_MOD_EXP_SIMPLE 126 ++#define BN_F_BN_MOD_INVERSE 110 ++#define BN_F_BN_MOD_INVERSE_NO_BRANCH 139 ++#define BN_F_BN_MOD_LSHIFT_QUICK 119 ++#define BN_F_BN_MOD_MUL_RECIPROCAL 111 ++#define BN_F_BN_MOD_SQRT 121 ++#define BN_F_BN_MPI2BN 112 ++#define BN_F_BN_NEW 113 ++#define BN_F_BN_RAND 114 ++#define BN_F_BN_RAND_RANGE 122 ++#define BN_F_BN_USUB 115 ++ ++/* Reason codes. */ ++#define BN_R_ARG2_LT_ARG3 100 ++#define BN_R_BAD_RECIPROCAL 101 ++#define BN_R_BIGNUM_TOO_LONG 114 ++#define BN_R_CALLED_WITH_EVEN_MODULUS 102 ++#define BN_R_DIV_BY_ZERO 103 ++#define BN_R_ENCODING_ERROR 104 ++#define BN_R_EXPAND_ON_STATIC_BIGNUM_DATA 105 ++#define BN_R_INPUT_NOT_REDUCED 110 ++#define BN_R_INVALID_LENGTH 106 ++#define BN_R_INVALID_RANGE 115 ++#define BN_R_NOT_A_SQUARE 111 ++#define BN_R_NOT_INITIALIZED 107 ++#define BN_R_NO_INVERSE 108 ++#define BN_R_NO_SOLUTION 116 ++#define BN_R_P_IS_NOT_PRIME 112 ++#define BN_R_TOO_MANY_ITERATIONS 113 ++#define BN_R_TOO_MANY_TEMPORARY_VARIABLES 109 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/buffer.h qt.patched/include/openssl/buffer.h +--- qt.orig/include/openssl/buffer.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/buffer.h 2010-08-27 12:01:45.040167500 +0200 +@@ -0,0 +1,119 @@ ++/* crypto/buffer/buffer.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_BUFFER_H ++#define HEADER_BUFFER_H ++ ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#include ++ ++#if !defined(NO_SYS_TYPES_H) ++#include ++#endif ++ ++/* Already declared in ossl_typ.h */ ++/* typedef struct buf_mem_st BUF_MEM; */ ++ ++struct buf_mem_st ++ { ++ size_t length; /* current number of bytes */ ++ char *data; ++ size_t max; /* size of buffer */ ++ }; ++ ++BUF_MEM *BUF_MEM_new(void); ++void BUF_MEM_free(BUF_MEM *a); ++int BUF_MEM_grow(BUF_MEM *str, size_t len); ++int BUF_MEM_grow_clean(BUF_MEM *str, size_t len); ++char * BUF_strdup(const char *str); ++char * BUF_strndup(const char *str, size_t siz); ++void * BUF_memdup(const void *data, size_t siz); ++void BUF_reverse(unsigned char *out, unsigned char *in, size_t siz); ++ ++/* safe string functions */ ++size_t BUF_strlcpy(char *dst,const char *src,size_t siz); ++size_t BUF_strlcat(char *dst,const char *src,size_t siz); ++ ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_BUF_strings(void); ++ ++/* Error codes for the BUF functions. */ ++ ++/* Function codes. */ ++#define BUF_F_BUF_MEMDUP 103 ++#define BUF_F_BUF_MEM_GROW 100 ++#define BUF_F_BUF_MEM_GROW_CLEAN 105 ++#define BUF_F_BUF_MEM_NEW 101 ++#define BUF_F_BUF_STRDUP 102 ++#define BUF_F_BUF_STRNDUP 104 ++ ++/* Reason codes. */ ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/camellia.h qt.patched/include/openssl/camellia.h +--- qt.orig/include/openssl/camellia.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/camellia.h 2010-08-27 12:01:45.055791900 +0200 +@@ -0,0 +1,126 @@ ++/* crypto/camellia/camellia.h -*- mode:C; c-file-style: "eay" -*- */ ++/* ==================================================================== ++ * Copyright (c) 2006 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * openssl-core@openssl.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.openssl.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ */ ++ ++#ifndef HEADER_CAMELLIA_H ++#define HEADER_CAMELLIA_H ++ ++#include ++ ++#ifdef OPENSSL_NO_CAMELLIA ++#error CAMELLIA is disabled. ++#endif ++ ++#include ++ ++#define CAMELLIA_ENCRYPT 1 ++#define CAMELLIA_DECRYPT 0 ++ ++/* Because array size can't be a const in C, the following two are macros. ++ Both sizes are in bytes. */ ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* This should be a hidden type, but EVP requires that the size be known */ ++ ++#define CAMELLIA_BLOCK_SIZE 16 ++#define CAMELLIA_TABLE_BYTE_LEN 272 ++#define CAMELLIA_TABLE_WORD_LEN (CAMELLIA_TABLE_BYTE_LEN / 4) ++ ++typedef unsigned int KEY_TABLE_TYPE[CAMELLIA_TABLE_WORD_LEN]; /* to match with WORD */ ++ ++struct camellia_key_st ++ { ++ union { ++ double d; /* ensures 64-bit align */ ++ KEY_TABLE_TYPE rd_key; ++ } u; ++ int grand_rounds; ++ }; ++typedef struct camellia_key_st CAMELLIA_KEY; ++ ++int Camellia_set_key(const unsigned char *userKey, const int bits, ++ CAMELLIA_KEY *key); ++ ++void Camellia_encrypt(const unsigned char *in, unsigned char *out, ++ const CAMELLIA_KEY *key); ++void Camellia_decrypt(const unsigned char *in, unsigned char *out, ++ const CAMELLIA_KEY *key); ++ ++void Camellia_ecb_encrypt(const unsigned char *in, unsigned char *out, ++ const CAMELLIA_KEY *key, const int enc); ++void Camellia_cbc_encrypt(const unsigned char *in, unsigned char *out, ++ size_t length, const CAMELLIA_KEY *key, ++ unsigned char *ivec, const int enc); ++void Camellia_cfb128_encrypt(const unsigned char *in, unsigned char *out, ++ size_t length, const CAMELLIA_KEY *key, ++ unsigned char *ivec, int *num, const int enc); ++void Camellia_cfb1_encrypt(const unsigned char *in, unsigned char *out, ++ size_t length, const CAMELLIA_KEY *key, ++ unsigned char *ivec, int *num, const int enc); ++void Camellia_cfb8_encrypt(const unsigned char *in, unsigned char *out, ++ size_t length, const CAMELLIA_KEY *key, ++ unsigned char *ivec, int *num, const int enc); ++void Camellia_ofb128_encrypt(const unsigned char *in, unsigned char *out, ++ size_t length, const CAMELLIA_KEY *key, ++ unsigned char *ivec, int *num); ++void Camellia_ctr128_encrypt(const unsigned char *in, unsigned char *out, ++ size_t length, const CAMELLIA_KEY *key, ++ unsigned char ivec[CAMELLIA_BLOCK_SIZE], ++ unsigned char ecount_buf[CAMELLIA_BLOCK_SIZE], ++ unsigned int *num); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* !HEADER_Camellia_H */ +diff -urN qt.orig/include/openssl/cast.h qt.patched/include/openssl/cast.h +--- qt.orig/include/openssl/cast.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/cast.h 2010-08-27 12:01:45.055791900 +0200 +@@ -0,0 +1,105 @@ ++/* crypto/cast/cast.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_CAST_H ++#define HEADER_CAST_H ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#include ++ ++#ifdef OPENSSL_NO_CAST ++#error CAST is disabled. ++#endif ++ ++#define CAST_ENCRYPT 1 ++#define CAST_DECRYPT 0 ++ ++#define CAST_LONG unsigned int ++ ++#define CAST_BLOCK 8 ++#define CAST_KEY_LENGTH 16 ++ ++typedef struct cast_key_st ++ { ++ CAST_LONG data[32]; ++ int short_key; /* Use reduced rounds for short key */ ++ } CAST_KEY; ++ ++ ++void CAST_set_key(CAST_KEY *key, int len, const unsigned char *data); ++void CAST_ecb_encrypt(const unsigned char *in, unsigned char *out, const CAST_KEY *key, ++ int enc); ++void CAST_encrypt(CAST_LONG *data, const CAST_KEY *key); ++void CAST_decrypt(CAST_LONG *data, const CAST_KEY *key); ++void CAST_cbc_encrypt(const unsigned char *in, unsigned char *out, long length, ++ const CAST_KEY *ks, unsigned char *iv, int enc); ++void CAST_cfb64_encrypt(const unsigned char *in, unsigned char *out, ++ long length, const CAST_KEY *schedule, unsigned char *ivec, ++ int *num, int enc); ++void CAST_ofb64_encrypt(const unsigned char *in, unsigned char *out, ++ long length, const CAST_KEY *schedule, unsigned char *ivec, ++ int *num); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff -urN qt.orig/include/openssl/cms.h qt.patched/include/openssl/cms.h +--- qt.orig/include/openssl/cms.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/cms.h 2010-08-27 12:01:45.071416300 +0200 +@@ -0,0 +1,479 @@ ++/* crypto/cms/cms.h */ ++/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL ++ * project. ++ */ ++/* ==================================================================== ++ * Copyright (c) 2008 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * licensing@OpenSSL.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ */ ++ ++ ++#ifndef HEADER_CMS_H ++#define HEADER_CMS_H ++ ++#include ++ ++#ifdef OPENSSL_NO_CMS ++#error CMS is disabled. ++#endif ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++ ++typedef struct CMS_ContentInfo_st CMS_ContentInfo; ++typedef struct CMS_SignerInfo_st CMS_SignerInfo; ++typedef struct CMS_CertificateChoices CMS_CertificateChoices; ++typedef struct CMS_RevocationInfoChoice_st CMS_RevocationInfoChoice; ++typedef struct CMS_RecipientInfo_st CMS_RecipientInfo; ++typedef struct CMS_ReceiptRequest_st CMS_ReceiptRequest; ++typedef struct CMS_Receipt_st CMS_Receipt; ++ ++DECLARE_STACK_OF(CMS_SignerInfo) ++DECLARE_STACK_OF(GENERAL_NAMES) ++DECLARE_ASN1_FUNCTIONS(CMS_ContentInfo) ++DECLARE_ASN1_FUNCTIONS(CMS_ReceiptRequest) ++DECLARE_ASN1_PRINT_FUNCTION(CMS_ContentInfo) ++ ++#define CMS_SIGNERINFO_ISSUER_SERIAL 0 ++#define CMS_SIGNERINFO_KEYIDENTIFIER 1 ++ ++#define CMS_RECIPINFO_TRANS 0 ++#define CMS_RECIPINFO_AGREE 1 ++#define CMS_RECIPINFO_KEK 2 ++#define CMS_RECIPINFO_PASS 3 ++#define CMS_RECIPINFO_OTHER 4 ++ ++/* S/MIME related flags */ ++ ++#define CMS_TEXT 0x1 ++#define CMS_NOCERTS 0x2 ++#define CMS_NO_CONTENT_VERIFY 0x4 ++#define CMS_NO_ATTR_VERIFY 0x8 ++#define CMS_NOSIGS \ ++ (CMS_NO_CONTENT_VERIFY|CMS_NO_ATTR_VERIFY) ++#define CMS_NOINTERN 0x10 ++#define CMS_NO_SIGNER_CERT_VERIFY 0x20 ++#define CMS_NOVERIFY 0x20 ++#define CMS_DETACHED 0x40 ++#define CMS_BINARY 0x80 ++#define CMS_NOATTR 0x100 ++#define CMS_NOSMIMECAP 0x200 ++#define CMS_NOOLDMIMETYPE 0x400 ++#define CMS_CRLFEOL 0x800 ++#define CMS_STREAM 0x1000 ++#define CMS_NOCRL 0x2000 ++#define CMS_PARTIAL 0x4000 ++#define CMS_REUSE_DIGEST 0x8000 ++#define CMS_USE_KEYID 0x10000 ++ ++const ASN1_OBJECT *CMS_get0_type(CMS_ContentInfo *cms); ++ ++BIO *CMS_dataInit(CMS_ContentInfo *cms, BIO *icont); ++int CMS_dataFinal(CMS_ContentInfo *cms, BIO *bio); ++ ++ASN1_OCTET_STRING **CMS_get0_content(CMS_ContentInfo *cms); ++int CMS_is_detached(CMS_ContentInfo *cms); ++int CMS_set_detached(CMS_ContentInfo *cms, int detached); ++ ++#ifdef HEADER_PEM_H ++DECLARE_PEM_rw_const(CMS, CMS_ContentInfo) ++#endif ++ ++int CMS_stream(unsigned char ***boundary, CMS_ContentInfo *cms); ++CMS_ContentInfo *d2i_CMS_bio(BIO *bp, CMS_ContentInfo **cms); ++int i2d_CMS_bio(BIO *bp, CMS_ContentInfo *cms); ++ ++BIO *BIO_new_CMS(BIO *out, CMS_ContentInfo *cms); ++int i2d_CMS_bio_stream(BIO *out, CMS_ContentInfo *cms, BIO *in, int flags); ++int PEM_write_bio_CMS_stream(BIO *out, CMS_ContentInfo *cms, BIO *in, int flags); ++CMS_ContentInfo *SMIME_read_CMS(BIO *bio, BIO **bcont); ++int SMIME_write_CMS(BIO *bio, CMS_ContentInfo *cms, BIO *data, int flags); ++ ++int CMS_final(CMS_ContentInfo *cms, BIO *data, BIO *dcont, unsigned int flags); ++ ++CMS_ContentInfo *CMS_sign(X509 *signcert, EVP_PKEY *pkey, STACK_OF(X509) *certs, ++ BIO *data, unsigned int flags); ++ ++CMS_ContentInfo *CMS_sign_receipt(CMS_SignerInfo *si, ++ X509 *signcert, EVP_PKEY *pkey, ++ STACK_OF(X509) *certs, ++ unsigned int flags); ++ ++int CMS_data(CMS_ContentInfo *cms, BIO *out, unsigned int flags); ++CMS_ContentInfo *CMS_data_create(BIO *in, unsigned int flags); ++ ++int CMS_digest_verify(CMS_ContentInfo *cms, BIO *dcont, BIO *out, ++ unsigned int flags); ++CMS_ContentInfo *CMS_digest_create(BIO *in, const EVP_MD *md, ++ unsigned int flags); ++ ++int CMS_EncryptedData_decrypt(CMS_ContentInfo *cms, ++ const unsigned char *key, size_t keylen, ++ BIO *dcont, BIO *out, unsigned int flags); ++ ++CMS_ContentInfo *CMS_EncryptedData_encrypt(BIO *in, const EVP_CIPHER *cipher, ++ const unsigned char *key, size_t keylen, ++ unsigned int flags); ++ ++int CMS_EncryptedData_set1_key(CMS_ContentInfo *cms, const EVP_CIPHER *ciph, ++ const unsigned char *key, size_t keylen); ++ ++int CMS_verify(CMS_ContentInfo *cms, STACK_OF(X509) *certs, ++ X509_STORE *store, BIO *dcont, BIO *out, unsigned int flags); ++ ++int CMS_verify_receipt(CMS_ContentInfo *rcms, CMS_ContentInfo *ocms, ++ STACK_OF(X509) *certs, ++ X509_STORE *store, unsigned int flags); ++ ++STACK_OF(X509) *CMS_get0_signers(CMS_ContentInfo *cms); ++ ++CMS_ContentInfo *CMS_encrypt(STACK_OF(X509) *certs, BIO *in, ++ const EVP_CIPHER *cipher, unsigned int flags); ++ ++int CMS_decrypt(CMS_ContentInfo *cms, EVP_PKEY *pkey, X509 *cert, ++ BIO *dcont, BIO *out, ++ unsigned int flags); ++ ++int CMS_decrypt_set1_pkey(CMS_ContentInfo *cms, EVP_PKEY *pk, X509 *cert); ++int CMS_decrypt_set1_key(CMS_ContentInfo *cms, ++ unsigned char *key, size_t keylen, ++ unsigned char *id, size_t idlen); ++ ++STACK_OF(CMS_RecipientInfo) *CMS_get0_RecipientInfos(CMS_ContentInfo *cms); ++int CMS_RecipientInfo_type(CMS_RecipientInfo *ri); ++CMS_ContentInfo *CMS_EnvelopedData_create(const EVP_CIPHER *cipher); ++CMS_RecipientInfo *CMS_add1_recipient_cert(CMS_ContentInfo *cms, ++ X509 *recip, unsigned int flags); ++int CMS_RecipientInfo_set0_pkey(CMS_RecipientInfo *ri, EVP_PKEY *pkey); ++int CMS_RecipientInfo_ktri_cert_cmp(CMS_RecipientInfo *ri, X509 *cert); ++int CMS_RecipientInfo_ktri_get0_algs(CMS_RecipientInfo *ri, ++ EVP_PKEY **pk, X509 **recip, ++ X509_ALGOR **palg); ++int CMS_RecipientInfo_ktri_get0_signer_id(CMS_RecipientInfo *ri, ++ ASN1_OCTET_STRING **keyid, ++ X509_NAME **issuer, ASN1_INTEGER **sno); ++ ++CMS_RecipientInfo *CMS_add0_recipient_key(CMS_ContentInfo *cms, int nid, ++ unsigned char *key, size_t keylen, ++ unsigned char *id, size_t idlen, ++ ASN1_GENERALIZEDTIME *date, ++ ASN1_OBJECT *otherTypeId, ++ ASN1_TYPE *otherType); ++ ++int CMS_RecipientInfo_kekri_get0_id(CMS_RecipientInfo *ri, ++ X509_ALGOR **palg, ++ ASN1_OCTET_STRING **pid, ++ ASN1_GENERALIZEDTIME **pdate, ++ ASN1_OBJECT **potherid, ++ ASN1_TYPE **pothertype); ++ ++int CMS_RecipientInfo_set0_key(CMS_RecipientInfo *ri, ++ unsigned char *key, size_t keylen); ++ ++int CMS_RecipientInfo_kekri_id_cmp(CMS_RecipientInfo *ri, ++ const unsigned char *id, size_t idlen); ++ ++int CMS_RecipientInfo_decrypt(CMS_ContentInfo *cms, CMS_RecipientInfo *ri); ++ ++int CMS_uncompress(CMS_ContentInfo *cms, BIO *dcont, BIO *out, ++ unsigned int flags); ++CMS_ContentInfo *CMS_compress(BIO *in, int comp_nid, unsigned int flags); ++ ++int CMS_set1_eContentType(CMS_ContentInfo *cms, const ASN1_OBJECT *oid); ++const ASN1_OBJECT *CMS_get0_eContentType(CMS_ContentInfo *cms); ++ ++CMS_CertificateChoices *CMS_add0_CertificateChoices(CMS_ContentInfo *cms); ++int CMS_add0_cert(CMS_ContentInfo *cms, X509 *cert); ++int CMS_add1_cert(CMS_ContentInfo *cms, X509 *cert); ++STACK_OF(X509) *CMS_get1_certs(CMS_ContentInfo *cms); ++ ++CMS_RevocationInfoChoice *CMS_add0_RevocationInfoChoice(CMS_ContentInfo *cms); ++int CMS_add0_crl(CMS_ContentInfo *cms, X509_CRL *crl); ++int CMS_add1_crl(CMS_ContentInfo *cms, X509_CRL *crl); ++STACK_OF(X509_CRL) *CMS_get1_crls(CMS_ContentInfo *cms); ++ ++int CMS_SignedData_init(CMS_ContentInfo *cms); ++CMS_SignerInfo *CMS_add1_signer(CMS_ContentInfo *cms, ++ X509 *signer, EVP_PKEY *pk, const EVP_MD *md, ++ unsigned int flags); ++STACK_OF(CMS_SignerInfo) *CMS_get0_SignerInfos(CMS_ContentInfo *cms); ++ ++void CMS_SignerInfo_set1_signer_cert(CMS_SignerInfo *si, X509 *signer); ++int CMS_SignerInfo_get0_signer_id(CMS_SignerInfo *si, ++ ASN1_OCTET_STRING **keyid, ++ X509_NAME **issuer, ASN1_INTEGER **sno); ++int CMS_SignerInfo_cert_cmp(CMS_SignerInfo *si, X509 *cert); ++int CMS_set1_signers_certs(CMS_ContentInfo *cms, STACK_OF(X509) *certs, ++ unsigned int flags); ++void CMS_SignerInfo_get0_algs(CMS_SignerInfo *si, EVP_PKEY **pk, X509 **signer, ++ X509_ALGOR **pdig, X509_ALGOR **psig); ++int CMS_SignerInfo_sign(CMS_SignerInfo *si); ++int CMS_SignerInfo_verify(CMS_SignerInfo *si); ++int CMS_SignerInfo_verify_content(CMS_SignerInfo *si, BIO *chain); ++ ++int CMS_add_smimecap(CMS_SignerInfo *si, STACK_OF(X509_ALGOR) *algs); ++int CMS_add_simple_smimecap(STACK_OF(X509_ALGOR) **algs, ++ int algnid, int keysize); ++int CMS_add_standard_smimecap(STACK_OF(X509_ALGOR) **smcap); ++ ++int CMS_signed_get_attr_count(const CMS_SignerInfo *si); ++int CMS_signed_get_attr_by_NID(const CMS_SignerInfo *si, int nid, ++ int lastpos); ++int CMS_signed_get_attr_by_OBJ(const CMS_SignerInfo *si, ASN1_OBJECT *obj, ++ int lastpos); ++X509_ATTRIBUTE *CMS_signed_get_attr(const CMS_SignerInfo *si, int loc); ++X509_ATTRIBUTE *CMS_signed_delete_attr(CMS_SignerInfo *si, int loc); ++int CMS_signed_add1_attr(CMS_SignerInfo *si, X509_ATTRIBUTE *attr); ++int CMS_signed_add1_attr_by_OBJ(CMS_SignerInfo *si, ++ const ASN1_OBJECT *obj, int type, ++ const void *bytes, int len); ++int CMS_signed_add1_attr_by_NID(CMS_SignerInfo *si, ++ int nid, int type, ++ const void *bytes, int len); ++int CMS_signed_add1_attr_by_txt(CMS_SignerInfo *si, ++ const char *attrname, int type, ++ const void *bytes, int len); ++void *CMS_signed_get0_data_by_OBJ(CMS_SignerInfo *si, ASN1_OBJECT *oid, ++ int lastpos, int type); ++ ++int CMS_unsigned_get_attr_count(const CMS_SignerInfo *si); ++int CMS_unsigned_get_attr_by_NID(const CMS_SignerInfo *si, int nid, ++ int lastpos); ++int CMS_unsigned_get_attr_by_OBJ(const CMS_SignerInfo *si, ASN1_OBJECT *obj, ++ int lastpos); ++X509_ATTRIBUTE *CMS_unsigned_get_attr(const CMS_SignerInfo *si, int loc); ++X509_ATTRIBUTE *CMS_unsigned_delete_attr(CMS_SignerInfo *si, int loc); ++int CMS_unsigned_add1_attr(CMS_SignerInfo *si, X509_ATTRIBUTE *attr); ++int CMS_unsigned_add1_attr_by_OBJ(CMS_SignerInfo *si, ++ const ASN1_OBJECT *obj, int type, ++ const void *bytes, int len); ++int CMS_unsigned_add1_attr_by_NID(CMS_SignerInfo *si, ++ int nid, int type, ++ const void *bytes, int len); ++int CMS_unsigned_add1_attr_by_txt(CMS_SignerInfo *si, ++ const char *attrname, int type, ++ const void *bytes, int len); ++void *CMS_unsigned_get0_data_by_OBJ(CMS_SignerInfo *si, ASN1_OBJECT *oid, ++ int lastpos, int type); ++ ++#ifdef HEADER_X509V3_H ++ ++int CMS_get1_ReceiptRequest(CMS_SignerInfo *si, CMS_ReceiptRequest **prr); ++CMS_ReceiptRequest *CMS_ReceiptRequest_create0(unsigned char *id, int idlen, ++ int allorfirst, ++ STACK_OF(GENERAL_NAMES) *receiptList, ++ STACK_OF(GENERAL_NAMES) *receiptsTo); ++int CMS_add1_ReceiptRequest(CMS_SignerInfo *si, CMS_ReceiptRequest *rr); ++void CMS_ReceiptRequest_get0_values(CMS_ReceiptRequest *rr, ++ ASN1_STRING **pcid, ++ int *pallorfirst, ++ STACK_OF(GENERAL_NAMES) **plist, ++ STACK_OF(GENERAL_NAMES) **prto); ++ ++#endif ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_CMS_strings(void); ++ ++/* Error codes for the CMS functions. */ ++ ++/* Function codes. */ ++#define CMS_F_CHECK_CONTENT 99 ++#define CMS_F_CMS_ADD0_CERT 164 ++#define CMS_F_CMS_ADD0_RECIPIENT_KEY 100 ++#define CMS_F_CMS_ADD1_RECEIPTREQUEST 158 ++#define CMS_F_CMS_ADD1_RECIPIENT_CERT 101 ++#define CMS_F_CMS_ADD1_SIGNER 102 ++#define CMS_F_CMS_ADD1_SIGNINGTIME 103 ++#define CMS_F_CMS_COMPRESS 104 ++#define CMS_F_CMS_COMPRESSEDDATA_CREATE 105 ++#define CMS_F_CMS_COMPRESSEDDATA_INIT_BIO 106 ++#define CMS_F_CMS_COPY_CONTENT 107 ++#define CMS_F_CMS_COPY_MESSAGEDIGEST 108 ++#define CMS_F_CMS_DATA 109 ++#define CMS_F_CMS_DATAFINAL 110 ++#define CMS_F_CMS_DATAINIT 111 ++#define CMS_F_CMS_DECRYPT 112 ++#define CMS_F_CMS_DECRYPT_SET1_KEY 113 ++#define CMS_F_CMS_DECRYPT_SET1_PKEY 114 ++#define CMS_F_CMS_DIGESTALGORITHM_FIND_CTX 115 ++#define CMS_F_CMS_DIGESTALGORITHM_INIT_BIO 116 ++#define CMS_F_CMS_DIGESTEDDATA_DO_FINAL 117 ++#define CMS_F_CMS_DIGEST_VERIFY 118 ++#define CMS_F_CMS_ENCODE_RECEIPT 161 ++#define CMS_F_CMS_ENCRYPT 119 ++#define CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO 120 ++#define CMS_F_CMS_ENCRYPTEDDATA_DECRYPT 121 ++#define CMS_F_CMS_ENCRYPTEDDATA_ENCRYPT 122 ++#define CMS_F_CMS_ENCRYPTEDDATA_SET1_KEY 123 ++#define CMS_F_CMS_ENVELOPEDDATA_CREATE 124 ++#define CMS_F_CMS_ENVELOPEDDATA_INIT_BIO 125 ++#define CMS_F_CMS_ENVELOPED_DATA_INIT 126 ++#define CMS_F_CMS_FINAL 127 ++#define CMS_F_CMS_GET0_CERTIFICATE_CHOICES 128 ++#define CMS_F_CMS_GET0_CONTENT 129 ++#define CMS_F_CMS_GET0_ECONTENT_TYPE 130 ++#define CMS_F_CMS_GET0_ENVELOPED 131 ++#define CMS_F_CMS_GET0_REVOCATION_CHOICES 132 ++#define CMS_F_CMS_GET0_SIGNED 133 ++#define CMS_F_CMS_MSGSIGDIGEST_ADD1 162 ++#define CMS_F_CMS_RECEIPTREQUEST_CREATE0 159 ++#define CMS_F_CMS_RECEIPT_VERIFY 160 ++#define CMS_F_CMS_RECIPIENTINFO_DECRYPT 134 ++#define CMS_F_CMS_RECIPIENTINFO_KEKRI_DECRYPT 135 ++#define CMS_F_CMS_RECIPIENTINFO_KEKRI_ENCRYPT 136 ++#define CMS_F_CMS_RECIPIENTINFO_KEKRI_GET0_ID 137 ++#define CMS_F_CMS_RECIPIENTINFO_KEKRI_ID_CMP 138 ++#define CMS_F_CMS_RECIPIENTINFO_KTRI_CERT_CMP 139 ++#define CMS_F_CMS_RECIPIENTINFO_KTRI_DECRYPT 140 ++#define CMS_F_CMS_RECIPIENTINFO_KTRI_ENCRYPT 141 ++#define CMS_F_CMS_RECIPIENTINFO_KTRI_GET0_ALGS 142 ++#define CMS_F_CMS_RECIPIENTINFO_KTRI_GET0_SIGNER_ID 143 ++#define CMS_F_CMS_RECIPIENTINFO_SET0_KEY 144 ++#define CMS_F_CMS_RECIPIENTINFO_SET0_PKEY 145 ++#define CMS_F_CMS_SET1_SIGNERIDENTIFIER 146 ++#define CMS_F_CMS_SET_DETACHED 147 ++#define CMS_F_CMS_SIGN 148 ++#define CMS_F_CMS_SIGNED_DATA_INIT 149 ++#define CMS_F_CMS_SIGNERINFO_CONTENT_SIGN 150 ++#define CMS_F_CMS_SIGNERINFO_SIGN 151 ++#define CMS_F_CMS_SIGNERINFO_VERIFY 152 ++#define CMS_F_CMS_SIGNERINFO_VERIFY_CERT 153 ++#define CMS_F_CMS_SIGNERINFO_VERIFY_CONTENT 154 ++#define CMS_F_CMS_SIGN_RECEIPT 163 ++#define CMS_F_CMS_STREAM 155 ++#define CMS_F_CMS_UNCOMPRESS 156 ++#define CMS_F_CMS_VERIFY 157 ++ ++/* Reason codes. */ ++#define CMS_R_ADD_SIGNER_ERROR 99 ++#define CMS_R_CERTIFICATE_ALREADY_PRESENT 175 ++#define CMS_R_CERTIFICATE_HAS_NO_KEYID 160 ++#define CMS_R_CERTIFICATE_VERIFY_ERROR 100 ++#define CMS_R_CIPHER_INITIALISATION_ERROR 101 ++#define CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR 102 ++#define CMS_R_CMS_DATAFINAL_ERROR 103 ++#define CMS_R_CMS_LIB 104 ++#define CMS_R_CONTENTIDENTIFIER_MISMATCH 170 ++#define CMS_R_CONTENT_NOT_FOUND 105 ++#define CMS_R_CONTENT_TYPE_MISMATCH 171 ++#define CMS_R_CONTENT_TYPE_NOT_COMPRESSED_DATA 106 ++#define CMS_R_CONTENT_TYPE_NOT_ENVELOPED_DATA 107 ++#define CMS_R_CONTENT_TYPE_NOT_SIGNED_DATA 108 ++#define CMS_R_CONTENT_VERIFY_ERROR 109 ++#define CMS_R_CTRL_ERROR 110 ++#define CMS_R_CTRL_FAILURE 111 ++#define CMS_R_DECRYPT_ERROR 112 ++#define CMS_R_DIGEST_ERROR 161 ++#define CMS_R_ERROR_GETTING_PUBLIC_KEY 113 ++#define CMS_R_ERROR_READING_MESSAGEDIGEST_ATTRIBUTE 114 ++#define CMS_R_ERROR_SETTING_KEY 115 ++#define CMS_R_ERROR_SETTING_RECIPIENTINFO 116 ++#define CMS_R_INVALID_ENCRYPTED_KEY_LENGTH 117 ++#define CMS_R_INVALID_KEY_LENGTH 118 ++#define CMS_R_MD_BIO_INIT_ERROR 119 ++#define CMS_R_MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH 120 ++#define CMS_R_MESSAGEDIGEST_WRONG_LENGTH 121 ++#define CMS_R_MSGSIGDIGEST_ERROR 172 ++#define CMS_R_MSGSIGDIGEST_VERIFICATION_FAILURE 162 ++#define CMS_R_MSGSIGDIGEST_WRONG_LENGTH 163 ++#define CMS_R_NEED_ONE_SIGNER 164 ++#define CMS_R_NOT_A_SIGNED_RECEIPT 165 ++#define CMS_R_NOT_ENCRYPTED_DATA 122 ++#define CMS_R_NOT_KEK 123 ++#define CMS_R_NOT_KEY_TRANSPORT 124 ++#define CMS_R_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 125 ++#define CMS_R_NO_CIPHER 126 ++#define CMS_R_NO_CONTENT 127 ++#define CMS_R_NO_CONTENT_TYPE 173 ++#define CMS_R_NO_DEFAULT_DIGEST 128 ++#define CMS_R_NO_DIGEST_SET 129 ++#define CMS_R_NO_KEY 130 ++#define CMS_R_NO_KEY_OR_CERT 174 ++#define CMS_R_NO_MATCHING_DIGEST 131 ++#define CMS_R_NO_MATCHING_RECIPIENT 132 ++#define CMS_R_NO_MATCHING_SIGNATURE 166 ++#define CMS_R_NO_MSGSIGDIGEST 167 ++#define CMS_R_NO_PRIVATE_KEY 133 ++#define CMS_R_NO_PUBLIC_KEY 134 ++#define CMS_R_NO_RECEIPT_REQUEST 168 ++#define CMS_R_NO_SIGNERS 135 ++#define CMS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 136 ++#define CMS_R_RECEIPT_DECODE_ERROR 169 ++#define CMS_R_RECIPIENT_ERROR 137 ++#define CMS_R_SIGNER_CERTIFICATE_NOT_FOUND 138 ++#define CMS_R_SIGNFINAL_ERROR 139 ++#define CMS_R_SMIME_TEXT_ERROR 140 ++#define CMS_R_STORE_INIT_ERROR 141 ++#define CMS_R_TYPE_NOT_COMPRESSED_DATA 142 ++#define CMS_R_TYPE_NOT_DATA 143 ++#define CMS_R_TYPE_NOT_DIGESTED_DATA 144 ++#define CMS_R_TYPE_NOT_ENCRYPTED_DATA 145 ++#define CMS_R_TYPE_NOT_ENVELOPED_DATA 146 ++#define CMS_R_UNABLE_TO_FINALIZE_CONTEXT 147 ++#define CMS_R_UNKNOWN_CIPHER 148 ++#define CMS_R_UNKNOWN_DIGEST_ALGORIHM 149 ++#define CMS_R_UNKNOWN_ID 150 ++#define CMS_R_UNSUPPORTED_COMPRESSION_ALGORITHM 151 ++#define CMS_R_UNSUPPORTED_CONTENT_TYPE 152 ++#define CMS_R_UNSUPPORTED_KEK_ALGORITHM 153 ++#define CMS_R_UNSUPPORTED_RECIPIENT_TYPE 154 ++#define CMS_R_UNSUPPORTED_RECPIENTINFO_TYPE 155 ++#define CMS_R_UNSUPPORTED_TYPE 156 ++#define CMS_R_UNWRAP_ERROR 157 ++#define CMS_R_VERIFICATION_FAILURE 158 ++#define CMS_R_WRAP_ERROR 159 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/comp.h qt.patched/include/openssl/comp.h +--- qt.orig/include/openssl/comp.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/comp.h 2010-08-27 12:01:45.087040700 +0200 +@@ -0,0 +1,80 @@ ++ ++#ifndef HEADER_COMP_H ++#define HEADER_COMP_H ++ ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++typedef struct comp_ctx_st COMP_CTX; ++ ++typedef struct comp_method_st ++ { ++ int type; /* NID for compression library */ ++ const char *name; /* A text string to identify the library */ ++ int (*init)(COMP_CTX *ctx); ++ void (*finish)(COMP_CTX *ctx); ++ int (*compress)(COMP_CTX *ctx, ++ unsigned char *out, unsigned int olen, ++ unsigned char *in, unsigned int ilen); ++ int (*expand)(COMP_CTX *ctx, ++ unsigned char *out, unsigned int olen, ++ unsigned char *in, unsigned int ilen); ++ /* The following two do NOTHING, but are kept for backward compatibility */ ++ long (*ctrl)(void); ++ long (*callback_ctrl)(void); ++ } COMP_METHOD; ++ ++struct comp_ctx_st ++ { ++ COMP_METHOD *meth; ++ unsigned long compress_in; ++ unsigned long compress_out; ++ unsigned long expand_in; ++ unsigned long expand_out; ++ ++ CRYPTO_EX_DATA ex_data; ++ }; ++ ++ ++COMP_CTX *COMP_CTX_new(COMP_METHOD *meth); ++void COMP_CTX_free(COMP_CTX *ctx); ++int COMP_compress_block(COMP_CTX *ctx, unsigned char *out, int olen, ++ unsigned char *in, int ilen); ++int COMP_expand_block(COMP_CTX *ctx, unsigned char *out, int olen, ++ unsigned char *in, int ilen); ++COMP_METHOD *COMP_rle(void ); ++COMP_METHOD *COMP_zlib(void ); ++void COMP_zlib_cleanup(void); ++ ++#ifdef HEADER_BIO_H ++#ifdef ZLIB ++BIO_METHOD *BIO_f_zlib(void); ++#endif ++#endif ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_COMP_strings(void); ++ ++/* Error codes for the COMP functions. */ ++ ++/* Function codes. */ ++#define COMP_F_BIO_ZLIB_FLUSH 99 ++#define COMP_F_BIO_ZLIB_NEW 100 ++#define COMP_F_BIO_ZLIB_READ 101 ++#define COMP_F_BIO_ZLIB_WRITE 102 ++ ++/* Reason codes. */ ++#define COMP_R_ZLIB_DEFLATE_ERROR 99 ++#define COMP_R_ZLIB_INFLATE_ERROR 100 ++#define COMP_R_ZLIB_NOT_SUPPORTED 101 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/conf.h qt.patched/include/openssl/conf.h +--- qt.orig/include/openssl/conf.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/conf.h 2010-08-27 12:01:45.102665100 +0200 +@@ -0,0 +1,263 @@ ++/* crypto/conf/conf.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_CONF_H ++#define HEADER_CONF_H ++ ++#include ++#include ++#include ++#include ++#include ++ ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++typedef struct ++ { ++ char *section; ++ char *name; ++ char *value; ++ } CONF_VALUE; ++ ++DECLARE_STACK_OF(CONF_VALUE) ++DECLARE_LHASH_OF(CONF_VALUE); ++ ++struct conf_st; ++struct conf_method_st; ++typedef struct conf_method_st CONF_METHOD; ++ ++struct conf_method_st ++ { ++ const char *name; ++ CONF *(*create)(CONF_METHOD *meth); ++ int (*init)(CONF *conf); ++ int (*destroy)(CONF *conf); ++ int (*destroy_data)(CONF *conf); ++ int (*load_bio)(CONF *conf, BIO *bp, long *eline); ++ int (*dump)(const CONF *conf, BIO *bp); ++ int (*is_number)(const CONF *conf, char c); ++ int (*to_int)(const CONF *conf, char c); ++ int (*load)(CONF *conf, const char *name, long *eline); ++ }; ++ ++/* Module definitions */ ++ ++typedef struct conf_imodule_st CONF_IMODULE; ++typedef struct conf_module_st CONF_MODULE; ++ ++DECLARE_STACK_OF(CONF_MODULE) ++DECLARE_STACK_OF(CONF_IMODULE) ++ ++/* DSO module function typedefs */ ++typedef int conf_init_func(CONF_IMODULE *md, const CONF *cnf); ++typedef void conf_finish_func(CONF_IMODULE *md); ++ ++#define CONF_MFLAGS_IGNORE_ERRORS 0x1 ++#define CONF_MFLAGS_IGNORE_RETURN_CODES 0x2 ++#define CONF_MFLAGS_SILENT 0x4 ++#define CONF_MFLAGS_NO_DSO 0x8 ++#define CONF_MFLAGS_IGNORE_MISSING_FILE 0x10 ++#define CONF_MFLAGS_DEFAULT_SECTION 0x20 ++ ++int CONF_set_default_method(CONF_METHOD *meth); ++void CONF_set_nconf(CONF *conf,LHASH_OF(CONF_VALUE) *hash); ++LHASH_OF(CONF_VALUE) *CONF_load(LHASH_OF(CONF_VALUE) *conf,const char *file, ++ long *eline); ++#ifndef OPENSSL_NO_FP_API ++LHASH_OF(CONF_VALUE) *CONF_load_fp(LHASH_OF(CONF_VALUE) *conf, FILE *fp, ++ long *eline); ++#endif ++LHASH_OF(CONF_VALUE) *CONF_load_bio(LHASH_OF(CONF_VALUE) *conf, BIO *bp,long *eline); ++STACK_OF(CONF_VALUE) *CONF_get_section(LHASH_OF(CONF_VALUE) *conf, ++ const char *section); ++char *CONF_get_string(LHASH_OF(CONF_VALUE) *conf,const char *group, ++ const char *name); ++long CONF_get_number(LHASH_OF(CONF_VALUE) *conf,const char *group, ++ const char *name); ++void CONF_free(LHASH_OF(CONF_VALUE) *conf); ++int CONF_dump_fp(LHASH_OF(CONF_VALUE) *conf, FILE *out); ++int CONF_dump_bio(LHASH_OF(CONF_VALUE) *conf, BIO *out); ++ ++void OPENSSL_config(const char *config_name); ++void OPENSSL_no_config(void); ++ ++/* New conf code. The semantics are different from the functions above. ++ If that wasn't the case, the above functions would have been replaced */ ++ ++struct conf_st ++ { ++ CONF_METHOD *meth; ++ void *meth_data; ++ LHASH_OF(CONF_VALUE) *data; ++ }; ++ ++CONF *NCONF_new(CONF_METHOD *meth); ++CONF_METHOD *NCONF_default(void); ++CONF_METHOD *NCONF_WIN32(void); ++#if 0 /* Just to give you an idea of what I have in mind */ ++CONF_METHOD *NCONF_XML(void); ++#endif ++void NCONF_free(CONF *conf); ++void NCONF_free_data(CONF *conf); ++ ++int NCONF_load(CONF *conf,const char *file,long *eline); ++#ifndef OPENSSL_NO_FP_API ++int NCONF_load_fp(CONF *conf, FILE *fp,long *eline); ++#endif ++int NCONF_load_bio(CONF *conf, BIO *bp,long *eline); ++STACK_OF(CONF_VALUE) *NCONF_get_section(const CONF *conf,const char *section); ++char *NCONF_get_string(const CONF *conf,const char *group,const char *name); ++int NCONF_get_number_e(const CONF *conf,const char *group,const char *name, ++ long *result); ++int NCONF_dump_fp(const CONF *conf, FILE *out); ++int NCONF_dump_bio(const CONF *conf, BIO *out); ++ ++#if 0 /* The following function has no error checking, ++ and should therefore be avoided */ ++long NCONF_get_number(CONF *conf,char *group,char *name); ++#else ++#define NCONF_get_number(c,g,n,r) NCONF_get_number_e(c,g,n,r) ++#endif ++ ++/* Module functions */ ++ ++int CONF_modules_load(const CONF *cnf, const char *appname, ++ unsigned long flags); ++int CONF_modules_load_file(const char *filename, const char *appname, ++ unsigned long flags); ++void CONF_modules_unload(int all); ++void CONF_modules_finish(void); ++void CONF_modules_free(void); ++int CONF_module_add(const char *name, conf_init_func *ifunc, ++ conf_finish_func *ffunc); ++ ++const char *CONF_imodule_get_name(const CONF_IMODULE *md); ++const char *CONF_imodule_get_value(const CONF_IMODULE *md); ++void *CONF_imodule_get_usr_data(const CONF_IMODULE *md); ++void CONF_imodule_set_usr_data(CONF_IMODULE *md, void *usr_data); ++CONF_MODULE *CONF_imodule_get_module(const CONF_IMODULE *md); ++unsigned long CONF_imodule_get_flags(const CONF_IMODULE *md); ++void CONF_imodule_set_flags(CONF_IMODULE *md, unsigned long flags); ++void *CONF_module_get_usr_data(CONF_MODULE *pmod); ++void CONF_module_set_usr_data(CONF_MODULE *pmod, void *usr_data); ++ ++char *CONF_get1_default_config_file(void); ++ ++int CONF_parse_list(const char *list, int sep, int nospc, ++ int (*list_cb)(const char *elem, int len, void *usr), void *arg); ++ ++void OPENSSL_load_builtin_modules(void); ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_CONF_strings(void); ++ ++/* Error codes for the CONF functions. */ ++ ++/* Function codes. */ ++#define CONF_F_CONF_DUMP_FP 104 ++#define CONF_F_CONF_LOAD 100 ++#define CONF_F_CONF_LOAD_BIO 102 ++#define CONF_F_CONF_LOAD_FP 103 ++#define CONF_F_CONF_MODULES_LOAD 116 ++#define CONF_F_CONF_PARSE_LIST 119 ++#define CONF_F_DEF_LOAD 120 ++#define CONF_F_DEF_LOAD_BIO 121 ++#define CONF_F_MODULE_INIT 115 ++#define CONF_F_MODULE_LOAD_DSO 117 ++#define CONF_F_MODULE_RUN 118 ++#define CONF_F_NCONF_DUMP_BIO 105 ++#define CONF_F_NCONF_DUMP_FP 106 ++#define CONF_F_NCONF_GET_NUMBER 107 ++#define CONF_F_NCONF_GET_NUMBER_E 112 ++#define CONF_F_NCONF_GET_SECTION 108 ++#define CONF_F_NCONF_GET_STRING 109 ++#define CONF_F_NCONF_LOAD 113 ++#define CONF_F_NCONF_LOAD_BIO 110 ++#define CONF_F_NCONF_LOAD_FP 114 ++#define CONF_F_NCONF_NEW 111 ++#define CONF_F_STR_COPY 101 ++ ++/* Reason codes. */ ++#define CONF_R_ERROR_LOADING_DSO 110 ++#define CONF_R_LIST_CANNOT_BE_NULL 115 ++#define CONF_R_MISSING_CLOSE_SQUARE_BRACKET 100 ++#define CONF_R_MISSING_EQUAL_SIGN 101 ++#define CONF_R_MISSING_FINISH_FUNCTION 111 ++#define CONF_R_MISSING_INIT_FUNCTION 112 ++#define CONF_R_MODULE_INITIALIZATION_ERROR 109 ++#define CONF_R_NO_CLOSE_BRACE 102 ++#define CONF_R_NO_CONF 105 ++#define CONF_R_NO_CONF_OR_ENVIRONMENT_VARIABLE 106 ++#define CONF_R_NO_SECTION 107 ++#define CONF_R_NO_SUCH_FILE 114 ++#define CONF_R_NO_VALUE 108 ++#define CONF_R_UNABLE_TO_CREATE_NEW_SECTION 103 ++#define CONF_R_UNKNOWN_MODULE_NAME 113 ++#define CONF_R_VARIABLE_HAS_NO_VALUE 104 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/conf_api.h qt.patched/include/openssl/conf_api.h +--- qt.orig/include/openssl/conf_api.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/conf_api.h 2010-08-27 12:01:45.102665100 +0200 +@@ -0,0 +1,89 @@ ++/* conf_api.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_CONF_API_H ++#define HEADER_CONF_API_H ++ ++#include ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* Up until OpenSSL 0.9.5a, this was new_section */ ++CONF_VALUE *_CONF_new_section(CONF *conf, const char *section); ++/* Up until OpenSSL 0.9.5a, this was get_section */ ++CONF_VALUE *_CONF_get_section(const CONF *conf, const char *section); ++/* Up until OpenSSL 0.9.5a, this was CONF_get_section */ ++STACK_OF(CONF_VALUE) *_CONF_get_section_values(const CONF *conf, ++ const char *section); ++ ++int _CONF_add_string(CONF *conf, CONF_VALUE *section, CONF_VALUE *value); ++char *_CONF_get_string(const CONF *conf, const char *section, ++ const char *name); ++long _CONF_get_number(const CONF *conf, const char *section, const char *name); ++ ++int _CONF_new_data(CONF *conf); ++void _CONF_free_data(CONF *conf); ++ ++#ifdef __cplusplus ++} ++#endif ++#endif ++ +diff -urN qt.orig/include/openssl/crypto.h qt.patched/include/openssl/crypto.h +--- qt.orig/include/openssl/crypto.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/crypto.h 2010-08-27 12:01:45.118289500 +0200 +@@ -0,0 +1,575 @@ ++/* crypto/crypto.h */ ++/* ==================================================================== ++ * Copyright (c) 1998-2006 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * openssl-core@openssl.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.openssl.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++/* ==================================================================== ++ * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. ++ * ECDH support in OpenSSL originally developed by ++ * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project. ++ */ ++ ++#ifndef HEADER_CRYPTO_H ++#define HEADER_CRYPTO_H ++ ++#include ++ ++#include ++ ++#ifndef OPENSSL_NO_FP_API ++#include ++#endif ++ ++#include ++#include ++#include ++#include ++ ++#ifdef CHARSET_EBCDIC ++#include ++#endif ++ ++/* Resolve problems on some operating systems with symbol names that clash ++ one way or another */ ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* Backward compatibility to SSLeay */ ++/* This is more to be used to check the correct DLL is being used ++ * in the MS world. */ ++#define SSLEAY_VERSION_NUMBER OPENSSL_VERSION_NUMBER ++#define SSLEAY_VERSION 0 ++/* #define SSLEAY_OPTIONS 1 no longer supported */ ++#define SSLEAY_CFLAGS 2 ++#define SSLEAY_BUILT_ON 3 ++#define SSLEAY_PLATFORM 4 ++#define SSLEAY_DIR 5 ++ ++/* Already declared in ossl_typ.h */ ++#if 0 ++typedef struct crypto_ex_data_st CRYPTO_EX_DATA; ++/* Called when a new object is created */ ++typedef int CRYPTO_EX_new(void *parent, void *ptr, CRYPTO_EX_DATA *ad, ++ int idx, long argl, void *argp); ++/* Called when an object is free()ed */ ++typedef void CRYPTO_EX_free(void *parent, void *ptr, CRYPTO_EX_DATA *ad, ++ int idx, long argl, void *argp); ++/* Called when we need to dup an object */ ++typedef int CRYPTO_EX_dup(CRYPTO_EX_DATA *to, CRYPTO_EX_DATA *from, void *from_d, ++ int idx, long argl, void *argp); ++#endif ++ ++/* A generic structure to pass assorted data in a expandable way */ ++typedef struct openssl_item_st ++ { ++ int code; ++ void *value; /* Not used for flag attributes */ ++ size_t value_size; /* Max size of value for output, length for input */ ++ size_t *value_length; /* Returned length of value for output */ ++ } OPENSSL_ITEM; ++ ++ ++/* When changing the CRYPTO_LOCK_* list, be sure to maintin the text lock ++ * names in cryptlib.c ++ */ ++ ++#define CRYPTO_LOCK_ERR 1 ++#define CRYPTO_LOCK_EX_DATA 2 ++#define CRYPTO_LOCK_X509 3 ++#define CRYPTO_LOCK_X509_INFO 4 ++#define CRYPTO_LOCK_X509_PKEY 5 ++#define CRYPTO_LOCK_X509_CRL 6 ++#define CRYPTO_LOCK_X509_REQ 7 ++#define CRYPTO_LOCK_DSA 8 ++#define CRYPTO_LOCK_RSA 9 ++#define CRYPTO_LOCK_EVP_PKEY 10 ++#define CRYPTO_LOCK_X509_STORE 11 ++#define CRYPTO_LOCK_SSL_CTX 12 ++#define CRYPTO_LOCK_SSL_CERT 13 ++#define CRYPTO_LOCK_SSL_SESSION 14 ++#define CRYPTO_LOCK_SSL_SESS_CERT 15 ++#define CRYPTO_LOCK_SSL 16 ++#define CRYPTO_LOCK_SSL_METHOD 17 ++#define CRYPTO_LOCK_RAND 18 ++#define CRYPTO_LOCK_RAND2 19 ++#define CRYPTO_LOCK_MALLOC 20 ++#define CRYPTO_LOCK_BIO 21 ++#define CRYPTO_LOCK_GETHOSTBYNAME 22 ++#define CRYPTO_LOCK_GETSERVBYNAME 23 ++#define CRYPTO_LOCK_READDIR 24 ++#define CRYPTO_LOCK_RSA_BLINDING 25 ++#define CRYPTO_LOCK_DH 26 ++#define CRYPTO_LOCK_MALLOC2 27 ++#define CRYPTO_LOCK_DSO 28 ++#define CRYPTO_LOCK_DYNLOCK 29 ++#define CRYPTO_LOCK_ENGINE 30 ++#define CRYPTO_LOCK_UI 31 ++#define CRYPTO_LOCK_ECDSA 32 ++#define CRYPTO_LOCK_EC 33 ++#define CRYPTO_LOCK_ECDH 34 ++#define CRYPTO_LOCK_BN 35 ++#define CRYPTO_LOCK_EC_PRE_COMP 36 ++#define CRYPTO_LOCK_STORE 37 ++#define CRYPTO_LOCK_COMP 38 ++#define CRYPTO_LOCK_FIPS 39 ++#define CRYPTO_LOCK_FIPS2 40 ++#define CRYPTO_NUM_LOCKS 41 ++ ++#define CRYPTO_LOCK 1 ++#define CRYPTO_UNLOCK 2 ++#define CRYPTO_READ 4 ++#define CRYPTO_WRITE 8 ++ ++#ifndef OPENSSL_NO_LOCKING ++#ifndef CRYPTO_w_lock ++#define CRYPTO_w_lock(type) \ ++ CRYPTO_lock(CRYPTO_LOCK|CRYPTO_WRITE,type,__FILE__,__LINE__) ++#define CRYPTO_w_unlock(type) \ ++ CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_WRITE,type,__FILE__,__LINE__) ++#define CRYPTO_r_lock(type) \ ++ CRYPTO_lock(CRYPTO_LOCK|CRYPTO_READ,type,__FILE__,__LINE__) ++#define CRYPTO_r_unlock(type) \ ++ CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_READ,type,__FILE__,__LINE__) ++#define CRYPTO_add(addr,amount,type) \ ++ CRYPTO_add_lock(addr,amount,type,__FILE__,__LINE__) ++#endif ++#else ++#define CRYPTO_w_lock(a) ++#define CRYPTO_w_unlock(a) ++#define CRYPTO_r_lock(a) ++#define CRYPTO_r_unlock(a) ++#define CRYPTO_add(a,b,c) ((*(a))+=(b)) ++#endif ++ ++/* Some applications as well as some parts of OpenSSL need to allocate ++ and deallocate locks in a dynamic fashion. The following typedef ++ makes this possible in a type-safe manner. */ ++/* struct CRYPTO_dynlock_value has to be defined by the application. */ ++typedef struct ++ { ++ int references; ++ struct CRYPTO_dynlock_value *data; ++ } CRYPTO_dynlock; ++ ++ ++/* The following can be used to detect memory leaks in the SSLeay library. ++ * It used, it turns on malloc checking */ ++ ++#define CRYPTO_MEM_CHECK_OFF 0x0 /* an enume */ ++#define CRYPTO_MEM_CHECK_ON 0x1 /* a bit */ ++#define CRYPTO_MEM_CHECK_ENABLE 0x2 /* a bit */ ++#define CRYPTO_MEM_CHECK_DISABLE 0x3 /* an enume */ ++ ++/* The following are bit values to turn on or off options connected to the ++ * malloc checking functionality */ ++ ++/* Adds time to the memory checking information */ ++#define V_CRYPTO_MDEBUG_TIME 0x1 /* a bit */ ++/* Adds thread number to the memory checking information */ ++#define V_CRYPTO_MDEBUG_THREAD 0x2 /* a bit */ ++ ++#define V_CRYPTO_MDEBUG_ALL (V_CRYPTO_MDEBUG_TIME | V_CRYPTO_MDEBUG_THREAD) ++ ++ ++/* predec of the BIO type */ ++typedef struct bio_st BIO_dummy; ++ ++struct crypto_ex_data_st ++ { ++ STACK_OF(void) *sk; ++ int dummy; /* gcc is screwing up this data structure :-( */ ++ }; ++DECLARE_STACK_OF(void) ++ ++/* This stuff is basically class callback functions ++ * The current classes are SSL_CTX, SSL, SSL_SESSION, and a few more */ ++ ++typedef struct crypto_ex_data_func_st ++ { ++ long argl; /* Arbitary long */ ++ void *argp; /* Arbitary void * */ ++ CRYPTO_EX_new *new_func; ++ CRYPTO_EX_free *free_func; ++ CRYPTO_EX_dup *dup_func; ++ } CRYPTO_EX_DATA_FUNCS; ++ ++DECLARE_STACK_OF(CRYPTO_EX_DATA_FUNCS) ++ ++/* Per class, we have a STACK of CRYPTO_EX_DATA_FUNCS for each CRYPTO_EX_DATA ++ * entry. ++ */ ++ ++#define CRYPTO_EX_INDEX_BIO 0 ++#define CRYPTO_EX_INDEX_SSL 1 ++#define CRYPTO_EX_INDEX_SSL_CTX 2 ++#define CRYPTO_EX_INDEX_SSL_SESSION 3 ++#define CRYPTO_EX_INDEX_X509_STORE 4 ++#define CRYPTO_EX_INDEX_X509_STORE_CTX 5 ++#define CRYPTO_EX_INDEX_RSA 6 ++#define CRYPTO_EX_INDEX_DSA 7 ++#define CRYPTO_EX_INDEX_DH 8 ++#define CRYPTO_EX_INDEX_ENGINE 9 ++#define CRYPTO_EX_INDEX_X509 10 ++#define CRYPTO_EX_INDEX_UI 11 ++#define CRYPTO_EX_INDEX_ECDSA 12 ++#define CRYPTO_EX_INDEX_ECDH 13 ++#define CRYPTO_EX_INDEX_COMP 14 ++#define CRYPTO_EX_INDEX_STORE 15 ++ ++/* Dynamically assigned indexes start from this value (don't use directly, use ++ * via CRYPTO_ex_data_new_class). */ ++#define CRYPTO_EX_INDEX_USER 100 ++ ++ ++/* This is the default callbacks, but we can have others as well: ++ * this is needed in Win32 where the application malloc and the ++ * library malloc may not be the same. ++ */ ++#define CRYPTO_malloc_init() CRYPTO_set_mem_functions(\ ++ malloc, realloc, free) ++ ++#if defined CRYPTO_MDEBUG_ALL || defined CRYPTO_MDEBUG_TIME || defined CRYPTO_MDEBUG_THREAD ++# ifndef CRYPTO_MDEBUG /* avoid duplicate #define */ ++# define CRYPTO_MDEBUG ++# endif ++#endif ++ ++/* Set standard debugging functions (not done by default ++ * unless CRYPTO_MDEBUG is defined) */ ++#define CRYPTO_malloc_debug_init() do {\ ++ CRYPTO_set_mem_debug_functions(\ ++ CRYPTO_dbg_malloc,\ ++ CRYPTO_dbg_realloc,\ ++ CRYPTO_dbg_free,\ ++ CRYPTO_dbg_set_options,\ ++ CRYPTO_dbg_get_options);\ ++ } while(0) ++ ++int CRYPTO_mem_ctrl(int mode); ++int CRYPTO_is_mem_check_on(void); ++ ++/* for applications */ ++#define MemCheck_start() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON) ++#define MemCheck_stop() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_OFF) ++ ++/* for library-internal use */ ++#define MemCheck_on() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE) ++#define MemCheck_off() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE) ++#define is_MemCheck_on() CRYPTO_is_mem_check_on() ++ ++#define OPENSSL_malloc(num) CRYPTO_malloc((int)num,__FILE__,__LINE__) ++#define OPENSSL_strdup(str) CRYPTO_strdup((str),__FILE__,__LINE__) ++#define OPENSSL_realloc(addr,num) \ ++ CRYPTO_realloc((char *)addr,(int)num,__FILE__,__LINE__) ++#define OPENSSL_realloc_clean(addr,old_num,num) \ ++ CRYPTO_realloc_clean(addr,old_num,num,__FILE__,__LINE__) ++#define OPENSSL_remalloc(addr,num) \ ++ CRYPTO_remalloc((char **)addr,(int)num,__FILE__,__LINE__) ++#define OPENSSL_freeFunc CRYPTO_free ++#define OPENSSL_free(addr) CRYPTO_free(addr) ++ ++#define OPENSSL_malloc_locked(num) \ ++ CRYPTO_malloc_locked((int)num,__FILE__,__LINE__) ++#define OPENSSL_free_locked(addr) CRYPTO_free_locked(addr) ++ ++ ++const char *SSLeay_version(int type); ++unsigned long SSLeay(void); ++ ++int OPENSSL_issetugid(void); ++ ++/* An opaque type representing an implementation of "ex_data" support */ ++typedef struct st_CRYPTO_EX_DATA_IMPL CRYPTO_EX_DATA_IMPL; ++/* Return an opaque pointer to the current "ex_data" implementation */ ++const CRYPTO_EX_DATA_IMPL *CRYPTO_get_ex_data_implementation(void); ++/* Sets the "ex_data" implementation to be used (if it's not too late) */ ++int CRYPTO_set_ex_data_implementation(const CRYPTO_EX_DATA_IMPL *i); ++/* Get a new "ex_data" class, and return the corresponding "class_index" */ ++int CRYPTO_ex_data_new_class(void); ++/* Within a given class, get/register a new index */ ++int CRYPTO_get_ex_new_index(int class_index, long argl, void *argp, ++ CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func, ++ CRYPTO_EX_free *free_func); ++/* Initialise/duplicate/free CRYPTO_EX_DATA variables corresponding to a given ++ * class (invokes whatever per-class callbacks are applicable) */ ++int CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad); ++int CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA *to, ++ CRYPTO_EX_DATA *from); ++void CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad); ++/* Get/set data in a CRYPTO_EX_DATA variable corresponding to a particular index ++ * (relative to the class type involved) */ ++int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val); ++void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad,int idx); ++/* This function cleans up all "ex_data" state. It mustn't be called under ++ * potential race-conditions. */ ++void CRYPTO_cleanup_all_ex_data(void); ++ ++int CRYPTO_get_new_lockid(char *name); ++ ++int CRYPTO_num_locks(void); /* return CRYPTO_NUM_LOCKS (shared libs!) */ ++void CRYPTO_lock(int mode, int type,const char *file,int line); ++void CRYPTO_set_locking_callback(void (*func)(int mode,int type, ++ const char *file,int line)); ++void (*CRYPTO_get_locking_callback(void))(int mode,int type,const char *file, ++ int line); ++void CRYPTO_set_add_lock_callback(int (*func)(int *num,int mount,int type, ++ const char *file, int line)); ++int (*CRYPTO_get_add_lock_callback(void))(int *num,int mount,int type, ++ const char *file,int line); ++ ++/* Don't use this structure directly. */ ++typedef struct crypto_threadid_st ++ { ++ void *ptr; ++ unsigned long val; ++ } CRYPTO_THREADID; ++/* Only use CRYPTO_THREADID_set_[numeric|pointer]() within callbacks */ ++void CRYPTO_THREADID_set_numeric(CRYPTO_THREADID *id, unsigned long val); ++void CRYPTO_THREADID_set_pointer(CRYPTO_THREADID *id, void *ptr); ++int CRYPTO_THREADID_set_callback(void (*threadid_func)(CRYPTO_THREADID *)); ++void (*CRYPTO_THREADID_get_callback(void))(CRYPTO_THREADID *); ++void CRYPTO_THREADID_current(CRYPTO_THREADID *id); ++int CRYPTO_THREADID_cmp(const CRYPTO_THREADID *a, const CRYPTO_THREADID *b); ++void CRYPTO_THREADID_cpy(CRYPTO_THREADID *dest, const CRYPTO_THREADID *src); ++unsigned long CRYPTO_THREADID_hash(const CRYPTO_THREADID *id); ++#ifndef OPENSSL_NO_DEPRECATED ++void CRYPTO_set_id_callback(unsigned long (*func)(void)); ++unsigned long (*CRYPTO_get_id_callback(void))(void); ++unsigned long CRYPTO_thread_id(void); ++#endif ++ ++const char *CRYPTO_get_lock_name(int type); ++int CRYPTO_add_lock(int *pointer,int amount,int type, const char *file, ++ int line); ++ ++int CRYPTO_get_new_dynlockid(void); ++void CRYPTO_destroy_dynlockid(int i); ++struct CRYPTO_dynlock_value *CRYPTO_get_dynlock_value(int i); ++void CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value *(*dyn_create_function)(const char *file, int line)); ++void CRYPTO_set_dynlock_lock_callback(void (*dyn_lock_function)(int mode, struct CRYPTO_dynlock_value *l, const char *file, int line)); ++void CRYPTO_set_dynlock_destroy_callback(void (*dyn_destroy_function)(struct CRYPTO_dynlock_value *l, const char *file, int line)); ++struct CRYPTO_dynlock_value *(*CRYPTO_get_dynlock_create_callback(void))(const char *file,int line); ++void (*CRYPTO_get_dynlock_lock_callback(void))(int mode, struct CRYPTO_dynlock_value *l, const char *file,int line); ++void (*CRYPTO_get_dynlock_destroy_callback(void))(struct CRYPTO_dynlock_value *l, const char *file,int line); ++ ++/* CRYPTO_set_mem_functions includes CRYPTO_set_locked_mem_functions -- ++ * call the latter last if you need different functions */ ++int CRYPTO_set_mem_functions(void *(*m)(size_t),void *(*r)(void *,size_t), void (*f)(void *)); ++int CRYPTO_set_locked_mem_functions(void *(*m)(size_t), void (*free_func)(void *)); ++int CRYPTO_set_mem_ex_functions(void *(*m)(size_t,const char *,int), ++ void *(*r)(void *,size_t,const char *,int), ++ void (*f)(void *)); ++int CRYPTO_set_locked_mem_ex_functions(void *(*m)(size_t,const char *,int), ++ void (*free_func)(void *)); ++int CRYPTO_set_mem_debug_functions(void (*m)(void *,int,const char *,int,int), ++ void (*r)(void *,void *,int,const char *,int,int), ++ void (*f)(void *,int), ++ void (*so)(long), ++ long (*go)(void)); ++void CRYPTO_get_mem_functions(void *(**m)(size_t),void *(**r)(void *, size_t), void (**f)(void *)); ++void CRYPTO_get_locked_mem_functions(void *(**m)(size_t), void (**f)(void *)); ++void CRYPTO_get_mem_ex_functions(void *(**m)(size_t,const char *,int), ++ void *(**r)(void *, size_t,const char *,int), ++ void (**f)(void *)); ++void CRYPTO_get_locked_mem_ex_functions(void *(**m)(size_t,const char *,int), ++ void (**f)(void *)); ++void CRYPTO_get_mem_debug_functions(void (**m)(void *,int,const char *,int,int), ++ void (**r)(void *,void *,int,const char *,int,int), ++ void (**f)(void *,int), ++ void (**so)(long), ++ long (**go)(void)); ++ ++void *CRYPTO_malloc_locked(int num, const char *file, int line); ++void CRYPTO_free_locked(void *); ++void *CRYPTO_malloc(int num, const char *file, int line); ++char *CRYPTO_strdup(const char *str, const char *file, int line); ++void CRYPTO_free(void *); ++void *CRYPTO_realloc(void *addr,int num, const char *file, int line); ++void *CRYPTO_realloc_clean(void *addr,int old_num,int num,const char *file, ++ int line); ++void *CRYPTO_remalloc(void *addr,int num, const char *file, int line); ++ ++void OPENSSL_cleanse(void *ptr, size_t len); ++ ++void CRYPTO_set_mem_debug_options(long bits); ++long CRYPTO_get_mem_debug_options(void); ++ ++#define CRYPTO_push_info(info) \ ++ CRYPTO_push_info_(info, __FILE__, __LINE__); ++int CRYPTO_push_info_(const char *info, const char *file, int line); ++int CRYPTO_pop_info(void); ++int CRYPTO_remove_all_info(void); ++ ++ ++/* Default debugging functions (enabled by CRYPTO_malloc_debug_init() macro; ++ * used as default in CRYPTO_MDEBUG compilations): */ ++/* The last argument has the following significance: ++ * ++ * 0: called before the actual memory allocation has taken place ++ * 1: called after the actual memory allocation has taken place ++ */ ++void CRYPTO_dbg_malloc(void *addr,int num,const char *file,int line,int before_p); ++void CRYPTO_dbg_realloc(void *addr1,void *addr2,int num,const char *file,int line,int before_p); ++void CRYPTO_dbg_free(void *addr,int before_p); ++/* Tell the debugging code about options. By default, the following values ++ * apply: ++ * ++ * 0: Clear all options. ++ * V_CRYPTO_MDEBUG_TIME (1): Set the "Show Time" option. ++ * V_CRYPTO_MDEBUG_THREAD (2): Set the "Show Thread Number" option. ++ * V_CRYPTO_MDEBUG_ALL (3): 1 + 2 ++ */ ++void CRYPTO_dbg_set_options(long bits); ++long CRYPTO_dbg_get_options(void); ++ ++ ++#ifndef OPENSSL_NO_FP_API ++void CRYPTO_mem_leaks_fp(FILE *); ++#endif ++void CRYPTO_mem_leaks(struct bio_st *bio); ++/* unsigned long order, char *file, int line, int num_bytes, char *addr */ ++typedef void *CRYPTO_MEM_LEAK_CB(unsigned long, const char *, int, int, void *); ++void CRYPTO_mem_leaks_cb(CRYPTO_MEM_LEAK_CB *cb); ++ ++/* die if we have to */ ++void OpenSSLDie(const char *file,int line,const char *assertion); ++#define OPENSSL_assert(e) (void)((e) ? 0 : (OpenSSLDie(__FILE__, __LINE__, #e),1)) ++ ++unsigned long *OPENSSL_ia32cap_loc(void); ++#define OPENSSL_ia32cap (*(OPENSSL_ia32cap_loc())) ++int OPENSSL_isservice(void); ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_CRYPTO_strings(void); ++ ++/* Error codes for the CRYPTO functions. */ ++ ++/* Function codes. */ ++#define CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX 100 ++#define CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID 103 ++#define CRYPTO_F_CRYPTO_GET_NEW_LOCKID 101 ++#define CRYPTO_F_CRYPTO_SET_EX_DATA 102 ++#define CRYPTO_F_DEF_ADD_INDEX 104 ++#define CRYPTO_F_DEF_GET_CLASS 105 ++#define CRYPTO_F_INT_DUP_EX_DATA 106 ++#define CRYPTO_F_INT_FREE_EX_DATA 107 ++#define CRYPTO_F_INT_NEW_EX_DATA 108 ++ ++/* Reason codes. */ ++#define CRYPTO_R_NO_DYNLOCK_CREATE_CALLBACK 100 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/des.h qt.patched/include/openssl/des.h +--- qt.orig/include/openssl/des.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/des.h 2010-08-27 12:01:45.133913900 +0200 +@@ -0,0 +1,245 @@ ++/* crypto/des/des.h */ ++/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_NEW_DES_H ++#define HEADER_NEW_DES_H ++ ++#include /* OPENSSL_EXTERN, OPENSSL_NO_DES, ++ DES_LONG (via openssl/opensslconf.h */ ++ ++#ifdef OPENSSL_NO_DES ++#error DES is disabled. ++#endif ++ ++#ifdef OPENSSL_BUILD_SHLIBCRYPTO ++# undef OPENSSL_EXTERN ++# define OPENSSL_EXTERN OPENSSL_EXPORT ++#endif ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++typedef unsigned char DES_cblock[8]; ++typedef /* const */ unsigned char const_DES_cblock[8]; ++/* With "const", gcc 2.8.1 on Solaris thinks that DES_cblock * ++ * and const_DES_cblock * are incompatible pointer types. */ ++ ++typedef struct DES_ks ++ { ++ union ++ { ++ DES_cblock cblock; ++ /* make sure things are correct size on machines with ++ * 8 byte longs */ ++ DES_LONG deslong[2]; ++ } ks[16]; ++ } DES_key_schedule; ++ ++#ifndef OPENSSL_DISABLE_OLD_DES_SUPPORT ++# ifndef OPENSSL_ENABLE_OLD_DES_SUPPORT ++# define OPENSSL_ENABLE_OLD_DES_SUPPORT ++# endif ++#endif ++ ++#ifdef OPENSSL_ENABLE_OLD_DES_SUPPORT ++# include ++#endif ++ ++#define DES_KEY_SZ (sizeof(DES_cblock)) ++#define DES_SCHEDULE_SZ (sizeof(DES_key_schedule)) ++ ++#define DES_ENCRYPT 1 ++#define DES_DECRYPT 0 ++ ++#define DES_CBC_MODE 0 ++#define DES_PCBC_MODE 1 ++ ++#define DES_ecb2_encrypt(i,o,k1,k2,e) \ ++ DES_ecb3_encrypt((i),(o),(k1),(k2),(k1),(e)) ++ ++#define DES_ede2_cbc_encrypt(i,o,l,k1,k2,iv,e) \ ++ DES_ede3_cbc_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(e)) ++ ++#define DES_ede2_cfb64_encrypt(i,o,l,k1,k2,iv,n,e) \ ++ DES_ede3_cfb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n),(e)) ++ ++#define DES_ede2_ofb64_encrypt(i,o,l,k1,k2,iv,n) \ ++ DES_ede3_ofb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n)) ++ ++OPENSSL_DECLARE_GLOBAL(int,DES_check_key); /* defaults to false */ ++#define DES_check_key OPENSSL_GLOBAL_REF(DES_check_key) ++OPENSSL_DECLARE_GLOBAL(int,DES_rw_mode); /* defaults to DES_PCBC_MODE */ ++#define DES_rw_mode OPENSSL_GLOBAL_REF(DES_rw_mode) ++ ++const char *DES_options(void); ++void DES_ecb3_encrypt(const_DES_cblock *input, DES_cblock *output, ++ DES_key_schedule *ks1,DES_key_schedule *ks2, ++ DES_key_schedule *ks3, int enc); ++DES_LONG DES_cbc_cksum(const unsigned char *input,DES_cblock *output, ++ long length,DES_key_schedule *schedule, ++ const_DES_cblock *ivec); ++/* DES_cbc_encrypt does not update the IV! Use DES_ncbc_encrypt instead. */ ++void DES_cbc_encrypt(const unsigned char *input,unsigned char *output, ++ long length,DES_key_schedule *schedule,DES_cblock *ivec, ++ int enc); ++void DES_ncbc_encrypt(const unsigned char *input,unsigned char *output, ++ long length,DES_key_schedule *schedule,DES_cblock *ivec, ++ int enc); ++void DES_xcbc_encrypt(const unsigned char *input,unsigned char *output, ++ long length,DES_key_schedule *schedule,DES_cblock *ivec, ++ const_DES_cblock *inw,const_DES_cblock *outw,int enc); ++void DES_cfb_encrypt(const unsigned char *in,unsigned char *out,int numbits, ++ long length,DES_key_schedule *schedule,DES_cblock *ivec, ++ int enc); ++void DES_ecb_encrypt(const_DES_cblock *input,DES_cblock *output, ++ DES_key_schedule *ks,int enc); ++ ++/* This is the DES encryption function that gets called by just about ++ every other DES routine in the library. You should not use this ++ function except to implement 'modes' of DES. I say this because the ++ functions that call this routine do the conversion from 'char *' to ++ long, and this needs to be done to make sure 'non-aligned' memory ++ access do not occur. The characters are loaded 'little endian'. ++ Data is a pointer to 2 unsigned long's and ks is the ++ DES_key_schedule to use. enc, is non zero specifies encryption, ++ zero if decryption. */ ++void DES_encrypt1(DES_LONG *data,DES_key_schedule *ks, int enc); ++ ++/* This functions is the same as DES_encrypt1() except that the DES ++ initial permutation (IP) and final permutation (FP) have been left ++ out. As for DES_encrypt1(), you should not use this function. ++ It is used by the routines in the library that implement triple DES. ++ IP() DES_encrypt2() DES_encrypt2() DES_encrypt2() FP() is the same ++ as DES_encrypt1() DES_encrypt1() DES_encrypt1() except faster :-). */ ++void DES_encrypt2(DES_LONG *data,DES_key_schedule *ks, int enc); ++ ++void DES_encrypt3(DES_LONG *data, DES_key_schedule *ks1, ++ DES_key_schedule *ks2, DES_key_schedule *ks3); ++void DES_decrypt3(DES_LONG *data, DES_key_schedule *ks1, ++ DES_key_schedule *ks2, DES_key_schedule *ks3); ++void DES_ede3_cbc_encrypt(const unsigned char *input,unsigned char *output, ++ long length, ++ DES_key_schedule *ks1,DES_key_schedule *ks2, ++ DES_key_schedule *ks3,DES_cblock *ivec,int enc); ++void DES_ede3_cbcm_encrypt(const unsigned char *in,unsigned char *out, ++ long length, ++ DES_key_schedule *ks1,DES_key_schedule *ks2, ++ DES_key_schedule *ks3, ++ DES_cblock *ivec1,DES_cblock *ivec2, ++ int enc); ++void DES_ede3_cfb64_encrypt(const unsigned char *in,unsigned char *out, ++ long length,DES_key_schedule *ks1, ++ DES_key_schedule *ks2,DES_key_schedule *ks3, ++ DES_cblock *ivec,int *num,int enc); ++void DES_ede3_cfb_encrypt(const unsigned char *in,unsigned char *out, ++ int numbits,long length,DES_key_schedule *ks1, ++ DES_key_schedule *ks2,DES_key_schedule *ks3, ++ DES_cblock *ivec,int enc); ++void DES_ede3_ofb64_encrypt(const unsigned char *in,unsigned char *out, ++ long length,DES_key_schedule *ks1, ++ DES_key_schedule *ks2,DES_key_schedule *ks3, ++ DES_cblock *ivec,int *num); ++#if 0 ++void DES_xwhite_in2out(const_DES_cblock *DES_key,const_DES_cblock *in_white, ++ DES_cblock *out_white); ++#endif ++ ++int DES_enc_read(int fd,void *buf,int len,DES_key_schedule *sched, ++ DES_cblock *iv); ++int DES_enc_write(int fd,const void *buf,int len,DES_key_schedule *sched, ++ DES_cblock *iv); ++char *DES_fcrypt(const char *buf,const char *salt, char *ret); ++char *DES_crypt(const char *buf,const char *salt); ++void DES_ofb_encrypt(const unsigned char *in,unsigned char *out,int numbits, ++ long length,DES_key_schedule *schedule,DES_cblock *ivec); ++void DES_pcbc_encrypt(const unsigned char *input,unsigned char *output, ++ long length,DES_key_schedule *schedule,DES_cblock *ivec, ++ int enc); ++DES_LONG DES_quad_cksum(const unsigned char *input,DES_cblock output[], ++ long length,int out_count,DES_cblock *seed); ++int DES_random_key(DES_cblock *ret); ++void DES_set_odd_parity(DES_cblock *key); ++int DES_check_key_parity(const_DES_cblock *key); ++int DES_is_weak_key(const_DES_cblock *key); ++/* DES_set_key (= set_key = DES_key_sched = key_sched) calls ++ * DES_set_key_checked if global variable DES_check_key is set, ++ * DES_set_key_unchecked otherwise. */ ++int DES_set_key(const_DES_cblock *key,DES_key_schedule *schedule); ++int DES_key_sched(const_DES_cblock *key,DES_key_schedule *schedule); ++int DES_set_key_checked(const_DES_cblock *key,DES_key_schedule *schedule); ++void DES_set_key_unchecked(const_DES_cblock *key,DES_key_schedule *schedule); ++void DES_string_to_key(const char *str,DES_cblock *key); ++void DES_string_to_2keys(const char *str,DES_cblock *key1,DES_cblock *key2); ++void DES_cfb64_encrypt(const unsigned char *in,unsigned char *out,long length, ++ DES_key_schedule *schedule,DES_cblock *ivec,int *num, ++ int enc); ++void DES_ofb64_encrypt(const unsigned char *in,unsigned char *out,long length, ++ DES_key_schedule *schedule,DES_cblock *ivec,int *num); ++ ++int DES_read_password(DES_cblock *key, const char *prompt, int verify); ++int DES_read_2passwords(DES_cblock *key1, DES_cblock *key2, const char *prompt, ++ int verify); ++ ++#define DES_fixup_key_parity DES_set_odd_parity ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff -urN qt.orig/include/openssl/des_old.h qt.patched/include/openssl/des_old.h +--- qt.orig/include/openssl/des_old.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/des_old.h 2010-08-27 12:01:45.149538300 +0200 +@@ -0,0 +1,446 @@ ++/* crypto/des/des_old.h -*- mode:C; c-file-style: "eay" -*- */ ++ ++/* WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING ++ * ++ * The function names in here are deprecated and are only present to ++ * provide an interface compatible with openssl 0.9.6 and older as ++ * well as libdes. OpenSSL now provides functions where "des_" has ++ * been replaced with "DES_" in the names, to make it possible to ++ * make incompatible changes that are needed for C type security and ++ * other stuff. ++ * ++ * This include files has two compatibility modes: ++ * ++ * - If OPENSSL_DES_LIBDES_COMPATIBILITY is defined, you get an API ++ * that is compatible with libdes and SSLeay. ++ * - If OPENSSL_DES_LIBDES_COMPATIBILITY isn't defined, you get an ++ * API that is compatible with OpenSSL 0.9.5x to 0.9.6x. ++ * ++ * Note that these modes break earlier snapshots of OpenSSL, where ++ * libdes compatibility was the only available mode or (later on) the ++ * prefered compatibility mode. However, after much consideration ++ * (and more or less violent discussions with external parties), it ++ * was concluded that OpenSSL should be compatible with earlier versions ++ * of itself before anything else. Also, in all honesty, libdes is ++ * an old beast that shouldn't really be used any more. ++ * ++ * Please consider starting to use the DES_ functions rather than the ++ * des_ ones. The des_ functions will disappear completely before ++ * OpenSSL 1.0! ++ * ++ * WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING ++ */ ++ ++/* Written by Richard Levitte (richard@levitte.org) for the OpenSSL ++ * project 2001. ++ */ ++/* ==================================================================== ++ * Copyright (c) 1998-2002 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * openssl-core@openssl.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.openssl.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++ ++#ifndef HEADER_DES_H ++#define HEADER_DES_H ++ ++#include /* OPENSSL_EXTERN, OPENSSL_NO_DES, DES_LONG */ ++ ++#ifdef OPENSSL_NO_DES ++#error DES is disabled. ++#endif ++ ++#ifndef HEADER_NEW_DES_H ++#error You must include des.h, not des_old.h directly. ++#endif ++ ++#ifdef _KERBEROS_DES_H ++#error replaces . ++#endif ++ ++#include ++ ++#ifdef OPENSSL_BUILD_SHLIBCRYPTO ++# undef OPENSSL_EXTERN ++# define OPENSSL_EXTERN OPENSSL_EXPORT ++#endif ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#ifdef _ ++#undef _ ++#endif ++ ++typedef unsigned char _ossl_old_des_cblock[8]; ++typedef struct _ossl_old_des_ks_struct ++ { ++ union { ++ _ossl_old_des_cblock _; ++ /* make sure things are correct size on machines with ++ * 8 byte longs */ ++ DES_LONG pad[2]; ++ } ks; ++ } _ossl_old_des_key_schedule[16]; ++ ++#ifndef OPENSSL_DES_LIBDES_COMPATIBILITY ++#define des_cblock DES_cblock ++#define const_des_cblock const_DES_cblock ++#define des_key_schedule DES_key_schedule ++#define des_ecb3_encrypt(i,o,k1,k2,k3,e)\ ++ DES_ecb3_encrypt((i),(o),&(k1),&(k2),&(k3),(e)) ++#define des_ede3_cbc_encrypt(i,o,l,k1,k2,k3,iv,e)\ ++ DES_ede3_cbc_encrypt((i),(o),(l),&(k1),&(k2),&(k3),(iv),(e)) ++#define des_ede3_cbcm_encrypt(i,o,l,k1,k2,k3,iv1,iv2,e)\ ++ DES_ede3_cbcm_encrypt((i),(o),(l),&(k1),&(k2),&(k3),(iv1),(iv2),(e)) ++#define des_ede3_cfb64_encrypt(i,o,l,k1,k2,k3,iv,n,e)\ ++ DES_ede3_cfb64_encrypt((i),(o),(l),&(k1),&(k2),&(k3),(iv),(n),(e)) ++#define des_ede3_ofb64_encrypt(i,o,l,k1,k2,k3,iv,n)\ ++ DES_ede3_ofb64_encrypt((i),(o),(l),&(k1),&(k2),&(k3),(iv),(n)) ++#define des_options()\ ++ DES_options() ++#define des_cbc_cksum(i,o,l,k,iv)\ ++ DES_cbc_cksum((i),(o),(l),&(k),(iv)) ++#define des_cbc_encrypt(i,o,l,k,iv,e)\ ++ DES_cbc_encrypt((i),(o),(l),&(k),(iv),(e)) ++#define des_ncbc_encrypt(i,o,l,k,iv,e)\ ++ DES_ncbc_encrypt((i),(o),(l),&(k),(iv),(e)) ++#define des_xcbc_encrypt(i,o,l,k,iv,inw,outw,e)\ ++ DES_xcbc_encrypt((i),(o),(l),&(k),(iv),(inw),(outw),(e)) ++#define des_cfb_encrypt(i,o,n,l,k,iv,e)\ ++ DES_cfb_encrypt((i),(o),(n),(l),&(k),(iv),(e)) ++#define des_ecb_encrypt(i,o,k,e)\ ++ DES_ecb_encrypt((i),(o),&(k),(e)) ++#define des_encrypt1(d,k,e)\ ++ DES_encrypt1((d),&(k),(e)) ++#define des_encrypt2(d,k,e)\ ++ DES_encrypt2((d),&(k),(e)) ++#define des_encrypt3(d,k1,k2,k3)\ ++ DES_encrypt3((d),&(k1),&(k2),&(k3)) ++#define des_decrypt3(d,k1,k2,k3)\ ++ DES_decrypt3((d),&(k1),&(k2),&(k3)) ++#define des_xwhite_in2out(k,i,o)\ ++ DES_xwhite_in2out((k),(i),(o)) ++#define des_enc_read(f,b,l,k,iv)\ ++ DES_enc_read((f),(b),(l),&(k),(iv)) ++#define des_enc_write(f,b,l,k,iv)\ ++ DES_enc_write((f),(b),(l),&(k),(iv)) ++#define des_fcrypt(b,s,r)\ ++ DES_fcrypt((b),(s),(r)) ++#if 0 ++#define des_crypt(b,s)\ ++ DES_crypt((b),(s)) ++#if !defined(PERL5) && !defined(__FreeBSD__) && !defined(NeXT) && !defined(__OpenBSD__) ++#define crypt(b,s)\ ++ DES_crypt((b),(s)) ++#endif ++#endif ++#define des_ofb_encrypt(i,o,n,l,k,iv)\ ++ DES_ofb_encrypt((i),(o),(n),(l),&(k),(iv)) ++#define des_pcbc_encrypt(i,o,l,k,iv,e)\ ++ DES_pcbc_encrypt((i),(o),(l),&(k),(iv),(e)) ++#define des_quad_cksum(i,o,l,c,s)\ ++ DES_quad_cksum((i),(o),(l),(c),(s)) ++#define des_random_seed(k)\ ++ _ossl_096_des_random_seed((k)) ++#define des_random_key(r)\ ++ DES_random_key((r)) ++#define des_read_password(k,p,v) \ ++ DES_read_password((k),(p),(v)) ++#define des_read_2passwords(k1,k2,p,v) \ ++ DES_read_2passwords((k1),(k2),(p),(v)) ++#define des_set_odd_parity(k)\ ++ DES_set_odd_parity((k)) ++#define des_check_key_parity(k)\ ++ DES_check_key_parity((k)) ++#define des_is_weak_key(k)\ ++ DES_is_weak_key((k)) ++#define des_set_key(k,ks)\ ++ DES_set_key((k),&(ks)) ++#define des_key_sched(k,ks)\ ++ DES_key_sched((k),&(ks)) ++#define des_set_key_checked(k,ks)\ ++ DES_set_key_checked((k),&(ks)) ++#define des_set_key_unchecked(k,ks)\ ++ DES_set_key_unchecked((k),&(ks)) ++#define des_string_to_key(s,k)\ ++ DES_string_to_key((s),(k)) ++#define des_string_to_2keys(s,k1,k2)\ ++ DES_string_to_2keys((s),(k1),(k2)) ++#define des_cfb64_encrypt(i,o,l,ks,iv,n,e)\ ++ DES_cfb64_encrypt((i),(o),(l),&(ks),(iv),(n),(e)) ++#define des_ofb64_encrypt(i,o,l,ks,iv,n)\ ++ DES_ofb64_encrypt((i),(o),(l),&(ks),(iv),(n)) ++ ++ ++#define des_ecb2_encrypt(i,o,k1,k2,e) \ ++ des_ecb3_encrypt((i),(o),(k1),(k2),(k1),(e)) ++ ++#define des_ede2_cbc_encrypt(i,o,l,k1,k2,iv,e) \ ++ des_ede3_cbc_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(e)) ++ ++#define des_ede2_cfb64_encrypt(i,o,l,k1,k2,iv,n,e) \ ++ des_ede3_cfb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n),(e)) ++ ++#define des_ede2_ofb64_encrypt(i,o,l,k1,k2,iv,n) \ ++ des_ede3_ofb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n)) ++ ++#define des_check_key DES_check_key ++#define des_rw_mode DES_rw_mode ++#else /* libdes compatibility */ ++/* Map all symbol names to _ossl_old_des_* form, so we avoid all ++ clashes with libdes */ ++#define des_cblock _ossl_old_des_cblock ++#define des_key_schedule _ossl_old_des_key_schedule ++#define des_ecb3_encrypt(i,o,k1,k2,k3,e)\ ++ _ossl_old_des_ecb3_encrypt((i),(o),(k1),(k2),(k3),(e)) ++#define des_ede3_cbc_encrypt(i,o,l,k1,k2,k3,iv,e)\ ++ _ossl_old_des_ede3_cbc_encrypt((i),(o),(l),(k1),(k2),(k3),(iv),(e)) ++#define des_ede3_cfb64_encrypt(i,o,l,k1,k2,k3,iv,n,e)\ ++ _ossl_old_des_ede3_cfb64_encrypt((i),(o),(l),(k1),(k2),(k3),(iv),(n),(e)) ++#define des_ede3_ofb64_encrypt(i,o,l,k1,k2,k3,iv,n)\ ++ _ossl_old_des_ede3_ofb64_encrypt((i),(o),(l),(k1),(k2),(k3),(iv),(n)) ++#define des_options()\ ++ _ossl_old_des_options() ++#define des_cbc_cksum(i,o,l,k,iv)\ ++ _ossl_old_des_cbc_cksum((i),(o),(l),(k),(iv)) ++#define des_cbc_encrypt(i,o,l,k,iv,e)\ ++ _ossl_old_des_cbc_encrypt((i),(o),(l),(k),(iv),(e)) ++#define des_ncbc_encrypt(i,o,l,k,iv,e)\ ++ _ossl_old_des_ncbc_encrypt((i),(o),(l),(k),(iv),(e)) ++#define des_xcbc_encrypt(i,o,l,k,iv,inw,outw,e)\ ++ _ossl_old_des_xcbc_encrypt((i),(o),(l),(k),(iv),(inw),(outw),(e)) ++#define des_cfb_encrypt(i,o,n,l,k,iv,e)\ ++ _ossl_old_des_cfb_encrypt((i),(o),(n),(l),(k),(iv),(e)) ++#define des_ecb_encrypt(i,o,k,e)\ ++ _ossl_old_des_ecb_encrypt((i),(o),(k),(e)) ++#define des_encrypt(d,k,e)\ ++ _ossl_old_des_encrypt((d),(k),(e)) ++#define des_encrypt2(d,k,e)\ ++ _ossl_old_des_encrypt2((d),(k),(e)) ++#define des_encrypt3(d,k1,k2,k3)\ ++ _ossl_old_des_encrypt3((d),(k1),(k2),(k3)) ++#define des_decrypt3(d,k1,k2,k3)\ ++ _ossl_old_des_decrypt3((d),(k1),(k2),(k3)) ++#define des_xwhite_in2out(k,i,o)\ ++ _ossl_old_des_xwhite_in2out((k),(i),(o)) ++#define des_enc_read(f,b,l,k,iv)\ ++ _ossl_old_des_enc_read((f),(b),(l),(k),(iv)) ++#define des_enc_write(f,b,l,k,iv)\ ++ _ossl_old_des_enc_write((f),(b),(l),(k),(iv)) ++#define des_fcrypt(b,s,r)\ ++ _ossl_old_des_fcrypt((b),(s),(r)) ++#define des_crypt(b,s)\ ++ _ossl_old_des_crypt((b),(s)) ++#if 0 ++#define crypt(b,s)\ ++ _ossl_old_crypt((b),(s)) ++#endif ++#define des_ofb_encrypt(i,o,n,l,k,iv)\ ++ _ossl_old_des_ofb_encrypt((i),(o),(n),(l),(k),(iv)) ++#define des_pcbc_encrypt(i,o,l,k,iv,e)\ ++ _ossl_old_des_pcbc_encrypt((i),(o),(l),(k),(iv),(e)) ++#define des_quad_cksum(i,o,l,c,s)\ ++ _ossl_old_des_quad_cksum((i),(o),(l),(c),(s)) ++#define des_random_seed(k)\ ++ _ossl_old_des_random_seed((k)) ++#define des_random_key(r)\ ++ _ossl_old_des_random_key((r)) ++#define des_read_password(k,p,v) \ ++ _ossl_old_des_read_password((k),(p),(v)) ++#define des_read_2passwords(k1,k2,p,v) \ ++ _ossl_old_des_read_2passwords((k1),(k2),(p),(v)) ++#define des_set_odd_parity(k)\ ++ _ossl_old_des_set_odd_parity((k)) ++#define des_is_weak_key(k)\ ++ _ossl_old_des_is_weak_key((k)) ++#define des_set_key(k,ks)\ ++ _ossl_old_des_set_key((k),(ks)) ++#define des_key_sched(k,ks)\ ++ _ossl_old_des_key_sched((k),(ks)) ++#define des_string_to_key(s,k)\ ++ _ossl_old_des_string_to_key((s),(k)) ++#define des_string_to_2keys(s,k1,k2)\ ++ _ossl_old_des_string_to_2keys((s),(k1),(k2)) ++#define des_cfb64_encrypt(i,o,l,ks,iv,n,e)\ ++ _ossl_old_des_cfb64_encrypt((i),(o),(l),(ks),(iv),(n),(e)) ++#define des_ofb64_encrypt(i,o,l,ks,iv,n)\ ++ _ossl_old_des_ofb64_encrypt((i),(o),(l),(ks),(iv),(n)) ++ ++ ++#define des_ecb2_encrypt(i,o,k1,k2,e) \ ++ des_ecb3_encrypt((i),(o),(k1),(k2),(k1),(e)) ++ ++#define des_ede2_cbc_encrypt(i,o,l,k1,k2,iv,e) \ ++ des_ede3_cbc_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(e)) ++ ++#define des_ede2_cfb64_encrypt(i,o,l,k1,k2,iv,n,e) \ ++ des_ede3_cfb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n),(e)) ++ ++#define des_ede2_ofb64_encrypt(i,o,l,k1,k2,iv,n) \ ++ des_ede3_ofb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n)) ++ ++#define des_check_key DES_check_key ++#define des_rw_mode DES_rw_mode ++#endif ++ ++const char *_ossl_old_des_options(void); ++void _ossl_old_des_ecb3_encrypt(_ossl_old_des_cblock *input,_ossl_old_des_cblock *output, ++ _ossl_old_des_key_schedule ks1,_ossl_old_des_key_schedule ks2, ++ _ossl_old_des_key_schedule ks3, int enc); ++DES_LONG _ossl_old_des_cbc_cksum(_ossl_old_des_cblock *input,_ossl_old_des_cblock *output, ++ long length,_ossl_old_des_key_schedule schedule,_ossl_old_des_cblock *ivec); ++void _ossl_old_des_cbc_encrypt(_ossl_old_des_cblock *input,_ossl_old_des_cblock *output,long length, ++ _ossl_old_des_key_schedule schedule,_ossl_old_des_cblock *ivec,int enc); ++void _ossl_old_des_ncbc_encrypt(_ossl_old_des_cblock *input,_ossl_old_des_cblock *output,long length, ++ _ossl_old_des_key_schedule schedule,_ossl_old_des_cblock *ivec,int enc); ++void _ossl_old_des_xcbc_encrypt(_ossl_old_des_cblock *input,_ossl_old_des_cblock *output,long length, ++ _ossl_old_des_key_schedule schedule,_ossl_old_des_cblock *ivec, ++ _ossl_old_des_cblock *inw,_ossl_old_des_cblock *outw,int enc); ++void _ossl_old_des_cfb_encrypt(unsigned char *in,unsigned char *out,int numbits, ++ long length,_ossl_old_des_key_schedule schedule,_ossl_old_des_cblock *ivec,int enc); ++void _ossl_old_des_ecb_encrypt(_ossl_old_des_cblock *input,_ossl_old_des_cblock *output, ++ _ossl_old_des_key_schedule ks,int enc); ++void _ossl_old_des_encrypt(DES_LONG *data,_ossl_old_des_key_schedule ks, int enc); ++void _ossl_old_des_encrypt2(DES_LONG *data,_ossl_old_des_key_schedule ks, int enc); ++void _ossl_old_des_encrypt3(DES_LONG *data, _ossl_old_des_key_schedule ks1, ++ _ossl_old_des_key_schedule ks2, _ossl_old_des_key_schedule ks3); ++void _ossl_old_des_decrypt3(DES_LONG *data, _ossl_old_des_key_schedule ks1, ++ _ossl_old_des_key_schedule ks2, _ossl_old_des_key_schedule ks3); ++void _ossl_old_des_ede3_cbc_encrypt(_ossl_old_des_cblock *input, _ossl_old_des_cblock *output, ++ long length, _ossl_old_des_key_schedule ks1, _ossl_old_des_key_schedule ks2, ++ _ossl_old_des_key_schedule ks3, _ossl_old_des_cblock *ivec, int enc); ++void _ossl_old_des_ede3_cfb64_encrypt(unsigned char *in, unsigned char *out, ++ long length, _ossl_old_des_key_schedule ks1, _ossl_old_des_key_schedule ks2, ++ _ossl_old_des_key_schedule ks3, _ossl_old_des_cblock *ivec, int *num, int enc); ++void _ossl_old_des_ede3_ofb64_encrypt(unsigned char *in, unsigned char *out, ++ long length, _ossl_old_des_key_schedule ks1, _ossl_old_des_key_schedule ks2, ++ _ossl_old_des_key_schedule ks3, _ossl_old_des_cblock *ivec, int *num); ++#if 0 ++void _ossl_old_des_xwhite_in2out(_ossl_old_des_cblock (*des_key), _ossl_old_des_cblock (*in_white), ++ _ossl_old_des_cblock (*out_white)); ++#endif ++ ++int _ossl_old_des_enc_read(int fd,char *buf,int len,_ossl_old_des_key_schedule sched, ++ _ossl_old_des_cblock *iv); ++int _ossl_old_des_enc_write(int fd,char *buf,int len,_ossl_old_des_key_schedule sched, ++ _ossl_old_des_cblock *iv); ++char *_ossl_old_des_fcrypt(const char *buf,const char *salt, char *ret); ++char *_ossl_old_des_crypt(const char *buf,const char *salt); ++#if !defined(PERL5) && !defined(NeXT) ++char *_ossl_old_crypt(const char *buf,const char *salt); ++#endif ++void _ossl_old_des_ofb_encrypt(unsigned char *in,unsigned char *out, ++ int numbits,long length,_ossl_old_des_key_schedule schedule,_ossl_old_des_cblock *ivec); ++void _ossl_old_des_pcbc_encrypt(_ossl_old_des_cblock *input,_ossl_old_des_cblock *output,long length, ++ _ossl_old_des_key_schedule schedule,_ossl_old_des_cblock *ivec,int enc); ++DES_LONG _ossl_old_des_quad_cksum(_ossl_old_des_cblock *input,_ossl_old_des_cblock *output, ++ long length,int out_count,_ossl_old_des_cblock *seed); ++void _ossl_old_des_random_seed(_ossl_old_des_cblock key); ++void _ossl_old_des_random_key(_ossl_old_des_cblock ret); ++int _ossl_old_des_read_password(_ossl_old_des_cblock *key,const char *prompt,int verify); ++int _ossl_old_des_read_2passwords(_ossl_old_des_cblock *key1,_ossl_old_des_cblock *key2, ++ const char *prompt,int verify); ++void _ossl_old_des_set_odd_parity(_ossl_old_des_cblock *key); ++int _ossl_old_des_is_weak_key(_ossl_old_des_cblock *key); ++int _ossl_old_des_set_key(_ossl_old_des_cblock *key,_ossl_old_des_key_schedule schedule); ++int _ossl_old_des_key_sched(_ossl_old_des_cblock *key,_ossl_old_des_key_schedule schedule); ++void _ossl_old_des_string_to_key(char *str,_ossl_old_des_cblock *key); ++void _ossl_old_des_string_to_2keys(char *str,_ossl_old_des_cblock *key1,_ossl_old_des_cblock *key2); ++void _ossl_old_des_cfb64_encrypt(unsigned char *in, unsigned char *out, long length, ++ _ossl_old_des_key_schedule schedule, _ossl_old_des_cblock *ivec, int *num, int enc); ++void _ossl_old_des_ofb64_encrypt(unsigned char *in, unsigned char *out, long length, ++ _ossl_old_des_key_schedule schedule, _ossl_old_des_cblock *ivec, int *num); ++ ++void _ossl_096_des_random_seed(des_cblock *key); ++ ++/* The following definitions provide compatibility with the MIT Kerberos ++ * library. The _ossl_old_des_key_schedule structure is not binary compatible. */ ++ ++#define _KERBEROS_DES_H ++ ++#define KRBDES_ENCRYPT DES_ENCRYPT ++#define KRBDES_DECRYPT DES_DECRYPT ++ ++#ifdef KERBEROS ++# define ENCRYPT DES_ENCRYPT ++# define DECRYPT DES_DECRYPT ++#endif ++ ++#ifndef NCOMPAT ++# define C_Block des_cblock ++# define Key_schedule des_key_schedule ++# define KEY_SZ DES_KEY_SZ ++# define string_to_key des_string_to_key ++# define read_pw_string des_read_pw_string ++# define random_key des_random_key ++# define pcbc_encrypt des_pcbc_encrypt ++# define set_key des_set_key ++# define key_sched des_key_sched ++# define ecb_encrypt des_ecb_encrypt ++# define cbc_encrypt des_cbc_encrypt ++# define ncbc_encrypt des_ncbc_encrypt ++# define xcbc_encrypt des_xcbc_encrypt ++# define cbc_cksum des_cbc_cksum ++# define quad_cksum des_quad_cksum ++# define check_parity des_check_key_parity ++#endif ++ ++#define des_fixup_key_parity DES_fixup_key_parity ++ ++#ifdef __cplusplus ++} ++#endif ++ ++/* for DES_read_pw_string et al */ ++#include ++ ++#endif +diff -urN qt.orig/include/openssl/dh.h qt.patched/include/openssl/dh.h +--- qt.orig/include/openssl/dh.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/dh.h 2010-08-27 12:01:45.149538300 +0200 +@@ -0,0 +1,260 @@ ++/* crypto/dh/dh.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_DH_H ++#define HEADER_DH_H ++ ++#include ++ ++#ifdef OPENSSL_NO_DH ++#error DH is disabled. ++#endif ++ ++#ifndef OPENSSL_NO_BIO ++#include ++#endif ++#include ++#ifndef OPENSSL_NO_DEPRECATED ++#include ++#endif ++ ++#ifndef OPENSSL_DH_MAX_MODULUS_BITS ++# define OPENSSL_DH_MAX_MODULUS_BITS 10000 ++#endif ++ ++#define DH_FLAG_CACHE_MONT_P 0x01 ++#define DH_FLAG_NO_EXP_CONSTTIME 0x02 /* new with 0.9.7h; the built-in DH ++ * implementation now uses constant time ++ * modular exponentiation for secret exponents ++ * by default. This flag causes the ++ * faster variable sliding window method to ++ * be used for all exponents. ++ */ ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* Already defined in ossl_typ.h */ ++/* typedef struct dh_st DH; */ ++/* typedef struct dh_method DH_METHOD; */ ++ ++struct dh_method ++ { ++ const char *name; ++ /* Methods here */ ++ int (*generate_key)(DH *dh); ++ int (*compute_key)(unsigned char *key,const BIGNUM *pub_key,DH *dh); ++ int (*bn_mod_exp)(const DH *dh, BIGNUM *r, const BIGNUM *a, ++ const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx, ++ BN_MONT_CTX *m_ctx); /* Can be null */ ++ ++ int (*init)(DH *dh); ++ int (*finish)(DH *dh); ++ int flags; ++ char *app_data; ++ /* If this is non-NULL, it will be used to generate parameters */ ++ int (*generate_params)(DH *dh, int prime_len, int generator, BN_GENCB *cb); ++ }; ++ ++struct dh_st ++ { ++ /* This first argument is used to pick up errors when ++ * a DH is passed instead of a EVP_PKEY */ ++ int pad; ++ int version; ++ BIGNUM *p; ++ BIGNUM *g; ++ long length; /* optional */ ++ BIGNUM *pub_key; /* g^x */ ++ BIGNUM *priv_key; /* x */ ++ ++ int flags; ++ BN_MONT_CTX *method_mont_p; ++ /* Place holders if we want to do X9.42 DH */ ++ BIGNUM *q; ++ BIGNUM *j; ++ unsigned char *seed; ++ int seedlen; ++ BIGNUM *counter; ++ ++ int references; ++ CRYPTO_EX_DATA ex_data; ++ const DH_METHOD *meth; ++ ENGINE *engine; ++ }; ++ ++#define DH_GENERATOR_2 2 ++/* #define DH_GENERATOR_3 3 */ ++#define DH_GENERATOR_5 5 ++ ++/* DH_check error codes */ ++#define DH_CHECK_P_NOT_PRIME 0x01 ++#define DH_CHECK_P_NOT_SAFE_PRIME 0x02 ++#define DH_UNABLE_TO_CHECK_GENERATOR 0x04 ++#define DH_NOT_SUITABLE_GENERATOR 0x08 ++ ++/* DH_check_pub_key error codes */ ++#define DH_CHECK_PUBKEY_TOO_SMALL 0x01 ++#define DH_CHECK_PUBKEY_TOO_LARGE 0x02 ++ ++/* primes p where (p-1)/2 is prime too are called "safe"; we define ++ this for backward compatibility: */ ++#define DH_CHECK_P_NOT_STRONG_PRIME DH_CHECK_P_NOT_SAFE_PRIME ++ ++#define d2i_DHparams_fp(fp,x) (DH *)ASN1_d2i_fp((char *(*)())DH_new, \ ++ (char *(*)())d2i_DHparams,(fp),(unsigned char **)(x)) ++#define i2d_DHparams_fp(fp,x) ASN1_i2d_fp(i2d_DHparams,(fp), \ ++ (unsigned char *)(x)) ++#define d2i_DHparams_bio(bp,x) ASN1_d2i_bio_of(DH,DH_new,d2i_DHparams,bp,x) ++#define i2d_DHparams_bio(bp,x) ASN1_i2d_bio_of_const(DH,i2d_DHparams,bp,x) ++ ++DH *DHparams_dup(DH *); ++ ++const DH_METHOD *DH_OpenSSL(void); ++ ++void DH_set_default_method(const DH_METHOD *meth); ++const DH_METHOD *DH_get_default_method(void); ++int DH_set_method(DH *dh, const DH_METHOD *meth); ++DH *DH_new_method(ENGINE *engine); ++ ++DH * DH_new(void); ++void DH_free(DH *dh); ++int DH_up_ref(DH *dh); ++int DH_size(const DH *dh); ++int DH_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, ++ CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func); ++int DH_set_ex_data(DH *d, int idx, void *arg); ++void *DH_get_ex_data(DH *d, int idx); ++ ++/* Deprecated version */ ++#ifndef OPENSSL_NO_DEPRECATED ++DH * DH_generate_parameters(int prime_len,int generator, ++ void (*callback)(int,int,void *),void *cb_arg); ++#endif /* !defined(OPENSSL_NO_DEPRECATED) */ ++ ++/* New version */ ++int DH_generate_parameters_ex(DH *dh, int prime_len,int generator, BN_GENCB *cb); ++ ++int DH_check(const DH *dh,int *codes); ++int DH_check_pub_key(const DH *dh,const BIGNUM *pub_key, int *codes); ++int DH_generate_key(DH *dh); ++int DH_compute_key(unsigned char *key,const BIGNUM *pub_key,DH *dh); ++DH * d2i_DHparams(DH **a,const unsigned char **pp, long length); ++int i2d_DHparams(const DH *a,unsigned char **pp); ++#ifndef OPENSSL_NO_FP_API ++int DHparams_print_fp(FILE *fp, const DH *x); ++#endif ++#ifndef OPENSSL_NO_BIO ++int DHparams_print(BIO *bp, const DH *x); ++#else ++int DHparams_print(char *bp, const DH *x); ++#endif ++ ++#define EVP_PKEY_CTX_set_dh_paramgen_prime_len(ctx, len) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN, \ ++ EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN, len, NULL) ++ ++#define EVP_PKEY_CTX_set_dh_paramgen_generator(ctx, gen) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN, \ ++ EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR, gen, NULL) ++ ++#define EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN (EVP_PKEY_ALG_CTRL + 1) ++#define EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR (EVP_PKEY_ALG_CTRL + 2) ++ ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_DH_strings(void); ++ ++/* Error codes for the DH functions. */ ++ ++/* Function codes. */ ++#define DH_F_COMPUTE_KEY 102 ++#define DH_F_DHPARAMS_PRINT_FP 101 ++#define DH_F_DH_BUILTIN_GENPARAMS 106 ++#define DH_F_DH_NEW_METHOD 105 ++#define DH_F_DH_PARAM_DECODE 107 ++#define DH_F_DH_PRIV_DECODE 110 ++#define DH_F_DH_PRIV_ENCODE 111 ++#define DH_F_DH_PUB_DECODE 108 ++#define DH_F_DH_PUB_ENCODE 109 ++#define DH_F_DO_DH_PRINT 100 ++#define DH_F_GENERATE_KEY 103 ++#define DH_F_GENERATE_PARAMETERS 104 ++#define DH_F_PKEY_DH_DERIVE 112 ++#define DH_F_PKEY_DH_KEYGEN 113 ++ ++/* Reason codes. */ ++#define DH_R_BAD_GENERATOR 101 ++#define DH_R_BN_DECODE_ERROR 109 ++#define DH_R_BN_ERROR 106 ++#define DH_R_DECODE_ERROR 104 ++#define DH_R_INVALID_PUBKEY 102 ++#define DH_R_KEYS_NOT_SET 108 ++#define DH_R_MODULUS_TOO_LARGE 103 ++#define DH_R_NO_PARAMETERS_SET 107 ++#define DH_R_NO_PRIVATE_VALUE 100 ++#define DH_R_PARAMETER_ENCODING_ERROR 105 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/dsa.h qt.patched/include/openssl/dsa.h +--- qt.orig/include/openssl/dsa.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/dsa.h 2010-08-27 12:01:45.165162700 +0200 +@@ -0,0 +1,307 @@ ++/* crypto/dsa/dsa.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++/* ++ * The DSS routines are based on patches supplied by ++ * Steven Schoch . He basically did the ++ * work and I have just tweaked them a little to fit into my ++ * stylistic vision for SSLeay :-) */ ++ ++#ifndef HEADER_DSA_H ++#define HEADER_DSA_H ++ ++#include ++ ++#ifdef OPENSSL_NO_DSA ++#error DSA is disabled. ++#endif ++ ++#ifndef OPENSSL_NO_BIO ++#include ++#endif ++#include ++#include ++ ++#ifndef OPENSSL_NO_DEPRECATED ++#include ++#ifndef OPENSSL_NO_DH ++# include ++#endif ++#endif ++ ++#ifndef OPENSSL_DSA_MAX_MODULUS_BITS ++# define OPENSSL_DSA_MAX_MODULUS_BITS 10000 ++#endif ++ ++#define DSA_FLAG_CACHE_MONT_P 0x01 ++#define DSA_FLAG_NO_EXP_CONSTTIME 0x02 /* new with 0.9.7h; the built-in DSA ++ * implementation now uses constant time ++ * modular exponentiation for secret exponents ++ * by default. This flag causes the ++ * faster variable sliding window method to ++ * be used for all exponents. ++ */ ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* Already defined in ossl_typ.h */ ++/* typedef struct dsa_st DSA; */ ++/* typedef struct dsa_method DSA_METHOD; */ ++ ++typedef struct DSA_SIG_st ++ { ++ BIGNUM *r; ++ BIGNUM *s; ++ } DSA_SIG; ++ ++struct dsa_method ++ { ++ const char *name; ++ DSA_SIG * (*dsa_do_sign)(const unsigned char *dgst, int dlen, DSA *dsa); ++ int (*dsa_sign_setup)(DSA *dsa, BN_CTX *ctx_in, BIGNUM **kinvp, ++ BIGNUM **rp); ++ int (*dsa_do_verify)(const unsigned char *dgst, int dgst_len, ++ DSA_SIG *sig, DSA *dsa); ++ int (*dsa_mod_exp)(DSA *dsa, BIGNUM *rr, BIGNUM *a1, BIGNUM *p1, ++ BIGNUM *a2, BIGNUM *p2, BIGNUM *m, BN_CTX *ctx, ++ BN_MONT_CTX *in_mont); ++ int (*bn_mod_exp)(DSA *dsa, BIGNUM *r, BIGNUM *a, const BIGNUM *p, ++ const BIGNUM *m, BN_CTX *ctx, ++ BN_MONT_CTX *m_ctx); /* Can be null */ ++ int (*init)(DSA *dsa); ++ int (*finish)(DSA *dsa); ++ int flags; ++ char *app_data; ++ /* If this is non-NULL, it is used to generate DSA parameters */ ++ int (*dsa_paramgen)(DSA *dsa, int bits, ++ const unsigned char *seed, int seed_len, ++ int *counter_ret, unsigned long *h_ret, ++ BN_GENCB *cb); ++ /* If this is non-NULL, it is used to generate DSA keys */ ++ int (*dsa_keygen)(DSA *dsa); ++ }; ++ ++struct dsa_st ++ { ++ /* This first variable is used to pick up errors where ++ * a DSA is passed instead of of a EVP_PKEY */ ++ int pad; ++ long version; ++ int write_params; ++ BIGNUM *p; ++ BIGNUM *q; /* == 20 */ ++ BIGNUM *g; ++ ++ BIGNUM *pub_key; /* y public key */ ++ BIGNUM *priv_key; /* x private key */ ++ ++ BIGNUM *kinv; /* Signing pre-calc */ ++ BIGNUM *r; /* Signing pre-calc */ ++ ++ int flags; ++ /* Normally used to cache montgomery values */ ++ BN_MONT_CTX *method_mont_p; ++ int references; ++ CRYPTO_EX_DATA ex_data; ++ const DSA_METHOD *meth; ++ /* functional reference if 'meth' is ENGINE-provided */ ++ ENGINE *engine; ++ }; ++ ++#define d2i_DSAparams_fp(fp,x) (DSA *)ASN1_d2i_fp((char *(*)())DSA_new, \ ++ (char *(*)())d2i_DSAparams,(fp),(unsigned char **)(x)) ++#define i2d_DSAparams_fp(fp,x) ASN1_i2d_fp(i2d_DSAparams,(fp), \ ++ (unsigned char *)(x)) ++#define d2i_DSAparams_bio(bp,x) ASN1_d2i_bio_of(DSA,DSA_new,d2i_DSAparams,bp,x) ++#define i2d_DSAparams_bio(bp,x) ASN1_i2d_bio_of_const(DSA,i2d_DSAparams,bp,x) ++ ++ ++DSA *DSAparams_dup(DSA *x); ++DSA_SIG * DSA_SIG_new(void); ++void DSA_SIG_free(DSA_SIG *a); ++int i2d_DSA_SIG(const DSA_SIG *a, unsigned char **pp); ++DSA_SIG * d2i_DSA_SIG(DSA_SIG **v, const unsigned char **pp, long length); ++ ++DSA_SIG * DSA_do_sign(const unsigned char *dgst,int dlen,DSA *dsa); ++int DSA_do_verify(const unsigned char *dgst,int dgst_len, ++ DSA_SIG *sig,DSA *dsa); ++ ++const DSA_METHOD *DSA_OpenSSL(void); ++ ++void DSA_set_default_method(const DSA_METHOD *); ++const DSA_METHOD *DSA_get_default_method(void); ++int DSA_set_method(DSA *dsa, const DSA_METHOD *); ++ ++DSA * DSA_new(void); ++DSA * DSA_new_method(ENGINE *engine); ++void DSA_free (DSA *r); ++/* "up" the DSA object's reference count */ ++int DSA_up_ref(DSA *r); ++int DSA_size(const DSA *); ++ /* next 4 return -1 on error */ ++int DSA_sign_setup( DSA *dsa,BN_CTX *ctx_in,BIGNUM **kinvp,BIGNUM **rp); ++int DSA_sign(int type,const unsigned char *dgst,int dlen, ++ unsigned char *sig, unsigned int *siglen, DSA *dsa); ++int DSA_verify(int type,const unsigned char *dgst,int dgst_len, ++ const unsigned char *sigbuf, int siglen, DSA *dsa); ++int DSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, ++ CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func); ++int DSA_set_ex_data(DSA *d, int idx, void *arg); ++void *DSA_get_ex_data(DSA *d, int idx); ++ ++DSA * d2i_DSAPublicKey(DSA **a, const unsigned char **pp, long length); ++DSA * d2i_DSAPrivateKey(DSA **a, const unsigned char **pp, long length); ++DSA * d2i_DSAparams(DSA **a, const unsigned char **pp, long length); ++ ++/* Deprecated version */ ++#ifndef OPENSSL_NO_DEPRECATED ++DSA * DSA_generate_parameters(int bits, ++ unsigned char *seed,int seed_len, ++ int *counter_ret, unsigned long *h_ret,void ++ (*callback)(int, int, void *),void *cb_arg); ++#endif /* !defined(OPENSSL_NO_DEPRECATED) */ ++ ++/* New version */ ++int DSA_generate_parameters_ex(DSA *dsa, int bits, ++ const unsigned char *seed,int seed_len, ++ int *counter_ret, unsigned long *h_ret, BN_GENCB *cb); ++ ++int DSA_generate_key(DSA *a); ++int i2d_DSAPublicKey(const DSA *a, unsigned char **pp); ++int i2d_DSAPrivateKey(const DSA *a, unsigned char **pp); ++int i2d_DSAparams(const DSA *a,unsigned char **pp); ++ ++#ifndef OPENSSL_NO_BIO ++int DSAparams_print(BIO *bp, const DSA *x); ++int DSA_print(BIO *bp, const DSA *x, int off); ++#endif ++#ifndef OPENSSL_NO_FP_API ++int DSAparams_print_fp(FILE *fp, const DSA *x); ++int DSA_print_fp(FILE *bp, const DSA *x, int off); ++#endif ++ ++#define DSS_prime_checks 50 ++/* Primality test according to FIPS PUB 186[-1], Appendix 2.1: ++ * 50 rounds of Rabin-Miller */ ++#define DSA_is_prime(n, callback, cb_arg) \ ++ BN_is_prime(n, DSS_prime_checks, callback, NULL, cb_arg) ++ ++#ifndef OPENSSL_NO_DH ++/* Convert DSA structure (key or just parameters) into DH structure ++ * (be careful to avoid small subgroup attacks when using this!) */ ++DH *DSA_dup_DH(const DSA *r); ++#endif ++ ++#define EVP_PKEY_CTX_set_dsa_paramgen_bits(ctx, nbits) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DSA, EVP_PKEY_OP_PARAMGEN, \ ++ EVP_PKEY_CTRL_DSA_PARAMGEN_BITS, nbits, NULL) ++ ++#define EVP_PKEY_CTRL_DSA_PARAMGEN_BITS (EVP_PKEY_ALG_CTRL + 1) ++#define EVP_PKEY_CTRL_DSA_PARAMGEN_Q_BITS (EVP_PKEY_ALG_CTRL + 2) ++#define EVP_PKEY_CTRL_DSA_PARAMGEN_MD (EVP_PKEY_ALG_CTRL + 3) ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_DSA_strings(void); ++ ++/* Error codes for the DSA functions. */ ++ ++/* Function codes. */ ++#define DSA_F_D2I_DSA_SIG 110 ++#define DSA_F_DO_DSA_PRINT 104 ++#define DSA_F_DSAPARAMS_PRINT 100 ++#define DSA_F_DSAPARAMS_PRINT_FP 101 ++#define DSA_F_DSA_DO_SIGN 112 ++#define DSA_F_DSA_DO_VERIFY 113 ++#define DSA_F_DSA_NEW_METHOD 103 ++#define DSA_F_DSA_PARAM_DECODE 119 ++#define DSA_F_DSA_PRINT_FP 105 ++#define DSA_F_DSA_PRIV_DECODE 115 ++#define DSA_F_DSA_PRIV_ENCODE 116 ++#define DSA_F_DSA_PUB_DECODE 117 ++#define DSA_F_DSA_PUB_ENCODE 118 ++#define DSA_F_DSA_SIGN 106 ++#define DSA_F_DSA_SIGN_SETUP 107 ++#define DSA_F_DSA_SIG_NEW 109 ++#define DSA_F_DSA_VERIFY 108 ++#define DSA_F_I2D_DSA_SIG 111 ++#define DSA_F_OLD_DSA_PRIV_DECODE 122 ++#define DSA_F_PKEY_DSA_CTRL 120 ++#define DSA_F_PKEY_DSA_KEYGEN 121 ++#define DSA_F_SIG_CB 114 ++ ++/* Reason codes. */ ++#define DSA_R_BAD_Q_VALUE 102 ++#define DSA_R_BN_DECODE_ERROR 108 ++#define DSA_R_BN_ERROR 109 ++#define DSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE 100 ++#define DSA_R_DECODE_ERROR 104 ++#define DSA_R_INVALID_DIGEST_TYPE 106 ++#define DSA_R_MISSING_PARAMETERS 101 ++#define DSA_R_MODULUS_TOO_LARGE 103 ++#define DSA_R_NO_PARAMETERS_SET 107 ++#define DSA_R_PARAMETER_ENCODING_ERROR 105 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/dso.h qt.patched/include/openssl/dso.h +--- qt.orig/include/openssl/dso.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/dso.h 2010-08-27 12:01:45.180787100 +0200 +@@ -0,0 +1,409 @@ ++/* dso.h -*- mode:C; c-file-style: "eay" -*- */ ++/* Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL ++ * project 2000. ++ */ ++/* ==================================================================== ++ * Copyright (c) 2000 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * licensing@OpenSSL.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++ ++#ifndef HEADER_DSO_H ++#define HEADER_DSO_H ++ ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* These values are used as commands to DSO_ctrl() */ ++#define DSO_CTRL_GET_FLAGS 1 ++#define DSO_CTRL_SET_FLAGS 2 ++#define DSO_CTRL_OR_FLAGS 3 ++ ++/* By default, DSO_load() will translate the provided filename into a form ++ * typical for the platform (more specifically the DSO_METHOD) using the ++ * dso_name_converter function of the method. Eg. win32 will transform "blah" ++ * into "blah.dll", and dlfcn will transform it into "libblah.so". The ++ * behaviour can be overriden by setting the name_converter callback in the DSO ++ * object (using DSO_set_name_converter()). This callback could even utilise ++ * the DSO_METHOD's converter too if it only wants to override behaviour for ++ * one or two possible DSO methods. However, the following flag can be set in a ++ * DSO to prevent *any* native name-translation at all - eg. if the caller has ++ * prompted the user for a path to a driver library so the filename should be ++ * interpreted as-is. */ ++#define DSO_FLAG_NO_NAME_TRANSLATION 0x01 ++/* An extra flag to give if only the extension should be added as ++ * translation. This is obviously only of importance on Unix and ++ * other operating systems where the translation also may prefix ++ * the name with something, like 'lib', and ignored everywhere else. ++ * This flag is also ignored if DSO_FLAG_NO_NAME_TRANSLATION is used ++ * at the same time. */ ++#define DSO_FLAG_NAME_TRANSLATION_EXT_ONLY 0x02 ++ ++/* The following flag controls the translation of symbol names to upper ++ * case. This is currently only being implemented for OpenVMS. ++ */ ++#define DSO_FLAG_UPCASE_SYMBOL 0x10 ++ ++/* This flag loads the library with public symbols. ++ * Meaning: The exported symbols of this library are public ++ * to all libraries loaded after this library. ++ * At the moment only implemented in unix. ++ */ ++#define DSO_FLAG_GLOBAL_SYMBOLS 0x20 ++ ++ ++typedef void (*DSO_FUNC_TYPE)(void); ++ ++typedef struct dso_st DSO; ++ ++/* The function prototype used for method functions (or caller-provided ++ * callbacks) that transform filenames. They are passed a DSO structure pointer ++ * (or NULL if they are to be used independantly of a DSO object) and a ++ * filename to transform. They should either return NULL (if there is an error ++ * condition) or a newly allocated string containing the transformed form that ++ * the caller will need to free with OPENSSL_free() when done. */ ++typedef char* (*DSO_NAME_CONVERTER_FUNC)(DSO *, const char *); ++/* The function prototype used for method functions (or caller-provided ++ * callbacks) that merge two file specifications. They are passed a ++ * DSO structure pointer (or NULL if they are to be used independantly of ++ * a DSO object) and two file specifications to merge. They should ++ * either return NULL (if there is an error condition) or a newly allocated ++ * string containing the result of merging that the caller will need ++ * to free with OPENSSL_free() when done. ++ * Here, merging means that bits and pieces are taken from each of the ++ * file specifications and added together in whatever fashion that is ++ * sensible for the DSO method in question. The only rule that really ++ * applies is that if the two specification contain pieces of the same ++ * type, the copy from the first string takes priority. One could see ++ * it as the first specification is the one given by the user and the ++ * second being a bunch of defaults to add on if they're missing in the ++ * first. */ ++typedef char* (*DSO_MERGER_FUNC)(DSO *, const char *, const char *); ++ ++typedef struct dso_meth_st ++ { ++ const char *name; ++ /* Loads a shared library, NB: new DSO_METHODs must ensure that a ++ * successful load populates the loaded_filename field, and likewise a ++ * successful unload OPENSSL_frees and NULLs it out. */ ++ int (*dso_load)(DSO *dso); ++ /* Unloads a shared library */ ++ int (*dso_unload)(DSO *dso); ++ /* Binds a variable */ ++ void *(*dso_bind_var)(DSO *dso, const char *symname); ++ /* Binds a function - assumes a return type of DSO_FUNC_TYPE. ++ * This should be cast to the real function prototype by the ++ * caller. Platforms that don't have compatible representations ++ * for different prototypes (this is possible within ANSI C) ++ * are highly unlikely to have shared libraries at all, let ++ * alone a DSO_METHOD implemented for them. */ ++ DSO_FUNC_TYPE (*dso_bind_func)(DSO *dso, const char *symname); ++ ++/* I don't think this would actually be used in any circumstances. */ ++#if 0 ++ /* Unbinds a variable */ ++ int (*dso_unbind_var)(DSO *dso, char *symname, void *symptr); ++ /* Unbinds a function */ ++ int (*dso_unbind_func)(DSO *dso, char *symname, DSO_FUNC_TYPE symptr); ++#endif ++ /* The generic (yuck) "ctrl()" function. NB: Negative return ++ * values (rather than zero) indicate errors. */ ++ long (*dso_ctrl)(DSO *dso, int cmd, long larg, void *parg); ++ /* The default DSO_METHOD-specific function for converting filenames to ++ * a canonical native form. */ ++ DSO_NAME_CONVERTER_FUNC dso_name_converter; ++ /* The default DSO_METHOD-specific function for converting filenames to ++ * a canonical native form. */ ++ DSO_MERGER_FUNC dso_merger; ++ ++ /* [De]Initialisation handlers. */ ++ int (*init)(DSO *dso); ++ int (*finish)(DSO *dso); ++ ++ /* Return pathname of the module containing location */ ++ int (*pathbyaddr)(void *addr,char *path,int sz); ++ /* Perform global symbol lookup, i.e. among *all* modules */ ++ void *(*globallookup)(const char *symname); ++ } DSO_METHOD; ++ ++/**********************************************************************/ ++/* The low-level handle type used to refer to a loaded shared library */ ++ ++struct dso_st ++ { ++ DSO_METHOD *meth; ++ /* Standard dlopen uses a (void *). Win32 uses a HANDLE. VMS ++ * doesn't use anything but will need to cache the filename ++ * for use in the dso_bind handler. All in all, let each ++ * method control its own destiny. "Handles" and such go in ++ * a STACK. */ ++ STACK_OF(void) *meth_data; ++ int references; ++ int flags; ++ /* For use by applications etc ... use this for your bits'n'pieces, ++ * don't touch meth_data! */ ++ CRYPTO_EX_DATA ex_data; ++ /* If this callback function pointer is set to non-NULL, then it will ++ * be used in DSO_load() in place of meth->dso_name_converter. NB: This ++ * should normally set using DSO_set_name_converter(). */ ++ DSO_NAME_CONVERTER_FUNC name_converter; ++ /* If this callback function pointer is set to non-NULL, then it will ++ * be used in DSO_load() in place of meth->dso_merger. NB: This ++ * should normally set using DSO_set_merger(). */ ++ DSO_MERGER_FUNC merger; ++ /* This is populated with (a copy of) the platform-independant ++ * filename used for this DSO. */ ++ char *filename; ++ /* This is populated with (a copy of) the translated filename by which ++ * the DSO was actually loaded. It is NULL iff the DSO is not currently ++ * loaded. NB: This is here because the filename translation process ++ * may involve a callback being invoked more than once not only to ++ * convert to a platform-specific form, but also to try different ++ * filenames in the process of trying to perform a load. As such, this ++ * variable can be used to indicate (a) whether this DSO structure ++ * corresponds to a loaded library or not, and (b) the filename with ++ * which it was actually loaded. */ ++ char *loaded_filename; ++ }; ++ ++ ++DSO * DSO_new(void); ++DSO * DSO_new_method(DSO_METHOD *method); ++int DSO_free(DSO *dso); ++int DSO_flags(DSO *dso); ++int DSO_up_ref(DSO *dso); ++long DSO_ctrl(DSO *dso, int cmd, long larg, void *parg); ++ ++/* This function sets the DSO's name_converter callback. If it is non-NULL, ++ * then it will be used instead of the associated DSO_METHOD's function. If ++ * oldcb is non-NULL then it is set to the function pointer value being ++ * replaced. Return value is non-zero for success. */ ++int DSO_set_name_converter(DSO *dso, DSO_NAME_CONVERTER_FUNC cb, ++ DSO_NAME_CONVERTER_FUNC *oldcb); ++/* These functions can be used to get/set the platform-independant filename ++ * used for a DSO. NB: set will fail if the DSO is already loaded. */ ++const char *DSO_get_filename(DSO *dso); ++int DSO_set_filename(DSO *dso, const char *filename); ++/* This function will invoke the DSO's name_converter callback to translate a ++ * filename, or if the callback isn't set it will instead use the DSO_METHOD's ++ * converter. If "filename" is NULL, the "filename" in the DSO itself will be ++ * used. If the DSO_FLAG_NO_NAME_TRANSLATION flag is set, then the filename is ++ * simply duplicated. NB: This function is usually called from within a ++ * DSO_METHOD during the processing of a DSO_load() call, and is exposed so that ++ * caller-created DSO_METHODs can do the same thing. A non-NULL return value ++ * will need to be OPENSSL_free()'d. */ ++char *DSO_convert_filename(DSO *dso, const char *filename); ++/* This function will invoke the DSO's merger callback to merge two file ++ * specifications, or if the callback isn't set it will instead use the ++ * DSO_METHOD's merger. A non-NULL return value will need to be ++ * OPENSSL_free()'d. */ ++char *DSO_merge(DSO *dso, const char *filespec1, const char *filespec2); ++/* If the DSO is currently loaded, this returns the filename that it was loaded ++ * under, otherwise it returns NULL. So it is also useful as a test as to ++ * whether the DSO is currently loaded. NB: This will not necessarily return ++ * the same value as DSO_convert_filename(dso, dso->filename), because the ++ * DSO_METHOD's load function may have tried a variety of filenames (with ++ * and/or without the aid of the converters) before settling on the one it ++ * actually loaded. */ ++const char *DSO_get_loaded_filename(DSO *dso); ++ ++void DSO_set_default_method(DSO_METHOD *meth); ++DSO_METHOD *DSO_get_default_method(void); ++DSO_METHOD *DSO_get_method(DSO *dso); ++DSO_METHOD *DSO_set_method(DSO *dso, DSO_METHOD *meth); ++ ++/* The all-singing all-dancing load function, you normally pass NULL ++ * for the first and third parameters. Use DSO_up and DSO_free for ++ * subsequent reference count handling. Any flags passed in will be set ++ * in the constructed DSO after its init() function but before the ++ * load operation. If 'dso' is non-NULL, 'flags' is ignored. */ ++DSO *DSO_load(DSO *dso, const char *filename, DSO_METHOD *meth, int flags); ++ ++/* This function binds to a variable inside a shared library. */ ++void *DSO_bind_var(DSO *dso, const char *symname); ++ ++/* This function binds to a function inside a shared library. */ ++DSO_FUNC_TYPE DSO_bind_func(DSO *dso, const char *symname); ++ ++/* This method is the default, but will beg, borrow, or steal whatever ++ * method should be the default on any particular platform (including ++ * DSO_METH_null() if necessary). */ ++DSO_METHOD *DSO_METHOD_openssl(void); ++ ++/* This method is defined for all platforms - if a platform has no ++ * DSO support then this will be the only method! */ ++DSO_METHOD *DSO_METHOD_null(void); ++ ++/* If DSO_DLFCN is defined, the standard dlfcn.h-style functions ++ * (dlopen, dlclose, dlsym, etc) will be used and incorporated into ++ * this method. If not, this method will return NULL. */ ++DSO_METHOD *DSO_METHOD_dlfcn(void); ++ ++/* If DSO_DL is defined, the standard dl.h-style functions (shl_load, ++ * shl_unload, shl_findsym, etc) will be used and incorporated into ++ * this method. If not, this method will return NULL. */ ++DSO_METHOD *DSO_METHOD_dl(void); ++ ++/* If WIN32 is defined, use DLLs. If not, return NULL. */ ++DSO_METHOD *DSO_METHOD_win32(void); ++ ++/* If VMS is defined, use shared images. If not, return NULL. */ ++DSO_METHOD *DSO_METHOD_vms(void); ++ ++/* This function writes null-terminated pathname of DSO module ++ * containing 'addr' into 'sz' large caller-provided 'path' and ++ * returns the number of characters [including trailing zero] ++ * written to it. If 'sz' is 0 or negative, 'path' is ignored and ++ * required amount of charachers [including trailing zero] to ++ * accomodate pathname is returned. If 'addr' is NULL, then ++ * pathname of cryptolib itself is returned. Negative or zero ++ * return value denotes error. ++ */ ++int DSO_pathbyaddr(void *addr,char *path,int sz); ++ ++/* This function should be used with caution! It looks up symbols in ++ * *all* loaded modules and if module gets unloaded by somebody else ++ * attempt to dereference the pointer is doomed to have fatal ++ * consequences. Primary usage for this function is to probe *core* ++ * system functionality, e.g. check if getnameinfo(3) is available ++ * at run-time without bothering about OS-specific details such as ++ * libc.so.versioning or where does it actually reside: in libc ++ * itself or libsocket. */ ++void *DSO_global_lookup(const char *name); ++ ++/* If BeOS is defined, use shared images. If not, return NULL. */ ++DSO_METHOD *DSO_METHOD_beos(void); ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_DSO_strings(void); ++ ++/* Error codes for the DSO functions. */ ++ ++/* Function codes. */ ++#define DSO_F_BEOS_BIND_FUNC 144 ++#define DSO_F_BEOS_BIND_VAR 145 ++#define DSO_F_BEOS_LOAD 146 ++#define DSO_F_BEOS_NAME_CONVERTER 147 ++#define DSO_F_BEOS_UNLOAD 148 ++#define DSO_F_DLFCN_BIND_FUNC 100 ++#define DSO_F_DLFCN_BIND_VAR 101 ++#define DSO_F_DLFCN_LOAD 102 ++#define DSO_F_DLFCN_MERGER 130 ++#define DSO_F_DLFCN_NAME_CONVERTER 123 ++#define DSO_F_DLFCN_UNLOAD 103 ++#define DSO_F_DL_BIND_FUNC 104 ++#define DSO_F_DL_BIND_VAR 105 ++#define DSO_F_DL_LOAD 106 ++#define DSO_F_DL_MERGER 131 ++#define DSO_F_DL_NAME_CONVERTER 124 ++#define DSO_F_DL_UNLOAD 107 ++#define DSO_F_DSO_BIND_FUNC 108 ++#define DSO_F_DSO_BIND_VAR 109 ++#define DSO_F_DSO_CONVERT_FILENAME 126 ++#define DSO_F_DSO_CTRL 110 ++#define DSO_F_DSO_FREE 111 ++#define DSO_F_DSO_GET_FILENAME 127 ++#define DSO_F_DSO_GET_LOADED_FILENAME 128 ++#define DSO_F_DSO_GLOBAL_LOOKUP 139 ++#define DSO_F_DSO_LOAD 112 ++#define DSO_F_DSO_MERGE 132 ++#define DSO_F_DSO_NEW_METHOD 113 ++#define DSO_F_DSO_PATHBYADDR 140 ++#define DSO_F_DSO_SET_FILENAME 129 ++#define DSO_F_DSO_SET_NAME_CONVERTER 122 ++#define DSO_F_DSO_UP_REF 114 ++#define DSO_F_GLOBAL_LOOKUP_FUNC 138 ++#define DSO_F_PATHBYADDR 137 ++#define DSO_F_VMS_BIND_SYM 115 ++#define DSO_F_VMS_LOAD 116 ++#define DSO_F_VMS_MERGER 133 ++#define DSO_F_VMS_UNLOAD 117 ++#define DSO_F_WIN32_BIND_FUNC 118 ++#define DSO_F_WIN32_BIND_VAR 119 ++#define DSO_F_WIN32_GLOBALLOOKUP 142 ++#define DSO_F_WIN32_GLOBALLOOKUP_FUNC 143 ++#define DSO_F_WIN32_JOINER 135 ++#define DSO_F_WIN32_LOAD 120 ++#define DSO_F_WIN32_MERGER 134 ++#define DSO_F_WIN32_NAME_CONVERTER 125 ++#define DSO_F_WIN32_PATHBYADDR 141 ++#define DSO_F_WIN32_SPLITTER 136 ++#define DSO_F_WIN32_UNLOAD 121 ++ ++/* Reason codes. */ ++#define DSO_R_CTRL_FAILED 100 ++#define DSO_R_DSO_ALREADY_LOADED 110 ++#define DSO_R_EMPTY_FILE_STRUCTURE 113 ++#define DSO_R_FAILURE 114 ++#define DSO_R_FILENAME_TOO_BIG 101 ++#define DSO_R_FINISH_FAILED 102 ++#define DSO_R_INCORRECT_FILE_SYNTAX 115 ++#define DSO_R_LOAD_FAILED 103 ++#define DSO_R_NAME_TRANSLATION_FAILED 109 ++#define DSO_R_NO_FILENAME 111 ++#define DSO_R_NO_FILE_SPECIFICATION 116 ++#define DSO_R_NULL_HANDLE 104 ++#define DSO_R_SET_FILENAME_FAILED 112 ++#define DSO_R_STACK_ERROR 105 ++#define DSO_R_SYM_FAILURE 106 ++#define DSO_R_UNLOAD_FAILED 107 ++#define DSO_R_UNSUPPORTED 108 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/dtls1.h qt.patched/include/openssl/dtls1.h +--- qt.orig/include/openssl/dtls1.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/dtls1.h 2010-08-27 12:01:45.196411500 +0200 +@@ -0,0 +1,267 @@ ++/* ssl/dtls1.h */ ++/* ++ * DTLS implementation written by Nagendra Modadugu ++ * (nagendra@cs.stanford.edu) for the OpenSSL project 2005. ++ */ ++/* ==================================================================== ++ * Copyright (c) 1999-2005 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * openssl-core@OpenSSL.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++ ++#ifndef HEADER_DTLS1_H ++#define HEADER_DTLS1_H ++ ++#include ++#include ++#ifdef OPENSSL_SYS_VMS ++#include ++#include ++#endif ++#ifdef OPENSSL_SYS_WIN32 ++/* Needed for struct timeval */ ++#include ++#elif defined(OPENSSL_SYS_NETWARE) && !defined(_WINSOCK2API_) ++#include ++#else ++#include ++#endif ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#define DTLS1_VERSION 0xFEFF ++#define DTLS1_BAD_VER 0x0100 ++ ++#if 0 ++/* this alert description is not specified anywhere... */ ++#define DTLS1_AD_MISSING_HANDSHAKE_MESSAGE 110 ++#endif ++ ++/* lengths of messages */ ++#define DTLS1_COOKIE_LENGTH 256 ++ ++#define DTLS1_RT_HEADER_LENGTH 13 ++ ++#define DTLS1_HM_HEADER_LENGTH 12 ++ ++#define DTLS1_HM_BAD_FRAGMENT -2 ++#define DTLS1_HM_FRAGMENT_RETRY -3 ++ ++#define DTLS1_CCS_HEADER_LENGTH 1 ++ ++#ifdef DTLS1_AD_MISSING_HANDSHAKE_MESSAGE ++#define DTLS1_AL_HEADER_LENGTH 7 ++#else ++#define DTLS1_AL_HEADER_LENGTH 2 ++#endif ++ ++ ++typedef struct dtls1_bitmap_st ++ { ++ unsigned long map; /* track 32 packets on 32-bit systems ++ and 64 - on 64-bit systems */ ++ unsigned char max_seq_num[8]; /* max record number seen so far, ++ 64-bit value in big-endian ++ encoding */ ++ } DTLS1_BITMAP; ++ ++struct dtls1_retransmit_state ++ { ++ EVP_CIPHER_CTX *enc_write_ctx; /* cryptographic state */ ++ EVP_MD_CTX *write_hash; /* used for mac generation */ ++#ifndef OPENSSL_NO_COMP ++ COMP_CTX *compress; /* compression */ ++#else ++ char *compress; ++#endif ++ SSL_SESSION *session; ++ unsigned short epoch; ++ }; ++ ++struct hm_header_st ++ { ++ unsigned char type; ++ unsigned long msg_len; ++ unsigned short seq; ++ unsigned long frag_off; ++ unsigned long frag_len; ++ unsigned int is_ccs; ++ struct dtls1_retransmit_state saved_retransmit_state; ++ }; ++ ++struct ccs_header_st ++ { ++ unsigned char type; ++ unsigned short seq; ++ }; ++ ++struct dtls1_timeout_st ++ { ++ /* Number of read timeouts so far */ ++ unsigned int read_timeouts; ++ ++ /* Number of write timeouts so far */ ++ unsigned int write_timeouts; ++ ++ /* Number of alerts received so far */ ++ unsigned int num_alerts; ++ }; ++ ++typedef struct record_pqueue_st ++ { ++ unsigned short epoch; ++ pqueue q; ++ } record_pqueue; ++ ++typedef struct hm_fragment_st ++ { ++ struct hm_header_st msg_header; ++ unsigned char *fragment; ++ unsigned char *reassembly; ++ } hm_fragment; ++ ++typedef struct dtls1_state_st ++ { ++ unsigned int send_cookie; ++ unsigned char cookie[DTLS1_COOKIE_LENGTH]; ++ unsigned char rcvd_cookie[DTLS1_COOKIE_LENGTH]; ++ unsigned int cookie_len; ++ ++ /* ++ * The current data and handshake epoch. This is initially ++ * undefined, and starts at zero once the initial handshake is ++ * completed ++ */ ++ unsigned short r_epoch; ++ unsigned short w_epoch; ++ ++ /* records being received in the current epoch */ ++ DTLS1_BITMAP bitmap; ++ ++ /* renegotiation starts a new set of sequence numbers */ ++ DTLS1_BITMAP next_bitmap; ++ ++ /* handshake message numbers */ ++ unsigned short handshake_write_seq; ++ unsigned short next_handshake_write_seq; ++ ++ unsigned short handshake_read_seq; ++ ++ /* save last sequence number for retransmissions */ ++ unsigned char last_write_sequence[8]; ++ ++ /* Received handshake records (processed and unprocessed) */ ++ record_pqueue unprocessed_rcds; ++ record_pqueue processed_rcds; ++ ++ /* Buffered handshake messages */ ++ pqueue buffered_messages; ++ ++ /* Buffered (sent) handshake records */ ++ pqueue sent_messages; ++ ++ /* Buffered application records. ++ * Only for records between CCS and Finished ++ * to prevent either protocol violation or ++ * unnecessary message loss. ++ */ ++ record_pqueue buffered_app_data; ++ ++ /* Is set when listening for new connections with dtls1_listen() */ ++ unsigned int listen; ++ ++ unsigned int mtu; /* max DTLS packet size */ ++ ++ struct hm_header_st w_msg_hdr; ++ struct hm_header_st r_msg_hdr; ++ ++ struct dtls1_timeout_st timeout; ++ ++ /* Indicates when the last handshake msg sent will timeout */ ++ struct timeval next_timeout; ++ ++ /* Timeout duration */ ++ unsigned short timeout_duration; ++ ++ /* storage for Alert/Handshake protocol data received but not ++ * yet processed by ssl3_read_bytes: */ ++ unsigned char alert_fragment[DTLS1_AL_HEADER_LENGTH]; ++ unsigned int alert_fragment_len; ++ unsigned char handshake_fragment[DTLS1_HM_HEADER_LENGTH]; ++ unsigned int handshake_fragment_len; ++ ++ unsigned int retransmitting; ++ unsigned int change_cipher_spec_ok; ++ ++ } DTLS1_STATE; ++ ++typedef struct dtls1_record_data_st ++ { ++ unsigned char *packet; ++ unsigned int packet_length; ++ SSL3_BUFFER rbuf; ++ SSL3_RECORD rrec; ++ } DTLS1_RECORD_DATA; ++ ++ ++/* Timeout multipliers (timeout slice is defined in apps/timeouts.h */ ++#define DTLS1_TMO_READ_COUNT 2 ++#define DTLS1_TMO_WRITE_COUNT 2 ++ ++#define DTLS1_TMO_ALERT_COUNT 12 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif ++ +diff -urN qt.orig/include/openssl/e_os2.h qt.patched/include/openssl/e_os2.h +--- qt.orig/include/openssl/e_os2.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/e_os2.h 2010-08-27 12:01:45.196411500 +0200 +@@ -0,0 +1,289 @@ ++/* e_os2.h */ ++/* ==================================================================== ++ * Copyright (c) 1998-2000 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * openssl-core@openssl.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.openssl.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++ ++#include ++ ++#ifndef HEADER_E_OS2_H ++#define HEADER_E_OS2_H ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/****************************************************************************** ++ * Detect operating systems. This probably needs completing. ++ * The result is that at least one OPENSSL_SYS_os macro should be defined. ++ * However, if none is defined, Unix is assumed. ++ **/ ++ ++#define OPENSSL_SYS_UNIX ++ ++/* ----------------------- Macintosh, before MacOS X ----------------------- */ ++#if defined(__MWERKS__) && defined(macintosh) || defined(OPENSSL_SYSNAME_MAC) ++# undef OPENSSL_SYS_UNIX ++# define OPENSSL_SYS_MACINTOSH_CLASSIC ++#endif ++ ++/* ----------------------- NetWare ----------------------------------------- */ ++#if defined(NETWARE) || defined(OPENSSL_SYSNAME_NETWARE) ++# undef OPENSSL_SYS_UNIX ++# define OPENSSL_SYS_NETWARE ++#endif ++ ++/* ---------------------- Microsoft operating systems ---------------------- */ ++ ++/* Note that MSDOS actually denotes 32-bit environments running on top of ++ MS-DOS, such as DJGPP one. */ ++#if defined(OPENSSL_SYSNAME_MSDOS) ++# undef OPENSSL_SYS_UNIX ++# define OPENSSL_SYS_MSDOS ++#endif ++ ++/* For 32 bit environment, there seems to be the CygWin environment and then ++ all the others that try to do the same thing Microsoft does... */ ++#if defined(OPENSSL_SYSNAME_UWIN) ++# undef OPENSSL_SYS_UNIX ++# define OPENSSL_SYS_WIN32_UWIN ++#else ++# if defined(__CYGWIN32__) || defined(OPENSSL_SYSNAME_CYGWIN32) ++# undef OPENSSL_SYS_UNIX ++# define OPENSSL_SYS_WIN32_CYGWIN ++# else ++# if defined(_WIN32) || defined(OPENSSL_SYSNAME_WIN32) ++# undef OPENSSL_SYS_UNIX ++# define OPENSSL_SYS_WIN32 ++# endif ++# if defined(OPENSSL_SYSNAME_WINNT) ++# undef OPENSSL_SYS_UNIX ++# define OPENSSL_SYS_WINNT ++# endif ++# if defined(OPENSSL_SYSNAME_WINCE) ++# undef OPENSSL_SYS_UNIX ++# define OPENSSL_SYS_WINCE ++# endif ++# endif ++#endif ++ ++/* Anything that tries to look like Microsoft is "Windows" */ ++#if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WINNT) || defined(OPENSSL_SYS_WINCE) ++# undef OPENSSL_SYS_UNIX ++# define OPENSSL_SYS_WINDOWS ++# ifndef OPENSSL_SYS_MSDOS ++# define OPENSSL_SYS_MSDOS ++# endif ++#endif ++ ++/* DLL settings. This part is a bit tough, because it's up to the application ++ implementor how he or she will link the application, so it requires some ++ macro to be used. */ ++#ifdef OPENSSL_SYS_WINDOWS ++# ifndef OPENSSL_OPT_WINDLL ++# if defined(_WINDLL) /* This is used when building OpenSSL to indicate that ++ DLL linkage should be used */ ++# define OPENSSL_OPT_WINDLL ++# endif ++# endif ++#endif ++ ++/* -------------------------------- OpenVMS -------------------------------- */ ++#if defined(__VMS) || defined(VMS) || defined(OPENSSL_SYSNAME_VMS) ++# undef OPENSSL_SYS_UNIX ++# define OPENSSL_SYS_VMS ++# if defined(__DECC) ++# define OPENSSL_SYS_VMS_DECC ++# elif defined(__DECCXX) ++# define OPENSSL_SYS_VMS_DECC ++# define OPENSSL_SYS_VMS_DECCXX ++# else ++# define OPENSSL_SYS_VMS_NODECC ++# endif ++#endif ++ ++/* --------------------------------- OS/2 ---------------------------------- */ ++#if defined(__EMX__) || defined(__OS2__) ++# undef OPENSSL_SYS_UNIX ++# define OPENSSL_SYS_OS2 ++#endif ++ ++/* --------------------------------- Unix ---------------------------------- */ ++#ifdef OPENSSL_SYS_UNIX ++# if defined(linux) || defined(__linux__) || defined(OPENSSL_SYSNAME_LINUX) ++# define OPENSSL_SYS_LINUX ++# endif ++# ifdef OPENSSL_SYSNAME_MPE ++# define OPENSSL_SYS_MPE ++# endif ++# ifdef OPENSSL_SYSNAME_SNI ++# define OPENSSL_SYS_SNI ++# endif ++# ifdef OPENSSL_SYSNAME_ULTRASPARC ++# define OPENSSL_SYS_ULTRASPARC ++# endif ++# ifdef OPENSSL_SYSNAME_NEWS4 ++# define OPENSSL_SYS_NEWS4 ++# endif ++# ifdef OPENSSL_SYSNAME_MACOSX ++# define OPENSSL_SYS_MACOSX ++# endif ++# ifdef OPENSSL_SYSNAME_MACOSX_RHAPSODY ++# define OPENSSL_SYS_MACOSX_RHAPSODY ++# define OPENSSL_SYS_MACOSX ++# endif ++# ifdef OPENSSL_SYSNAME_SUNOS ++# define OPENSSL_SYS_SUNOS ++#endif ++# if defined(_CRAY) || defined(OPENSSL_SYSNAME_CRAY) ++# define OPENSSL_SYS_CRAY ++# endif ++# if defined(_AIX) || defined(OPENSSL_SYSNAME_AIX) ++# define OPENSSL_SYS_AIX ++# endif ++#endif ++ ++/* --------------------------------- VOS ----------------------------------- */ ++#ifdef OPENSSL_SYSNAME_VOS ++# define OPENSSL_SYS_VOS ++#endif ++ ++/* ------------------------------- VxWorks --------------------------------- */ ++#ifdef OPENSSL_SYSNAME_VXWORKS ++# define OPENSSL_SYS_VXWORKS ++#endif ++ ++/* --------------------------------- BeOS ---------------------------------- */ ++#if defined(__BEOS__) ++# define OPENSSL_SYS_BEOS ++# include ++# if defined(BONE_VERSION) ++# define OPENSSL_SYS_BEOS_BONE ++# else ++# define OPENSSL_SYS_BEOS_R5 ++# endif ++#endif ++ ++/** ++ * That's it for OS-specific stuff ++ *****************************************************************************/ ++ ++ ++/* Specials for I/O an exit */ ++#ifdef OPENSSL_SYS_MSDOS ++# define OPENSSL_UNISTD_IO ++# define OPENSSL_DECLARE_EXIT extern void exit(int); ++#else ++# define OPENSSL_UNISTD_IO OPENSSL_UNISTD ++# define OPENSSL_DECLARE_EXIT /* declared in unistd.h */ ++#endif ++ ++/* Definitions of OPENSSL_GLOBAL and OPENSSL_EXTERN, to define and declare ++ certain global symbols that, with some compilers under VMS, have to be ++ defined and declared explicitely with globaldef and globalref. ++ Definitions of OPENSSL_EXPORT and OPENSSL_IMPORT, to define and declare ++ DLL exports and imports for compilers under Win32. These are a little ++ more complicated to use. Basically, for any library that exports some ++ global variables, the following code must be present in the header file ++ that declares them, before OPENSSL_EXTERN is used: ++ ++ #ifdef SOME_BUILD_FLAG_MACRO ++ # undef OPENSSL_EXTERN ++ # define OPENSSL_EXTERN OPENSSL_EXPORT ++ #endif ++ ++ The default is to have OPENSSL_EXPORT, OPENSSL_IMPORT and OPENSSL_GLOBAL ++ have some generally sensible values, and for OPENSSL_EXTERN to have the ++ value OPENSSL_IMPORT. ++*/ ++ ++#if defined(OPENSSL_SYS_VMS_NODECC) ++# define OPENSSL_EXPORT globalref ++# define OPENSSL_IMPORT globalref ++# define OPENSSL_GLOBAL globaldef ++#elif defined(OPENSSL_SYS_WINDOWS) && defined(OPENSSL_OPT_WINDLL) ++# define OPENSSL_EXPORT extern __declspec(dllexport) ++# define OPENSSL_IMPORT extern __declspec(dllimport) ++# define OPENSSL_GLOBAL ++#else ++# define OPENSSL_EXPORT extern ++# define OPENSSL_IMPORT extern ++# define OPENSSL_GLOBAL ++#endif ++#define OPENSSL_EXTERN OPENSSL_IMPORT ++ ++/* Macros to allow global variables to be reached through function calls when ++ required (if a shared library version requires it, for example. ++ The way it's done allows definitions like this: ++ ++ // in foobar.c ++ OPENSSL_IMPLEMENT_GLOBAL(int,foobar,0) ++ // in foobar.h ++ OPENSSL_DECLARE_GLOBAL(int,foobar); ++ #define foobar OPENSSL_GLOBAL_REF(foobar) ++*/ ++#ifdef OPENSSL_EXPORT_VAR_AS_FUNCTION ++# define OPENSSL_IMPLEMENT_GLOBAL(type,name,value) \ ++ type *_shadow_##name(void) \ ++ { static type _hide_##name=value; return &_hide_##name; } ++# define OPENSSL_DECLARE_GLOBAL(type,name) type *_shadow_##name(void) ++# define OPENSSL_GLOBAL_REF(name) (*(_shadow_##name())) ++#else ++# define OPENSSL_IMPLEMENT_GLOBAL(type,name,value) OPENSSL_GLOBAL type _shadow_##name=value; ++# define OPENSSL_DECLARE_GLOBAL(type,name) OPENSSL_EXPORT type _shadow_##name ++# define OPENSSL_GLOBAL_REF(name) _shadow_##name ++#endif ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/ebcdic.h qt.patched/include/openssl/ebcdic.h +--- qt.orig/include/openssl/ebcdic.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/ebcdic.h 2010-08-27 12:01:45.212035900 +0200 +@@ -0,0 +1,19 @@ ++/* crypto/ebcdic.h */ ++ ++#ifndef HEADER_EBCDIC_H ++#define HEADER_EBCDIC_H ++ ++#include ++ ++/* Avoid name clashes with other applications */ ++#define os_toascii _openssl_os_toascii ++#define os_toebcdic _openssl_os_toebcdic ++#define ebcdic2ascii _openssl_ebcdic2ascii ++#define ascii2ebcdic _openssl_ascii2ebcdic ++ ++extern const unsigned char os_toascii[256]; ++extern const unsigned char os_toebcdic[256]; ++void *ebcdic2ascii(void *dest, const void *srce, size_t count); ++void *ascii2ebcdic(void *dest, const void *srce, size_t count); ++ ++#endif +diff -urN qt.orig/include/openssl/ec.h qt.patched/include/openssl/ec.h +--- qt.orig/include/openssl/ec.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/ec.h 2010-08-27 12:01:45.227660300 +0200 +@@ -0,0 +1,1100 @@ ++/* crypto/ec/ec.h */ ++/* ++ * Originally written by Bodo Moeller for the OpenSSL project. ++ */ ++/** ++ * \file crypto/ec/ec.h Include file for the OpenSSL EC functions ++ * \author Originally written by Bodo Moeller for the OpenSSL project ++ */ ++/* ==================================================================== ++ * Copyright (c) 1998-2005 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * openssl-core@openssl.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.openssl.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++/* ==================================================================== ++ * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. ++ * ++ * Portions of the attached software ("Contribution") are developed by ++ * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project. ++ * ++ * The Contribution is licensed pursuant to the OpenSSL open source ++ * license provided above. ++ * ++ * The elliptic curve binary polynomial software is originally written by ++ * Sheueling Chang Shantz and Douglas Stebila of Sun Microsystems Laboratories. ++ * ++ */ ++ ++#ifndef HEADER_EC_H ++#define HEADER_EC_H ++ ++#include ++ ++#ifdef OPENSSL_NO_EC ++#error EC is disabled. ++#endif ++ ++#include ++#include ++#ifndef OPENSSL_NO_DEPRECATED ++#include ++#endif ++ ++#ifdef __cplusplus ++extern "C" { ++#elif defined(__SUNPRO_C) ++# if __SUNPRO_C >= 0x520 ++# pragma error_messages (off,E_ARRAY_OF_INCOMPLETE_NONAME,E_ARRAY_OF_INCOMPLETE) ++# endif ++#endif ++ ++ ++#ifndef OPENSSL_ECC_MAX_FIELD_BITS ++# define OPENSSL_ECC_MAX_FIELD_BITS 661 ++#endif ++ ++/** Enum for the point conversion form as defined in X9.62 (ECDSA) ++ * for the encoding of a elliptic curve point (x,y) */ ++typedef enum { ++ /** the point is encoded as z||x, where the octet z specifies ++ * which solution of the quadratic equation y is */ ++ POINT_CONVERSION_COMPRESSED = 2, ++ /** the point is encoded as z||x||y, where z is the octet 0x02 */ ++ POINT_CONVERSION_UNCOMPRESSED = 4, ++ /** the point is encoded as z||x||y, where the octet z specifies ++ * which solution of the quadratic equation y is */ ++ POINT_CONVERSION_HYBRID = 6 ++} point_conversion_form_t; ++ ++ ++typedef struct ec_method_st EC_METHOD; ++ ++typedef struct ec_group_st ++ /* ++ EC_METHOD *meth; ++ -- field definition ++ -- curve coefficients ++ -- optional generator with associated information (order, cofactor) ++ -- optional extra data (precomputed table for fast computation of multiples of generator) ++ -- ASN1 stuff ++ */ ++ EC_GROUP; ++ ++typedef struct ec_point_st EC_POINT; ++ ++ ++/********************************************************************/ ++/* EC_METHODs for curves over GF(p) */ ++/********************************************************************/ ++ ++/** Returns the basic GFp ec methods which provides the basis for the ++ * optimized methods. ++ * \return EC_METHOD object ++ */ ++const EC_METHOD *EC_GFp_simple_method(void); ++ ++/** Returns GFp methods using montgomery multiplication. ++ * \return EC_METHOD object ++ */ ++const EC_METHOD *EC_GFp_mont_method(void); ++ ++/** Returns GFp methods using optimized methods for NIST recommended curves ++ * \return EC_METHOD object ++ */ ++const EC_METHOD *EC_GFp_nist_method(void); ++ ++ ++/********************************************************************/ ++/* EC_METHOD for curves over GF(2^m) */ ++/********************************************************************/ ++ ++/** Returns the basic GF2m ec method ++ * \return EC_METHOD object ++ */ ++const EC_METHOD *EC_GF2m_simple_method(void); ++ ++ ++/********************************************************************/ ++/* EC_GROUP functions */ ++/********************************************************************/ ++ ++/** Creates a new EC_GROUP object ++ * \param meth EC_METHOD to use ++ * \return newly created EC_GROUP object or NULL in case of an error. ++ */ ++EC_GROUP *EC_GROUP_new(const EC_METHOD *meth); ++ ++/** Frees a EC_GROUP object ++ * \param group EC_GROUP object to be freed. ++ */ ++void EC_GROUP_free(EC_GROUP *group); ++ ++/** Clears and frees a EC_GROUP object ++ * \param group EC_GROUP object to be cleared and freed. ++ */ ++void EC_GROUP_clear_free(EC_GROUP *group); ++ ++/** Copies EC_GROUP objects. Note: both EC_GROUPs must use the same EC_METHOD. ++ * \param dst destination EC_GROUP object ++ * \param src source EC_GROUP object ++ * \return 1 on success and 0 if an error occurred. ++ */ ++int EC_GROUP_copy(EC_GROUP *dst, const EC_GROUP *src); ++ ++/** Creates a new EC_GROUP object and copies the copies the content ++ * form src to the newly created EC_KEY object ++ * \param src source EC_GROUP object ++ * \return newly created EC_GROUP object or NULL in case of an error. ++ */ ++EC_GROUP *EC_GROUP_dup(const EC_GROUP *src); ++ ++/** Returns the EC_METHOD of the EC_GROUP object. ++ * \param group EC_GROUP object ++ * \return EC_METHOD used in this EC_GROUP object. ++ */ ++const EC_METHOD *EC_GROUP_method_of(const EC_GROUP *group); ++ ++/** Returns the field type of the EC_METHOD. ++ * \param meth EC_METHOD object ++ * \return NID of the underlying field type OID. ++ */ ++int EC_METHOD_get_field_type(const EC_METHOD *meth); ++ ++/** Sets the generator and it's order/cofactor of a EC_GROUP object. ++ * \param group EC_GROUP object ++ * \param generator EC_POINT object with the generator. ++ * \param order the order of the group generated by the generator. ++ * \param cofactor the index of the sub-group generated by the generator ++ * in the group of all points on the elliptic curve. ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator, const BIGNUM *order, const BIGNUM *cofactor); ++ ++/** Returns the generator of a EC_GROUP object. ++ * \param group EC_GROUP object ++ * \return the currently used generator (possibly NULL). ++ */ ++const EC_POINT *EC_GROUP_get0_generator(const EC_GROUP *group); ++ ++/** Gets the order of a EC_GROUP ++ * \param group EC_GROUP object ++ * \param order BIGNUM to which the order is copied ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx); ++ ++/** Gets the cofactor of a EC_GROUP ++ * \param group EC_GROUP object ++ * \param cofactor BIGNUM to which the cofactor is copied ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor, BN_CTX *ctx); ++ ++/** Sets the name of a EC_GROUP object ++ * \param group EC_GROUP object ++ * \param nid NID of the curve name OID ++ */ ++void EC_GROUP_set_curve_name(EC_GROUP *group, int nid); ++ ++/** Returns the curve name of a EC_GROUP object ++ * \param group EC_GROUP object ++ * \return NID of the curve name OID or 0 if not set. ++ */ ++int EC_GROUP_get_curve_name(const EC_GROUP *group); ++ ++void EC_GROUP_set_asn1_flag(EC_GROUP *group, int flag); ++int EC_GROUP_get_asn1_flag(const EC_GROUP *group); ++ ++void EC_GROUP_set_point_conversion_form(EC_GROUP *, point_conversion_form_t); ++point_conversion_form_t EC_GROUP_get_point_conversion_form(const EC_GROUP *); ++ ++unsigned char *EC_GROUP_get0_seed(const EC_GROUP *); ++size_t EC_GROUP_get_seed_len(const EC_GROUP *); ++size_t EC_GROUP_set_seed(EC_GROUP *, const unsigned char *, size_t len); ++ ++/** Sets the parameter of a ec over GFp defined by y^2 = x^3 + a*x + b ++ * \param group EC_GROUP object ++ * \param p BIGNUM with the prime number ++ * \param a BIGNUM with parameter a of the equation ++ * \param b BIGNUM with parameter b of the equation ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_GROUP_set_curve_GFp(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); ++ ++/** Gets the parameter of the ec over GFp defined by y^2 = x^3 + a*x + b ++ * \param group EC_GROUP object ++ * \param p BIGNUM for the prime number ++ * \param a BIGNUM for parameter a of the equation ++ * \param b BIGNUM for parameter b of the equation ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_GROUP_get_curve_GFp(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b, BN_CTX *ctx); ++ ++/** Sets the parameter of a ec over GF2m defined by y^2 + x*y = x^3 + a*x^2 + b ++ * \param group EC_GROUP object ++ * \param p BIGNUM with the polynomial defining the underlying field ++ * \param a BIGNUM with parameter a of the equation ++ * \param b BIGNUM with parameter b of the equation ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_GROUP_set_curve_GF2m(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); ++ ++/** Gets the parameter of the ec over GF2m defined by y^2 + x*y = x^3 + a*x^2 + b ++ * \param group EC_GROUP object ++ * \param p BIGNUM for the polynomial defining the underlying field ++ * \param a BIGNUM for parameter a of the equation ++ * \param b BIGNUM for parameter b of the equation ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_GROUP_get_curve_GF2m(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b, BN_CTX *ctx); ++ ++/** Returns the number of bits needed to represent a field element ++ * \param group EC_GROUP object ++ * \return number of bits needed to represent a field element ++ */ ++int EC_GROUP_get_degree(const EC_GROUP *group); ++ ++/** Checks whether the parameter in the EC_GROUP define a valid ec group ++ * \param group EC_GROUP object ++ * \param ctx BN_CTX object (optional) ++ * \return 1 if group is a valid ec group and 0 otherwise ++ */ ++int EC_GROUP_check(const EC_GROUP *group, BN_CTX *ctx); ++ ++/** Checks whether the discriminant of the elliptic curve is zero or not ++ * \param group EC_GROUP object ++ * \param ctx BN_CTX object (optional) ++ * \return 1 if the discriminant is not zero and 0 otherwise ++ */ ++int EC_GROUP_check_discriminant(const EC_GROUP *group, BN_CTX *ctx); ++ ++/** Compares two EC_GROUP objects ++ * \param a first EC_GROUP object ++ * \param b second EC_GROUP object ++ * \param ctx BN_CTX object (optional) ++ * \return 0 if both groups are equal and 1 otherwise ++ */ ++int EC_GROUP_cmp(const EC_GROUP *a, const EC_GROUP *b, BN_CTX *ctx); ++ ++/* EC_GROUP_new_GF*() calls EC_GROUP_new() and EC_GROUP_set_GF*() ++ * after choosing an appropriate EC_METHOD */ ++ ++/** Creates a new EC_GROUP object with the specified parameters defined ++ * over GFp (defined by the equation y^2 = x^3 + a*x + b) ++ * \param p BIGNUM with the prime number ++ * \param a BIGNUM with the parameter a of the equation ++ * \param b BIGNUM with the parameter b of the equation ++ * \param ctx BN_CTX object (optional) ++ * \return newly created EC_GROUP object with the specified parameters ++ */ ++EC_GROUP *EC_GROUP_new_curve_GFp(const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); ++ ++/** Creates a new EC_GROUP object with the specified parameters defined ++ * over GF2m (defined by the equation y^2 + x*y = x^3 + a*x^2 + b) ++ * \param p BIGNUM with the polynomial defining the underlying field ++ * \param a BIGNUM with the parameter a of the equation ++ * \param b BIGNUM with the parameter b of the equation ++ * \param ctx BN_CTX object (optional) ++ * \return newly created EC_GROUP object with the specified parameters ++ */ ++EC_GROUP *EC_GROUP_new_curve_GF2m(const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); ++ ++/** Creates a EC_GROUP object with a curve specified by a NID ++ * \param nid NID of the OID of the curve name ++ * \return newly created EC_GROUP object with specified curve or NULL ++ * if an error occurred ++ */ ++EC_GROUP *EC_GROUP_new_by_curve_name(int nid); ++ ++ ++/********************************************************************/ ++/* handling of internal curves */ ++/********************************************************************/ ++ ++typedef struct { ++ int nid; ++ const char *comment; ++ } EC_builtin_curve; ++ ++/* EC_builtin_curves(EC_builtin_curve *r, size_t size) returns number ++ * of all available curves or zero if a error occurred. ++ * In case r ist not zero nitems EC_builtin_curve structures ++ * are filled with the data of the first nitems internal groups */ ++size_t EC_get_builtin_curves(EC_builtin_curve *r, size_t nitems); ++ ++ ++/********************************************************************/ ++/* EC_POINT functions */ ++/********************************************************************/ ++ ++/** Creates a new EC_POINT object for the specified EC_GROUP ++ * \param group EC_GROUP the underlying EC_GROUP object ++ * \return newly created EC_POINT object or NULL if an error occurred ++ */ ++EC_POINT *EC_POINT_new(const EC_GROUP *group); ++ ++/** Frees a EC_POINT object ++ * \param point EC_POINT object to be freed ++ */ ++void EC_POINT_free(EC_POINT *point); ++ ++/** Clears and frees a EC_POINT object ++ * \param point EC_POINT object to be cleared and freed ++ */ ++void EC_POINT_clear_free(EC_POINT *point); ++ ++/** Copies EC_POINT object ++ * \param dst destination EC_POINT object ++ * \param src source EC_POINT object ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_POINT_copy(EC_POINT *dst, const EC_POINT *src); ++ ++/** Creates a new EC_POINT object and copies the content of the supplied ++ * EC_POINT ++ * \param src source EC_POINT object ++ * \param group underlying the EC_GROUP object ++ * \return newly created EC_POINT object or NULL if an error occurred ++ */ ++EC_POINT *EC_POINT_dup(const EC_POINT *src, const EC_GROUP *group); ++ ++/** Returns the EC_METHOD used in EC_POINT object ++ * \param point EC_POINT object ++ * \return the EC_METHOD used ++ */ ++const EC_METHOD *EC_POINT_method_of(const EC_POINT *point); ++ ++/** Sets a point to infinity (neutral element) ++ * \param group underlying EC_GROUP object ++ * \param point EC_POINT to set to infinity ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point); ++ ++/** Sets the jacobian projective coordinates of a EC_POINT over GFp ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param x BIGNUM with the x-coordinate ++ * \param y BIGNUM with the y-coordinate ++ * \param z BIGNUM with the z-coordinate ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP *group, EC_POINT *p, ++ const BIGNUM *x, const BIGNUM *y, const BIGNUM *z, BN_CTX *ctx); ++ ++/** Gets the jacobian projective coordinates of a EC_POINT over GFp ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param x BIGNUM for the x-coordinate ++ * \param y BIGNUM for the y-coordinate ++ * \param z BIGNUM for the z-coordinate ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group, ++ const EC_POINT *p, BIGNUM *x, BIGNUM *y, BIGNUM *z, BN_CTX *ctx); ++ ++/** Sets the affine coordinates of a EC_POINT over GFp ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param x BIGNUM with the x-coordinate ++ * \param y BIGNUM with the y-coordinate ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group, EC_POINT *p, ++ const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx); ++ ++/** Gets the affine coordinates of a EC_POINT over GFp ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param x BIGNUM for the x-coordinate ++ * \param y BIGNUM for the y-coordinate ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group, ++ const EC_POINT *p, BIGNUM *x, BIGNUM *y, BN_CTX *ctx); ++ ++/** Sets the x9.62 compressed coordinates of a EC_POINT over GFp ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param x BIGNUM with x-coordinate ++ * \param y_bit integer with the y-Bit (either 0 or 1) ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP *group, EC_POINT *p, ++ const BIGNUM *x, int y_bit, BN_CTX *ctx); ++ ++/** Sets the affine coordinates of a EC_POINT over GF2m ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param x BIGNUM with the x-coordinate ++ * \param y BIGNUM with the y-coordinate ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_POINT_set_affine_coordinates_GF2m(const EC_GROUP *group, EC_POINT *p, ++ const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx); ++ ++/** Gets the affine coordinates of a EC_POINT over GF2m ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param x BIGNUM for the x-coordinate ++ * \param y BIGNUM for the y-coordinate ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_POINT_get_affine_coordinates_GF2m(const EC_GROUP *group, ++ const EC_POINT *p, BIGNUM *x, BIGNUM *y, BN_CTX *ctx); ++ ++/** Sets the x9.62 compressed coordinates of a EC_POINT over GF2m ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param x BIGNUM with x-coordinate ++ * \param y_bit integer with the y-Bit (either 0 or 1) ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_POINT_set_compressed_coordinates_GF2m(const EC_GROUP *group, EC_POINT *p, ++ const BIGNUM *x, int y_bit, BN_CTX *ctx); ++ ++/** Encodes a EC_POINT object to a octet string ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param form point conversion form ++ * \param buf memory buffer for the result. If NULL the function returns ++ * required buffer size. ++ * \param len length of the memory buffer ++ * \param ctx BN_CTX object (optional) ++ * \return the length of the encoded octet string or 0 if an error occurred ++ */ ++size_t EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *p, ++ point_conversion_form_t form, ++ unsigned char *buf, size_t len, BN_CTX *ctx); ++ ++/** Decodes a EC_POINT from a octet string ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param buf memory buffer with the encoded ec point ++ * \param len length of the encoded ec point ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *p, ++ const unsigned char *buf, size_t len, BN_CTX *ctx); ++ ++/* other interfaces to point2oct/oct2point: */ ++BIGNUM *EC_POINT_point2bn(const EC_GROUP *, const EC_POINT *, ++ point_conversion_form_t form, BIGNUM *, BN_CTX *); ++EC_POINT *EC_POINT_bn2point(const EC_GROUP *, const BIGNUM *, ++ EC_POINT *, BN_CTX *); ++char *EC_POINT_point2hex(const EC_GROUP *, const EC_POINT *, ++ point_conversion_form_t form, BN_CTX *); ++EC_POINT *EC_POINT_hex2point(const EC_GROUP *, const char *, ++ EC_POINT *, BN_CTX *); ++ ++ ++/********************************************************************/ ++/* functions for doing EC_POINT arithmetic */ ++/********************************************************************/ ++ ++/** Computes the sum of two EC_POINT ++ * \param group underlying EC_GROUP object ++ * \param r EC_POINT object for the result (r = a + b) ++ * \param a EC_POINT object with the first summand ++ * \param b EC_POINT object with the second summand ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx); ++ ++/** Computes the double of a EC_POINT ++ * \param group underlying EC_GROUP object ++ * \param r EC_POINT object for the result (r = 2 * a) ++ * \param a EC_POINT object ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, BN_CTX *ctx); ++ ++/** Computes the inverse of a EC_POINT ++ * \param group underlying EC_GROUP object ++ * \param a EC_POINT object to be inverted (it's used for the result as well) ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx); ++ ++/** Checks whether the point is the neutral element of the group ++ * \param group the underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \return 1 if the point is the neutral element and 0 otherwise ++ */ ++int EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *p); ++ ++/** Checks whether the point is on the curve ++ * \param group underlying EC_GROUP object ++ * \param point EC_POINT object to check ++ * \param ctx BN_CTX object (optional) ++ * \return 1 if point if on the curve and 0 otherwise ++ */ ++int EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point, BN_CTX *ctx); ++ ++/** Compares two EC_POINTs ++ * \param group underlying EC_GROUP object ++ * \param a first EC_POINT object ++ * \param b second EC_POINT object ++ * \param ctx BN_CTX object (optional) ++ * \return 0 if both points are equal and a value != 0 otherwise ++ */ ++int EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx); ++ ++int EC_POINT_make_affine(const EC_GROUP *, EC_POINT *, BN_CTX *); ++int EC_POINTs_make_affine(const EC_GROUP *, size_t num, EC_POINT *[], BN_CTX *); ++ ++/** Computes r = generator * n sum_{i=0}^num p[i] * m[i] ++ * \param group underlying EC_GROUP object ++ * \param r EC_POINT object for the result ++ * \param n BIGNUM with the multiplier for the group generator (optional) ++ * \param num number futher summands ++ * \param p array of size num of EC_POINT objects ++ * \param m array of size num of BIGNUM objects ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_POINTs_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *n, size_t num, const EC_POINT *p[], const BIGNUM *m[], BN_CTX *ctx); ++ ++/** Computes r = generator * n + q * m ++ * \param group underlying EC_GROUP object ++ * \param r EC_POINT object for the result ++ * \param n BIGNUM with the multiplier for the group generator (optional) ++ * \param q EC_POINT object with the first factor of the second summand ++ * \param m BIGNUM with the second factor of the second summand ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_POINT_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *n, const EC_POINT *q, const BIGNUM *m, BN_CTX *ctx); ++ ++/** Stores multiples of generator for faster point multiplication ++ * \param group EC_GROUP object ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occured ++ */ ++int EC_GROUP_precompute_mult(EC_GROUP *group, BN_CTX *ctx); ++ ++/** Reports whether a precomputation has been done ++ * \param group EC_GROUP object ++ * \return 1 if a pre-computation has been done and 0 otherwise ++ */ ++int EC_GROUP_have_precompute_mult(const EC_GROUP *group); ++ ++ ++/********************************************************************/ ++/* ASN1 stuff */ ++/********************************************************************/ ++ ++/* EC_GROUP_get_basis_type() returns the NID of the basis type ++ * used to represent the field elements */ ++int EC_GROUP_get_basis_type(const EC_GROUP *); ++int EC_GROUP_get_trinomial_basis(const EC_GROUP *, unsigned int *k); ++int EC_GROUP_get_pentanomial_basis(const EC_GROUP *, unsigned int *k1, ++ unsigned int *k2, unsigned int *k3); ++ ++#define OPENSSL_EC_NAMED_CURVE 0x001 ++ ++typedef struct ecpk_parameters_st ECPKPARAMETERS; ++ ++EC_GROUP *d2i_ECPKParameters(EC_GROUP **, const unsigned char **in, long len); ++int i2d_ECPKParameters(const EC_GROUP *, unsigned char **out); ++ ++#define d2i_ECPKParameters_bio(bp,x) ASN1_d2i_bio_of(EC_GROUP,NULL,d2i_ECPKParameters,bp,x) ++#define i2d_ECPKParameters_bio(bp,x) ASN1_i2d_bio_of_const(EC_GROUP,i2d_ECPKParameters,bp,x) ++#define d2i_ECPKParameters_fp(fp,x) (EC_GROUP *)ASN1_d2i_fp(NULL, \ ++ (char *(*)())d2i_ECPKParameters,(fp),(unsigned char **)(x)) ++#define i2d_ECPKParameters_fp(fp,x) ASN1_i2d_fp(i2d_ECPKParameters,(fp), \ ++ (unsigned char *)(x)) ++ ++#ifndef OPENSSL_NO_BIO ++int ECPKParameters_print(BIO *bp, const EC_GROUP *x, int off); ++#endif ++#ifndef OPENSSL_NO_FP_API ++int ECPKParameters_print_fp(FILE *fp, const EC_GROUP *x, int off); ++#endif ++ ++ ++/********************************************************************/ ++/* EC_KEY functions */ ++/********************************************************************/ ++ ++typedef struct ec_key_st EC_KEY; ++ ++/* some values for the encoding_flag */ ++#define EC_PKEY_NO_PARAMETERS 0x001 ++#define EC_PKEY_NO_PUBKEY 0x002 ++ ++/** Creates a new EC_KEY object. ++ * \return EC_KEY object or NULL if an error occurred. ++ */ ++EC_KEY *EC_KEY_new(void); ++ ++/** Creates a new EC_KEY object using a named curve as underlying ++ * EC_GROUP object. ++ * \param nid NID of the named curve. ++ * \return EC_KEY object or NULL if an error occurred. ++ */ ++EC_KEY *EC_KEY_new_by_curve_name(int nid); ++ ++/** Frees a EC_KEY object. ++ * \param key EC_KEY object to be freed. ++ */ ++void EC_KEY_free(EC_KEY *key); ++ ++/** Copies a EC_KEY object. ++ * \param dst destination EC_KEY object ++ * \param src src EC_KEY object ++ * \return dst or NULL if an error occurred. ++ */ ++EC_KEY *EC_KEY_copy(EC_KEY *dst, const EC_KEY *src); ++ ++/** Creates a new EC_KEY object and copies the content from src to it. ++ * \param src the source EC_KEY object ++ * \return newly created EC_KEY object or NULL if an error occurred. ++ */ ++EC_KEY *EC_KEY_dup(const EC_KEY *src); ++ ++/** Increases the internal reference count of a EC_KEY object. ++ * \param key EC_KEY object ++ * \return 1 on success and 0 if an error occurred. ++ */ ++int EC_KEY_up_ref(EC_KEY *key); ++ ++/** Returns the EC_GROUP object of a EC_KEY object ++ * \param key EC_KEY object ++ * \return the EC_GROUP object (possibly NULL). ++ */ ++const EC_GROUP *EC_KEY_get0_group(const EC_KEY *key); ++ ++/** Sets the EC_GROUP of a EC_KEY object. ++ * \param key EC_KEY object ++ * \param group EC_GROUP to use in the EC_KEY object (note: the EC_KEY ++ * object will use an own copy of the EC_GROUP). ++ * \return 1 on success and 0 if an error occurred. ++ */ ++int EC_KEY_set_group(EC_KEY *key, const EC_GROUP *group); ++ ++/** Returns the private key of a EC_KEY object. ++ * \param key EC_KEY object ++ * \return a BIGNUM with the private key (possibly NULL). ++ */ ++const BIGNUM *EC_KEY_get0_private_key(const EC_KEY *key); ++ ++/** Sets the private key of a EC_KEY object. ++ * \param key EC_KEY object ++ * \param prv BIGNUM with the private key (note: the EC_KEY object ++ * will use an own copy of the BIGNUM). ++ * \return 1 on success and 0 if an error occurred. ++ */ ++int EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *prv); ++ ++/** Returns the public key of a EC_KEY object. ++ * \param key the EC_KEY object ++ * \return a EC_POINT object with the public key (possibly NULL) ++ */ ++const EC_POINT *EC_KEY_get0_public_key(const EC_KEY *key); ++ ++/** Sets the public key of a EC_KEY object. ++ * \param key EC_KEY object ++ * \param pub EC_POINT object with the public key (note: the EC_KEY object ++ * will use an own copy of the EC_POINT object). ++ * \return 1 on success and 0 if an error occurred. ++ */ ++int EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub); ++ ++unsigned EC_KEY_get_enc_flags(const EC_KEY *key); ++void EC_KEY_set_enc_flags(EC_KEY *, unsigned int); ++point_conversion_form_t EC_KEY_get_conv_form(const EC_KEY *); ++void EC_KEY_set_conv_form(EC_KEY *, point_conversion_form_t); ++/* functions to set/get method specific data */ ++void *EC_KEY_get_key_method_data(EC_KEY *, ++ void *(*dup_func)(void *), void (*free_func)(void *), void (*clear_free_func)(void *)); ++void EC_KEY_insert_key_method_data(EC_KEY *, void *data, ++ void *(*dup_func)(void *), void (*free_func)(void *), void (*clear_free_func)(void *)); ++/* wrapper functions for the underlying EC_GROUP object */ ++void EC_KEY_set_asn1_flag(EC_KEY *, int); ++ ++/** Creates a table of pre-computed multiples of the generator to ++ * accelerate further EC_KEY operations. ++ * \param key EC_KEY object ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred. ++ */ ++int EC_KEY_precompute_mult(EC_KEY *key, BN_CTX *ctx); ++ ++/** Creates a new ec private (and optional a new public) key. ++ * \param key EC_KEY object ++ * \return 1 on success and 0 if an error occurred. ++ */ ++int EC_KEY_generate_key(EC_KEY *key); ++ ++/** Verifies that a private and/or public key is valid. ++ * \param key the EC_KEY object ++ * \return 1 on success and 0 otherwise. ++ */ ++int EC_KEY_check_key(const EC_KEY *key); ++ ++ ++/********************************************************************/ ++/* de- and encoding functions for SEC1 ECPrivateKey */ ++/********************************************************************/ ++ ++/** Decodes a private key from a memory buffer. ++ * \param key a pointer to a EC_KEY object which should be used (or NULL) ++ * \param in pointer to memory with the DER encoded private key ++ * \param len length of the DER encoded private key ++ * \return the decoded private key or NULL if an error occurred. ++ */ ++EC_KEY *d2i_ECPrivateKey(EC_KEY **key, const unsigned char **in, long len); ++ ++/** Encodes a private key object and stores the result in a buffer. ++ * \param key the EC_KEY object to encode ++ * \param out the buffer for the result (if NULL the function returns number ++ * of bytes needed). ++ * \return 1 on success and 0 if an error occurred. ++ */ ++int i2d_ECPrivateKey(EC_KEY *key, unsigned char **out); ++ ++ ++/********************************************************************/ ++/* de- and encoding functions for EC parameters */ ++/********************************************************************/ ++ ++/** Decodes ec parameter from a memory buffer. ++ * \param key a pointer to a EC_KEY object which should be used (or NULL) ++ * \param in pointer to memory with the DER encoded ec parameters ++ * \param len length of the DER encoded ec parameters ++ * \return a EC_KEY object with the decoded parameters or NULL if an error ++ * occurred. ++ */ ++EC_KEY *d2i_ECParameters(EC_KEY **key, const unsigned char **in, long len); ++ ++/** Encodes ec parameter and stores the result in a buffer. ++ * \param key the EC_KEY object with ec paramters to encode ++ * \param out the buffer for the result (if NULL the function returns number ++ * of bytes needed). ++ * \return 1 on success and 0 if an error occurred. ++ */ ++int i2d_ECParameters(EC_KEY *key, unsigned char **out); ++ ++ ++/********************************************************************/ ++/* de- and encoding functions for EC public key */ ++/* (octet string, not DER -- hence 'o2i' and 'i2o') */ ++/********************************************************************/ ++ ++/** Decodes a ec public key from a octet string. ++ * \param key a pointer to a EC_KEY object which should be used ++ * \param in memory buffer with the encoded public key ++ * \param len length of the encoded public key ++ * \return EC_KEY object with decoded public key or NULL if an error ++ * occurred. ++ */ ++EC_KEY *o2i_ECPublicKey(EC_KEY **key, const unsigned char **in, long len); ++ ++/** Encodes a ec public key in an octet string. ++ * \param key the EC_KEY object with the public key ++ * \param out the buffer for the result (if NULL the function returns number ++ * of bytes needed). ++ * \return 1 on success and 0 if an error occurred ++ */ ++int i2o_ECPublicKey(EC_KEY *key, unsigned char **out); ++ ++#ifndef OPENSSL_NO_BIO ++/** Prints out the ec parameters on human readable form. ++ * \param bp BIO object to which the information is printed ++ * \param key EC_KEY object ++ * \return 1 on success and 0 if an error occurred ++ */ ++int ECParameters_print(BIO *bp, const EC_KEY *key); ++ ++/** Prints out the contents of a EC_KEY object ++ * \param bp BIO object to which the information is printed ++ * \param key EC_KEY object ++ * \param off line offset ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_KEY_print(BIO *bp, const EC_KEY *key, int off); ++ ++#endif ++#ifndef OPENSSL_NO_FP_API ++/** Prints out the ec parameters on human readable form. ++ * \param fp file descriptor to which the information is printed ++ * \param key EC_KEY object ++ * \return 1 on success and 0 if an error occurred ++ */ ++int ECParameters_print_fp(FILE *fp, const EC_KEY *key); ++ ++/** Prints out the contents of a EC_KEY object ++ * \param fp file descriptor to which the information is printed ++ * \param key EC_KEY object ++ * \param off line offset ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_KEY_print_fp(FILE *fp, const EC_KEY *key, int off); ++ ++#endif ++ ++#define ECParameters_dup(x) ASN1_dup_of(EC_KEY,i2d_ECParameters,d2i_ECParameters,x) ++ ++#ifndef __cplusplus ++#if defined(__SUNPRO_C) ++# if __SUNPRO_C >= 0x520 ++# pragma error_messages (default,E_ARRAY_OF_INCOMPLETE_NONAME,E_ARRAY_OF_INCOMPLETE) ++# endif ++# endif ++#endif ++ ++#define EVP_PKEY_CTX_set_ec_paramgen_curve_nid(ctx, nid) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, EVP_PKEY_OP_PARAMGEN, \ ++ EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID, nid, NULL) ++ ++ ++#define EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID (EVP_PKEY_ALG_CTRL + 1) ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_EC_strings(void); ++ ++/* Error codes for the EC functions. */ ++ ++/* Function codes. */ ++#define EC_F_COMPUTE_WNAF 143 ++#define EC_F_D2I_ECPARAMETERS 144 ++#define EC_F_D2I_ECPKPARAMETERS 145 ++#define EC_F_D2I_ECPRIVATEKEY 146 ++#define EC_F_DO_EC_KEY_PRINT 221 ++#define EC_F_ECKEY_PARAM2TYPE 223 ++#define EC_F_ECKEY_PARAM_DECODE 212 ++#define EC_F_ECKEY_PRIV_DECODE 213 ++#define EC_F_ECKEY_PRIV_ENCODE 214 ++#define EC_F_ECKEY_PUB_DECODE 215 ++#define EC_F_ECKEY_PUB_ENCODE 216 ++#define EC_F_ECKEY_TYPE2PARAM 220 ++#define EC_F_ECPARAMETERS_PRINT 147 ++#define EC_F_ECPARAMETERS_PRINT_FP 148 ++#define EC_F_ECPKPARAMETERS_PRINT 149 ++#define EC_F_ECPKPARAMETERS_PRINT_FP 150 ++#define EC_F_ECP_NIST_MOD_192 203 ++#define EC_F_ECP_NIST_MOD_224 204 ++#define EC_F_ECP_NIST_MOD_256 205 ++#define EC_F_ECP_NIST_MOD_521 206 ++#define EC_F_EC_ASN1_GROUP2CURVE 153 ++#define EC_F_EC_ASN1_GROUP2FIELDID 154 ++#define EC_F_EC_ASN1_GROUP2PARAMETERS 155 ++#define EC_F_EC_ASN1_GROUP2PKPARAMETERS 156 ++#define EC_F_EC_ASN1_PARAMETERS2GROUP 157 ++#define EC_F_EC_ASN1_PKPARAMETERS2GROUP 158 ++#define EC_F_EC_EX_DATA_SET_DATA 211 ++#define EC_F_EC_GF2M_MONTGOMERY_POINT_MULTIPLY 208 ++#define EC_F_EC_GF2M_SIMPLE_GROUP_CHECK_DISCRIMINANT 159 ++#define EC_F_EC_GF2M_SIMPLE_GROUP_SET_CURVE 195 ++#define EC_F_EC_GF2M_SIMPLE_OCT2POINT 160 ++#define EC_F_EC_GF2M_SIMPLE_POINT2OCT 161 ++#define EC_F_EC_GF2M_SIMPLE_POINT_GET_AFFINE_COORDINATES 162 ++#define EC_F_EC_GF2M_SIMPLE_POINT_SET_AFFINE_COORDINATES 163 ++#define EC_F_EC_GF2M_SIMPLE_SET_COMPRESSED_COORDINATES 164 ++#define EC_F_EC_GFP_MONT_FIELD_DECODE 133 ++#define EC_F_EC_GFP_MONT_FIELD_ENCODE 134 ++#define EC_F_EC_GFP_MONT_FIELD_MUL 131 ++#define EC_F_EC_GFP_MONT_FIELD_SET_TO_ONE 209 ++#define EC_F_EC_GFP_MONT_FIELD_SQR 132 ++#define EC_F_EC_GFP_MONT_GROUP_SET_CURVE 189 ++#define EC_F_EC_GFP_MONT_GROUP_SET_CURVE_GFP 135 ++#define EC_F_EC_GFP_NIST_FIELD_MUL 200 ++#define EC_F_EC_GFP_NIST_FIELD_SQR 201 ++#define EC_F_EC_GFP_NIST_GROUP_SET_CURVE 202 ++#define EC_F_EC_GFP_SIMPLE_GROUP_CHECK_DISCRIMINANT 165 ++#define EC_F_EC_GFP_SIMPLE_GROUP_SET_CURVE 166 ++#define EC_F_EC_GFP_SIMPLE_GROUP_SET_CURVE_GFP 100 ++#define EC_F_EC_GFP_SIMPLE_GROUP_SET_GENERATOR 101 ++#define EC_F_EC_GFP_SIMPLE_MAKE_AFFINE 102 ++#define EC_F_EC_GFP_SIMPLE_OCT2POINT 103 ++#define EC_F_EC_GFP_SIMPLE_POINT2OCT 104 ++#define EC_F_EC_GFP_SIMPLE_POINTS_MAKE_AFFINE 137 ++#define EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES 167 ++#define EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES_GFP 105 ++#define EC_F_EC_GFP_SIMPLE_POINT_SET_AFFINE_COORDINATES 168 ++#define EC_F_EC_GFP_SIMPLE_POINT_SET_AFFINE_COORDINATES_GFP 128 ++#define EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES 169 ++#define EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES_GFP 129 ++#define EC_F_EC_GROUP_CHECK 170 ++#define EC_F_EC_GROUP_CHECK_DISCRIMINANT 171 ++#define EC_F_EC_GROUP_COPY 106 ++#define EC_F_EC_GROUP_GET0_GENERATOR 139 ++#define EC_F_EC_GROUP_GET_COFACTOR 140 ++#define EC_F_EC_GROUP_GET_CURVE_GF2M 172 ++#define EC_F_EC_GROUP_GET_CURVE_GFP 130 ++#define EC_F_EC_GROUP_GET_DEGREE 173 ++#define EC_F_EC_GROUP_GET_ORDER 141 ++#define EC_F_EC_GROUP_GET_PENTANOMIAL_BASIS 193 ++#define EC_F_EC_GROUP_GET_TRINOMIAL_BASIS 194 ++#define EC_F_EC_GROUP_NEW 108 ++#define EC_F_EC_GROUP_NEW_BY_CURVE_NAME 174 ++#define EC_F_EC_GROUP_NEW_FROM_DATA 175 ++#define EC_F_EC_GROUP_PRECOMPUTE_MULT 142 ++#define EC_F_EC_GROUP_SET_CURVE_GF2M 176 ++#define EC_F_EC_GROUP_SET_CURVE_GFP 109 ++#define EC_F_EC_GROUP_SET_EXTRA_DATA 110 ++#define EC_F_EC_GROUP_SET_GENERATOR 111 ++#define EC_F_EC_KEY_CHECK_KEY 177 ++#define EC_F_EC_KEY_COPY 178 ++#define EC_F_EC_KEY_GENERATE_KEY 179 ++#define EC_F_EC_KEY_NEW 182 ++#define EC_F_EC_KEY_PRINT 180 ++#define EC_F_EC_KEY_PRINT_FP 181 ++#define EC_F_EC_POINTS_MAKE_AFFINE 136 ++#define EC_F_EC_POINT_ADD 112 ++#define EC_F_EC_POINT_CMP 113 ++#define EC_F_EC_POINT_COPY 114 ++#define EC_F_EC_POINT_DBL 115 ++#define EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M 183 ++#define EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP 116 ++#define EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP 117 ++#define EC_F_EC_POINT_INVERT 210 ++#define EC_F_EC_POINT_IS_AT_INFINITY 118 ++#define EC_F_EC_POINT_IS_ON_CURVE 119 ++#define EC_F_EC_POINT_MAKE_AFFINE 120 ++#define EC_F_EC_POINT_MUL 184 ++#define EC_F_EC_POINT_NEW 121 ++#define EC_F_EC_POINT_OCT2POINT 122 ++#define EC_F_EC_POINT_POINT2OCT 123 ++#define EC_F_EC_POINT_SET_AFFINE_COORDINATES_GF2M 185 ++#define EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP 124 ++#define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GF2M 186 ++#define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP 125 ++#define EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP 126 ++#define EC_F_EC_POINT_SET_TO_INFINITY 127 ++#define EC_F_EC_PRE_COMP_DUP 207 ++#define EC_F_EC_PRE_COMP_NEW 196 ++#define EC_F_EC_WNAF_MUL 187 ++#define EC_F_EC_WNAF_PRECOMPUTE_MULT 188 ++#define EC_F_I2D_ECPARAMETERS 190 ++#define EC_F_I2D_ECPKPARAMETERS 191 ++#define EC_F_I2D_ECPRIVATEKEY 192 ++#define EC_F_I2O_ECPUBLICKEY 151 ++#define EC_F_O2I_ECPUBLICKEY 152 ++#define EC_F_OLD_EC_PRIV_DECODE 222 ++#define EC_F_PKEY_EC_CTRL 197 ++#define EC_F_PKEY_EC_CTRL_STR 198 ++#define EC_F_PKEY_EC_DERIVE 217 ++#define EC_F_PKEY_EC_KEYGEN 199 ++#define EC_F_PKEY_EC_PARAMGEN 219 ++#define EC_F_PKEY_EC_SIGN 218 ++ ++/* Reason codes. */ ++#define EC_R_ASN1_ERROR 115 ++#define EC_R_ASN1_UNKNOWN_FIELD 116 ++#define EC_R_BUFFER_TOO_SMALL 100 ++#define EC_R_D2I_ECPKPARAMETERS_FAILURE 117 ++#define EC_R_DECODE_ERROR 142 ++#define EC_R_DISCRIMINANT_IS_ZERO 118 ++#define EC_R_EC_GROUP_NEW_BY_NAME_FAILURE 119 ++#define EC_R_FIELD_TOO_LARGE 143 ++#define EC_R_GROUP2PKPARAMETERS_FAILURE 120 ++#define EC_R_I2D_ECPKPARAMETERS_FAILURE 121 ++#define EC_R_INCOMPATIBLE_OBJECTS 101 ++#define EC_R_INVALID_ARGUMENT 112 ++#define EC_R_INVALID_COMPRESSED_POINT 110 ++#define EC_R_INVALID_COMPRESSION_BIT 109 ++#define EC_R_INVALID_CURVE 141 ++#define EC_R_INVALID_DIGEST_TYPE 138 ++#define EC_R_INVALID_ENCODING 102 ++#define EC_R_INVALID_FIELD 103 ++#define EC_R_INVALID_FORM 104 ++#define EC_R_INVALID_GROUP_ORDER 122 ++#define EC_R_INVALID_PENTANOMIAL_BASIS 132 ++#define EC_R_INVALID_PRIVATE_KEY 123 ++#define EC_R_INVALID_TRINOMIAL_BASIS 137 ++#define EC_R_KEYS_NOT_SET 140 ++#define EC_R_MISSING_PARAMETERS 124 ++#define EC_R_MISSING_PRIVATE_KEY 125 ++#define EC_R_NOT_A_NIST_PRIME 135 ++#define EC_R_NOT_A_SUPPORTED_NIST_PRIME 136 ++#define EC_R_NOT_IMPLEMENTED 126 ++#define EC_R_NOT_INITIALIZED 111 ++#define EC_R_NO_FIELD_MOD 133 ++#define EC_R_NO_PARAMETERS_SET 139 ++#define EC_R_PASSED_NULL_PARAMETER 134 ++#define EC_R_PKPARAMETERS2GROUP_FAILURE 127 ++#define EC_R_POINT_AT_INFINITY 106 ++#define EC_R_POINT_IS_NOT_ON_CURVE 107 ++#define EC_R_SLOT_FULL 108 ++#define EC_R_UNDEFINED_GENERATOR 113 ++#define EC_R_UNDEFINED_ORDER 128 ++#define EC_R_UNKNOWN_GROUP 129 ++#define EC_R_UNKNOWN_ORDER 114 ++#define EC_R_UNSUPPORTED_FIELD 131 ++#define EC_R_WRONG_ORDER 130 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/ecdh.h qt.patched/include/openssl/ecdh.h +--- qt.orig/include/openssl/ecdh.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/ecdh.h 2010-08-27 12:01:45.243284700 +0200 +@@ -0,0 +1,123 @@ ++/* crypto/ecdh/ecdh.h */ ++/* ==================================================================== ++ * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. ++ * ++ * The Elliptic Curve Public-Key Crypto Library (ECC Code) included ++ * herein is developed by SUN MICROSYSTEMS, INC., and is contributed ++ * to the OpenSSL project. ++ * ++ * The ECC Code is licensed pursuant to the OpenSSL open source ++ * license provided below. ++ * ++ * The ECDH software is originally written by Douglas Stebila of ++ * Sun Microsystems Laboratories. ++ * ++ */ ++/* ==================================================================== ++ * Copyright (c) 2000-2002 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * licensing@OpenSSL.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++#ifndef HEADER_ECDH_H ++#define HEADER_ECDH_H ++ ++#include ++ ++#ifdef OPENSSL_NO_ECDH ++#error ECDH is disabled. ++#endif ++ ++#include ++#include ++#ifndef OPENSSL_NO_DEPRECATED ++#include ++#endif ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++const ECDH_METHOD *ECDH_OpenSSL(void); ++ ++void ECDH_set_default_method(const ECDH_METHOD *); ++const ECDH_METHOD *ECDH_get_default_method(void); ++int ECDH_set_method(EC_KEY *, const ECDH_METHOD *); ++ ++int ECDH_compute_key(void *out, size_t outlen, const EC_POINT *pub_key, EC_KEY *ecdh, ++ void *(*KDF)(const void *in, size_t inlen, void *out, size_t *outlen)); ++ ++int ECDH_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new ++ *new_func, CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func); ++int ECDH_set_ex_data(EC_KEY *d, int idx, void *arg); ++void *ECDH_get_ex_data(EC_KEY *d, int idx); ++ ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_ECDH_strings(void); ++ ++/* Error codes for the ECDH functions. */ ++ ++/* Function codes. */ ++#define ECDH_F_ECDH_COMPUTE_KEY 100 ++#define ECDH_F_ECDH_DATA_NEW_METHOD 101 ++ ++/* Reason codes. */ ++#define ECDH_R_KDF_FAILED 102 ++#define ECDH_R_NO_PRIVATE_VALUE 100 ++#define ECDH_R_POINT_ARITHMETIC_FAILURE 101 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/ecdsa.h qt.patched/include/openssl/ecdsa.h +--- qt.orig/include/openssl/ecdsa.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/ecdsa.h 2010-08-27 12:01:45.243284700 +0200 +@@ -0,0 +1,258 @@ ++/* crypto/ecdsa/ecdsa.h */ ++/** ++ * \file crypto/ecdsa/ecdsa.h Include file for the OpenSSL ECDSA functions ++ * \author Written by Nils Larsch for the OpenSSL project ++ */ ++/* ==================================================================== ++ * Copyright (c) 2000-2005 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * licensing@OpenSSL.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++#ifndef HEADER_ECDSA_H ++#define HEADER_ECDSA_H ++ ++#include ++ ++#ifdef OPENSSL_NO_ECDSA ++#error ECDSA is disabled. ++#endif ++ ++#include ++#include ++#ifndef OPENSSL_NO_DEPRECATED ++#include ++#endif ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++typedef struct ECDSA_SIG_st ++ { ++ BIGNUM *r; ++ BIGNUM *s; ++ } ECDSA_SIG; ++ ++/** Allocates and initialize a ECDSA_SIG structure ++ * \return pointer to a ECDSA_SIG structure or NULL if an error occurred ++ */ ++ECDSA_SIG *ECDSA_SIG_new(void); ++ ++/** frees a ECDSA_SIG structure ++ * \param sig pointer to the ECDSA_SIG structure ++ */ ++void ECDSA_SIG_free(ECDSA_SIG *sig); ++ ++/** DER encode content of ECDSA_SIG object (note: this function modifies *pp ++ * (*pp += length of the DER encoded signature)). ++ * \param sig pointer to the ECDSA_SIG object ++ * \param pp pointer to a unsigned char pointer for the output or NULL ++ * \return the length of the DER encoded ECDSA_SIG object or 0 ++ */ ++int i2d_ECDSA_SIG(const ECDSA_SIG *sig, unsigned char **pp); ++ ++/** Decodes a DER encoded ECDSA signature (note: this function changes *pp ++ * (*pp += len)). ++ * \param sig pointer to ECDSA_SIG pointer (may be NULL) ++ * \param pp memory buffer with the DER encoded signature ++ * \param len length of the buffer ++ * \return pointer to the decoded ECDSA_SIG structure (or NULL) ++ */ ++ECDSA_SIG *d2i_ECDSA_SIG(ECDSA_SIG **sig, const unsigned char **pp, long len); ++ ++/** Computes the ECDSA signature of the given hash value using ++ * the supplied private key and returns the created signature. ++ * \param dgst pointer to the hash value ++ * \param dgst_len length of the hash value ++ * \param eckey EC_KEY object containing a private EC key ++ * \return pointer to a ECDSA_SIG structure or NULL if an error occurred ++ */ ++ECDSA_SIG *ECDSA_do_sign(const unsigned char *dgst,int dgst_len,EC_KEY *eckey); ++ ++/** Computes ECDSA signature of a given hash value using the supplied ++ * private key (note: sig must point to ECDSA_size(eckey) bytes of memory). ++ * \param dgst pointer to the hash value to sign ++ * \param dgstlen length of the hash value ++ * \param kinv BIGNUM with a pre-computed inverse k (optional) ++ * \param rp BIGNUM with a pre-computed rp value (optioanl), ++ * see ECDSA_sign_setup ++ * \param eckey EC_KEY object containing a private EC key ++ * \return pointer to a ECDSA_SIG structure or NULL if an error occurred ++ */ ++ECDSA_SIG *ECDSA_do_sign_ex(const unsigned char *dgst, int dgstlen, ++ const BIGNUM *kinv, const BIGNUM *rp, EC_KEY *eckey); ++ ++/** Verifies that the supplied signature is a valid ECDSA ++ * signature of the supplied hash value using the supplied public key. ++ * \param dgst pointer to the hash value ++ * \param dgst_len length of the hash value ++ * \param sig ECDSA_SIG structure ++ * \param eckey EC_KEY object containing a public EC key ++ * \return 1 if the signature is valid, 0 if the signature is invalid ++ * and -1 on error ++ */ ++int ECDSA_do_verify(const unsigned char *dgst, int dgst_len, ++ const ECDSA_SIG *sig, EC_KEY* eckey); ++ ++const ECDSA_METHOD *ECDSA_OpenSSL(void); ++ ++/** Sets the default ECDSA method ++ * \param meth new default ECDSA_METHOD ++ */ ++void ECDSA_set_default_method(const ECDSA_METHOD *meth); ++ ++/** Returns the default ECDSA method ++ * \return pointer to ECDSA_METHOD structure containing the default method ++ */ ++const ECDSA_METHOD *ECDSA_get_default_method(void); ++ ++/** Sets method to be used for the ECDSA operations ++ * \param eckey EC_KEY object ++ * \param meth new method ++ * \return 1 on success and 0 otherwise ++ */ ++int ECDSA_set_method(EC_KEY *eckey, const ECDSA_METHOD *meth); ++ ++/** Returns the maximum length of the DER encoded signature ++ * \param eckey EC_KEY object ++ * \return numbers of bytes required for the DER encoded signature ++ */ ++int ECDSA_size(const EC_KEY *eckey); ++ ++/** Precompute parts of the signing operation ++ * \param eckey EC_KEY object containing a private EC key ++ * \param ctx BN_CTX object (optional) ++ * \param kinv BIGNUM pointer for the inverse of k ++ * \param rp BIGNUM pointer for x coordinate of k * generator ++ * \return 1 on success and 0 otherwise ++ */ ++int ECDSA_sign_setup(EC_KEY *eckey, BN_CTX *ctx, BIGNUM **kinv, ++ BIGNUM **rp); ++ ++/** Computes ECDSA signature of a given hash value using the supplied ++ * private key (note: sig must point to ECDSA_size(eckey) bytes of memory). ++ * \param type this parameter is ignored ++ * \param dgst pointer to the hash value to sign ++ * \param dgstlen length of the hash value ++ * \param sig memory for the DER encoded created signature ++ * \param siglen pointer to the length of the returned signature ++ * \param eckey EC_KEY object containing a private EC key ++ * \return 1 on success and 0 otherwise ++ */ ++int ECDSA_sign(int type, const unsigned char *dgst, int dgstlen, ++ unsigned char *sig, unsigned int *siglen, EC_KEY *eckey); ++ ++ ++/** Computes ECDSA signature of a given hash value using the supplied ++ * private key (note: sig must point to ECDSA_size(eckey) bytes of memory). ++ * \param type this parameter is ignored ++ * \param dgst pointer to the hash value to sign ++ * \param dgstlen length of the hash value ++ * \param sig buffer to hold the DER encoded signature ++ * \param siglen pointer to the length of the returned signature ++ * \param kinv BIGNUM with a pre-computed inverse k (optional) ++ * \param rp BIGNUM with a pre-computed rp value (optioanl), ++ * see ECDSA_sign_setup ++ * \param eckey EC_KEY object containing a private EC key ++ * \return 1 on success and 0 otherwise ++ */ ++int ECDSA_sign_ex(int type, const unsigned char *dgst, int dgstlen, ++ unsigned char *sig, unsigned int *siglen, const BIGNUM *kinv, ++ const BIGNUM *rp, EC_KEY *eckey); ++ ++/** Verifies that the given signature is valid ECDSA signature ++ * of the supplied hash value using the specified public key. ++ * \param type this parameter is ignored ++ * \param dgst pointer to the hash value ++ * \param dgstlen length of the hash value ++ * \param sig pointer to the DER encoded signature ++ * \param siglen length of the DER encoded signature ++ * \param eckey EC_KEY object containing a public EC key ++ * \return 1 if the signature is valid, 0 if the signature is invalid ++ * and -1 on error ++ */ ++int ECDSA_verify(int type, const unsigned char *dgst, int dgstlen, ++ const unsigned char *sig, int siglen, EC_KEY *eckey); ++ ++/* the standard ex_data functions */ ++int ECDSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new ++ *new_func, CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func); ++int ECDSA_set_ex_data(EC_KEY *d, int idx, void *arg); ++void *ECDSA_get_ex_data(EC_KEY *d, int idx); ++ ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_ECDSA_strings(void); ++ ++/* Error codes for the ECDSA functions. */ ++ ++/* Function codes. */ ++#define ECDSA_F_ECDSA_DATA_NEW_METHOD 100 ++#define ECDSA_F_ECDSA_DO_SIGN 101 ++#define ECDSA_F_ECDSA_DO_VERIFY 102 ++#define ECDSA_F_ECDSA_SIGN_SETUP 103 ++ ++/* Reason codes. */ ++#define ECDSA_R_BAD_SIGNATURE 100 ++#define ECDSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE 101 ++#define ECDSA_R_ERR_EC_LIB 102 ++#define ECDSA_R_MISSING_PARAMETERS 103 ++#define ECDSA_R_NEED_NEW_SETUP_VALUES 106 ++#define ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED 104 ++#define ECDSA_R_SIGNATURE_MALLOC_FAILED 105 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/engine.h qt.patched/include/openssl/engine.h +--- qt.orig/include/openssl/engine.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/engine.h 2010-08-27 12:01:45.258909100 +0200 +@@ -0,0 +1,830 @@ ++/* openssl/engine.h */ ++/* Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL ++ * project 2000. ++ */ ++/* ==================================================================== ++ * Copyright (c) 1999-2004 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * licensing@OpenSSL.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++/* ==================================================================== ++ * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. ++ * ECDH support in OpenSSL originally developed by ++ * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project. ++ */ ++ ++#ifndef HEADER_ENGINE_H ++#define HEADER_ENGINE_H ++ ++#include ++ ++#ifdef OPENSSL_NO_ENGINE ++#error ENGINE is disabled. ++#endif ++ ++#ifndef OPENSSL_NO_DEPRECATED ++#include ++#ifndef OPENSSL_NO_RSA ++#include ++#endif ++#ifndef OPENSSL_NO_DSA ++#include ++#endif ++#ifndef OPENSSL_NO_DH ++#include ++#endif ++#ifndef OPENSSL_NO_ECDH ++#include ++#endif ++#ifndef OPENSSL_NO_ECDSA ++#include ++#endif ++#include ++#include ++#include ++#endif ++ ++#include ++#include ++ ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* These flags are used to control combinations of algorithm (methods) ++ * by bitwise "OR"ing. */ ++#define ENGINE_METHOD_RSA (unsigned int)0x0001 ++#define ENGINE_METHOD_DSA (unsigned int)0x0002 ++#define ENGINE_METHOD_DH (unsigned int)0x0004 ++#define ENGINE_METHOD_RAND (unsigned int)0x0008 ++#define ENGINE_METHOD_ECDH (unsigned int)0x0010 ++#define ENGINE_METHOD_ECDSA (unsigned int)0x0020 ++#define ENGINE_METHOD_CIPHERS (unsigned int)0x0040 ++#define ENGINE_METHOD_DIGESTS (unsigned int)0x0080 ++#define ENGINE_METHOD_STORE (unsigned int)0x0100 ++#define ENGINE_METHOD_PKEY_METHS (unsigned int)0x0200 ++#define ENGINE_METHOD_PKEY_ASN1_METHS (unsigned int)0x0400 ++/* Obvious all-or-nothing cases. */ ++#define ENGINE_METHOD_ALL (unsigned int)0xFFFF ++#define ENGINE_METHOD_NONE (unsigned int)0x0000 ++ ++/* This(ese) flag(s) controls behaviour of the ENGINE_TABLE mechanism used ++ * internally to control registration of ENGINE implementations, and can be set ++ * by ENGINE_set_table_flags(). The "NOINIT" flag prevents attempts to ++ * initialise registered ENGINEs if they are not already initialised. */ ++#define ENGINE_TABLE_FLAG_NOINIT (unsigned int)0x0001 ++ ++/* ENGINE flags that can be set by ENGINE_set_flags(). */ ++/* #define ENGINE_FLAGS_MALLOCED 0x0001 */ /* Not used */ ++ ++/* This flag is for ENGINEs that wish to handle the various 'CMD'-related ++ * control commands on their own. Without this flag, ENGINE_ctrl() handles these ++ * control commands on behalf of the ENGINE using their "cmd_defns" data. */ ++#define ENGINE_FLAGS_MANUAL_CMD_CTRL (int)0x0002 ++ ++/* This flag is for ENGINEs who return new duplicate structures when found via ++ * "ENGINE_by_id()". When an ENGINE must store state (eg. if ENGINE_ctrl() ++ * commands are called in sequence as part of some stateful process like ++ * key-generation setup and execution), it can set this flag - then each attempt ++ * to obtain the ENGINE will result in it being copied into a new structure. ++ * Normally, ENGINEs don't declare this flag so ENGINE_by_id() just increments ++ * the existing ENGINE's structural reference count. */ ++#define ENGINE_FLAGS_BY_ID_COPY (int)0x0004 ++ ++/* ENGINEs can support their own command types, and these flags are used in ++ * ENGINE_CTRL_GET_CMD_FLAGS to indicate to the caller what kind of input each ++ * command expects. Currently only numeric and string input is supported. If a ++ * control command supports none of the _NUMERIC, _STRING, or _NO_INPUT options, ++ * then it is regarded as an "internal" control command - and not for use in ++ * config setting situations. As such, they're not available to the ++ * ENGINE_ctrl_cmd_string() function, only raw ENGINE_ctrl() access. Changes to ++ * this list of 'command types' should be reflected carefully in ++ * ENGINE_cmd_is_executable() and ENGINE_ctrl_cmd_string(). */ ++ ++/* accepts a 'long' input value (3rd parameter to ENGINE_ctrl) */ ++#define ENGINE_CMD_FLAG_NUMERIC (unsigned int)0x0001 ++/* accepts string input (cast from 'void*' to 'const char *', 4th parameter to ++ * ENGINE_ctrl) */ ++#define ENGINE_CMD_FLAG_STRING (unsigned int)0x0002 ++/* Indicates that the control command takes *no* input. Ie. the control command ++ * is unparameterised. */ ++#define ENGINE_CMD_FLAG_NO_INPUT (unsigned int)0x0004 ++/* Indicates that the control command is internal. This control command won't ++ * be shown in any output, and is only usable through the ENGINE_ctrl_cmd() ++ * function. */ ++#define ENGINE_CMD_FLAG_INTERNAL (unsigned int)0x0008 ++ ++/* NB: These 3 control commands are deprecated and should not be used. ENGINEs ++ * relying on these commands should compile conditional support for ++ * compatibility (eg. if these symbols are defined) but should also migrate the ++ * same functionality to their own ENGINE-specific control functions that can be ++ * "discovered" by calling applications. The fact these control commands ++ * wouldn't be "executable" (ie. usable by text-based config) doesn't change the ++ * fact that application code can find and use them without requiring per-ENGINE ++ * hacking. */ ++ ++/* These flags are used to tell the ctrl function what should be done. ++ * All command numbers are shared between all engines, even if some don't ++ * make sense to some engines. In such a case, they do nothing but return ++ * the error ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED. */ ++#define ENGINE_CTRL_SET_LOGSTREAM 1 ++#define ENGINE_CTRL_SET_PASSWORD_CALLBACK 2 ++#define ENGINE_CTRL_HUP 3 /* Close and reinitialise any ++ handles/connections etc. */ ++#define ENGINE_CTRL_SET_USER_INTERFACE 4 /* Alternative to callback */ ++#define ENGINE_CTRL_SET_CALLBACK_DATA 5 /* User-specific data, used ++ when calling the password ++ callback and the user ++ interface */ ++#define ENGINE_CTRL_LOAD_CONFIGURATION 6 /* Load a configuration, given ++ a string that represents a ++ file name or so */ ++#define ENGINE_CTRL_LOAD_SECTION 7 /* Load data from a given ++ section in the already loaded ++ configuration */ ++ ++/* These control commands allow an application to deal with an arbitrary engine ++ * in a dynamic way. Warn: Negative return values indicate errors FOR THESE ++ * COMMANDS because zero is used to indicate 'end-of-list'. Other commands, ++ * including ENGINE-specific command types, return zero for an error. ++ * ++ * An ENGINE can choose to implement these ctrl functions, and can internally ++ * manage things however it chooses - it does so by setting the ++ * ENGINE_FLAGS_MANUAL_CMD_CTRL flag (using ENGINE_set_flags()). Otherwise the ++ * ENGINE_ctrl() code handles this on the ENGINE's behalf using the cmd_defns ++ * data (set using ENGINE_set_cmd_defns()). This means an ENGINE's ctrl() ++ * handler need only implement its own commands - the above "meta" commands will ++ * be taken care of. */ ++ ++/* Returns non-zero if the supplied ENGINE has a ctrl() handler. If "not", then ++ * all the remaining control commands will return failure, so it is worth ++ * checking this first if the caller is trying to "discover" the engine's ++ * capabilities and doesn't want errors generated unnecessarily. */ ++#define ENGINE_CTRL_HAS_CTRL_FUNCTION 10 ++/* Returns a positive command number for the first command supported by the ++ * engine. Returns zero if no ctrl commands are supported. */ ++#define ENGINE_CTRL_GET_FIRST_CMD_TYPE 11 ++/* The 'long' argument specifies a command implemented by the engine, and the ++ * return value is the next command supported, or zero if there are no more. */ ++#define ENGINE_CTRL_GET_NEXT_CMD_TYPE 12 ++/* The 'void*' argument is a command name (cast from 'const char *'), and the ++ * return value is the command that corresponds to it. */ ++#define ENGINE_CTRL_GET_CMD_FROM_NAME 13 ++/* The next two allow a command to be converted into its corresponding string ++ * form. In each case, the 'long' argument supplies the command. In the NAME_LEN ++ * case, the return value is the length of the command name (not counting a ++ * trailing EOL). In the NAME case, the 'void*' argument must be a string buffer ++ * large enough, and it will be populated with the name of the command (WITH a ++ * trailing EOL). */ ++#define ENGINE_CTRL_GET_NAME_LEN_FROM_CMD 14 ++#define ENGINE_CTRL_GET_NAME_FROM_CMD 15 ++/* The next two are similar but give a "short description" of a command. */ ++#define ENGINE_CTRL_GET_DESC_LEN_FROM_CMD 16 ++#define ENGINE_CTRL_GET_DESC_FROM_CMD 17 ++/* With this command, the return value is the OR'd combination of ++ * ENGINE_CMD_FLAG_*** values that indicate what kind of input a given ++ * engine-specific ctrl command expects. */ ++#define ENGINE_CTRL_GET_CMD_FLAGS 18 ++ ++/* ENGINE implementations should start the numbering of their own control ++ * commands from this value. (ie. ENGINE_CMD_BASE, ENGINE_CMD_BASE + 1, etc). */ ++#define ENGINE_CMD_BASE 200 ++ ++/* NB: These 2 nCipher "chil" control commands are deprecated, and their ++ * functionality is now available through ENGINE-specific control commands ++ * (exposed through the above-mentioned 'CMD'-handling). Code using these 2 ++ * commands should be migrated to the more general command handling before these ++ * are removed. */ ++ ++/* Flags specific to the nCipher "chil" engine */ ++#define ENGINE_CTRL_CHIL_SET_FORKCHECK 100 ++ /* Depending on the value of the (long)i argument, this sets or ++ * unsets the SimpleForkCheck flag in the CHIL API to enable or ++ * disable checking and workarounds for applications that fork(). ++ */ ++#define ENGINE_CTRL_CHIL_NO_LOCKING 101 ++ /* This prevents the initialisation function from providing mutex ++ * callbacks to the nCipher library. */ ++ ++/* If an ENGINE supports its own specific control commands and wishes the ++ * framework to handle the above 'ENGINE_CMD_***'-manipulation commands on its ++ * behalf, it should supply a null-terminated array of ENGINE_CMD_DEFN entries ++ * to ENGINE_set_cmd_defns(). It should also implement a ctrl() handler that ++ * supports the stated commands (ie. the "cmd_num" entries as described by the ++ * array). NB: The array must be ordered in increasing order of cmd_num. ++ * "null-terminated" means that the last ENGINE_CMD_DEFN element has cmd_num set ++ * to zero and/or cmd_name set to NULL. */ ++typedef struct ENGINE_CMD_DEFN_st ++ { ++ unsigned int cmd_num; /* The command number */ ++ const char *cmd_name; /* The command name itself */ ++ const char *cmd_desc; /* A short description of the command */ ++ unsigned int cmd_flags; /* The input the command expects */ ++ } ENGINE_CMD_DEFN; ++ ++/* Generic function pointer */ ++typedef int (*ENGINE_GEN_FUNC_PTR)(void); ++/* Generic function pointer taking no arguments */ ++typedef int (*ENGINE_GEN_INT_FUNC_PTR)(ENGINE *); ++/* Specific control function pointer */ ++typedef int (*ENGINE_CTRL_FUNC_PTR)(ENGINE *, int, long, void *, void (*f)(void)); ++/* Generic load_key function pointer */ ++typedef EVP_PKEY * (*ENGINE_LOAD_KEY_PTR)(ENGINE *, const char *, ++ UI_METHOD *ui_method, void *callback_data); ++typedef int (*ENGINE_SSL_CLIENT_CERT_PTR)(ENGINE *, SSL *ssl, ++ STACK_OF(X509_NAME) *ca_dn, X509 **pcert, EVP_PKEY **pkey, ++ STACK_OF(X509) **pother, UI_METHOD *ui_method, void *callback_data); ++/* These callback types are for an ENGINE's handler for cipher and digest logic. ++ * These handlers have these prototypes; ++ * int foo(ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid); ++ * int foo(ENGINE *e, const EVP_MD **digest, const int **nids, int nid); ++ * Looking at how to implement these handlers in the case of cipher support, if ++ * the framework wants the EVP_CIPHER for 'nid', it will call; ++ * foo(e, &p_evp_cipher, NULL, nid); (return zero for failure) ++ * If the framework wants a list of supported 'nid's, it will call; ++ * foo(e, NULL, &p_nids, 0); (returns number of 'nids' or -1 for error) ++ */ ++/* Returns to a pointer to the array of supported cipher 'nid's. If the second ++ * parameter is non-NULL it is set to the size of the returned array. */ ++typedef int (*ENGINE_CIPHERS_PTR)(ENGINE *, const EVP_CIPHER **, const int **, int); ++typedef int (*ENGINE_DIGESTS_PTR)(ENGINE *, const EVP_MD **, const int **, int); ++typedef int (*ENGINE_PKEY_METHS_PTR)(ENGINE *, EVP_PKEY_METHOD **, const int **, int); ++typedef int (*ENGINE_PKEY_ASN1_METHS_PTR)(ENGINE *, EVP_PKEY_ASN1_METHOD **, const int **, int); ++/* STRUCTURE functions ... all of these functions deal with pointers to ENGINE ++ * structures where the pointers have a "structural reference". This means that ++ * their reference is to allowed access to the structure but it does not imply ++ * that the structure is functional. To simply increment or decrement the ++ * structural reference count, use ENGINE_by_id and ENGINE_free. NB: This is not ++ * required when iterating using ENGINE_get_next as it will automatically ++ * decrement the structural reference count of the "current" ENGINE and ++ * increment the structural reference count of the ENGINE it returns (unless it ++ * is NULL). */ ++ ++/* Get the first/last "ENGINE" type available. */ ++ENGINE *ENGINE_get_first(void); ++ENGINE *ENGINE_get_last(void); ++/* Iterate to the next/previous "ENGINE" type (NULL = end of the list). */ ++ENGINE *ENGINE_get_next(ENGINE *e); ++ENGINE *ENGINE_get_prev(ENGINE *e); ++/* Add another "ENGINE" type into the array. */ ++int ENGINE_add(ENGINE *e); ++/* Remove an existing "ENGINE" type from the array. */ ++int ENGINE_remove(ENGINE *e); ++/* Retrieve an engine from the list by its unique "id" value. */ ++ENGINE *ENGINE_by_id(const char *id); ++/* Add all the built-in engines. */ ++void ENGINE_load_openssl(void); ++void ENGINE_load_dynamic(void); ++#ifndef OPENSSL_NO_STATIC_ENGINE ++void ENGINE_load_4758cca(void); ++void ENGINE_load_aep(void); ++void ENGINE_load_atalla(void); ++void ENGINE_load_chil(void); ++void ENGINE_load_cswift(void); ++void ENGINE_load_nuron(void); ++void ENGINE_load_sureware(void); ++void ENGINE_load_ubsec(void); ++void ENGINE_load_padlock(void); ++void ENGINE_load_capi(void); ++#ifndef OPENSSL_NO_GMP ++void ENGINE_load_gmp(void); ++#endif ++#ifndef OPENSSL_NO_GOST ++void ENGINE_load_gost(void); ++#endif ++#endif ++void ENGINE_load_cryptodev(void); ++void ENGINE_load_builtin_engines(void); ++ ++/* Get and set global flags (ENGINE_TABLE_FLAG_***) for the implementation ++ * "registry" handling. */ ++unsigned int ENGINE_get_table_flags(void); ++void ENGINE_set_table_flags(unsigned int flags); ++ ++/* Manage registration of ENGINEs per "table". For each type, there are 3 ++ * functions; ++ * ENGINE_register_***(e) - registers the implementation from 'e' (if it has one) ++ * ENGINE_unregister_***(e) - unregister the implementation from 'e' ++ * ENGINE_register_all_***() - call ENGINE_register_***() for each 'e' in the list ++ * Cleanup is automatically registered from each table when required, so ++ * ENGINE_cleanup() will reverse any "register" operations. */ ++ ++int ENGINE_register_RSA(ENGINE *e); ++void ENGINE_unregister_RSA(ENGINE *e); ++void ENGINE_register_all_RSA(void); ++ ++int ENGINE_register_DSA(ENGINE *e); ++void ENGINE_unregister_DSA(ENGINE *e); ++void ENGINE_register_all_DSA(void); ++ ++int ENGINE_register_ECDH(ENGINE *e); ++void ENGINE_unregister_ECDH(ENGINE *e); ++void ENGINE_register_all_ECDH(void); ++ ++int ENGINE_register_ECDSA(ENGINE *e); ++void ENGINE_unregister_ECDSA(ENGINE *e); ++void ENGINE_register_all_ECDSA(void); ++ ++int ENGINE_register_DH(ENGINE *e); ++void ENGINE_unregister_DH(ENGINE *e); ++void ENGINE_register_all_DH(void); ++ ++int ENGINE_register_RAND(ENGINE *e); ++void ENGINE_unregister_RAND(ENGINE *e); ++void ENGINE_register_all_RAND(void); ++ ++int ENGINE_register_STORE(ENGINE *e); ++void ENGINE_unregister_STORE(ENGINE *e); ++void ENGINE_register_all_STORE(void); ++ ++int ENGINE_register_ciphers(ENGINE *e); ++void ENGINE_unregister_ciphers(ENGINE *e); ++void ENGINE_register_all_ciphers(void); ++ ++int ENGINE_register_digests(ENGINE *e); ++void ENGINE_unregister_digests(ENGINE *e); ++void ENGINE_register_all_digests(void); ++ ++int ENGINE_register_pkey_meths(ENGINE *e); ++void ENGINE_unregister_pkey_meths(ENGINE *e); ++void ENGINE_register_all_pkey_meths(void); ++ ++int ENGINE_register_pkey_asn1_meths(ENGINE *e); ++void ENGINE_unregister_pkey_asn1_meths(ENGINE *e); ++void ENGINE_register_all_pkey_asn1_meths(void); ++ ++/* These functions register all support from the above categories. Note, use of ++ * these functions can result in static linkage of code your application may not ++ * need. If you only need a subset of functionality, consider using more ++ * selective initialisation. */ ++int ENGINE_register_complete(ENGINE *e); ++int ENGINE_register_all_complete(void); ++ ++/* Send parametrised control commands to the engine. The possibilities to send ++ * down an integer, a pointer to data or a function pointer are provided. Any of ++ * the parameters may or may not be NULL, depending on the command number. In ++ * actuality, this function only requires a structural (rather than functional) ++ * reference to an engine, but many control commands may require the engine be ++ * functional. The caller should be aware of trying commands that require an ++ * operational ENGINE, and only use functional references in such situations. */ ++int ENGINE_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)(void)); ++ ++/* This function tests if an ENGINE-specific command is usable as a "setting". ++ * Eg. in an application's config file that gets processed through ++ * ENGINE_ctrl_cmd_string(). If this returns zero, it is not available to ++ * ENGINE_ctrl_cmd_string(), only ENGINE_ctrl(). */ ++int ENGINE_cmd_is_executable(ENGINE *e, int cmd); ++ ++/* This function works like ENGINE_ctrl() with the exception of taking a ++ * command name instead of a command number, and can handle optional commands. ++ * See the comment on ENGINE_ctrl_cmd_string() for an explanation on how to ++ * use the cmd_name and cmd_optional. */ ++int ENGINE_ctrl_cmd(ENGINE *e, const char *cmd_name, ++ long i, void *p, void (*f)(void), int cmd_optional); ++ ++/* This function passes a command-name and argument to an ENGINE. The cmd_name ++ * is converted to a command number and the control command is called using ++ * 'arg' as an argument (unless the ENGINE doesn't support such a command, in ++ * which case no control command is called). The command is checked for input ++ * flags, and if necessary the argument will be converted to a numeric value. If ++ * cmd_optional is non-zero, then if the ENGINE doesn't support the given ++ * cmd_name the return value will be success anyway. This function is intended ++ * for applications to use so that users (or config files) can supply ++ * engine-specific config data to the ENGINE at run-time to control behaviour of ++ * specific engines. As such, it shouldn't be used for calling ENGINE_ctrl() ++ * functions that return data, deal with binary data, or that are otherwise ++ * supposed to be used directly through ENGINE_ctrl() in application code. Any ++ * "return" data from an ENGINE_ctrl() operation in this function will be lost - ++ * the return value is interpreted as failure if the return value is zero, ++ * success otherwise, and this function returns a boolean value as a result. In ++ * other words, vendors of 'ENGINE'-enabled devices should write ENGINE ++ * implementations with parameterisations that work in this scheme, so that ++ * compliant ENGINE-based applications can work consistently with the same ++ * configuration for the same ENGINE-enabled devices, across applications. */ ++int ENGINE_ctrl_cmd_string(ENGINE *e, const char *cmd_name, const char *arg, ++ int cmd_optional); ++ ++/* These functions are useful for manufacturing new ENGINE structures. They ++ * don't address reference counting at all - one uses them to populate an ENGINE ++ * structure with personalised implementations of things prior to using it ++ * directly or adding it to the builtin ENGINE list in OpenSSL. These are also ++ * here so that the ENGINE structure doesn't have to be exposed and break binary ++ * compatibility! */ ++ENGINE *ENGINE_new(void); ++int ENGINE_free(ENGINE *e); ++int ENGINE_up_ref(ENGINE *e); ++int ENGINE_set_id(ENGINE *e, const char *id); ++int ENGINE_set_name(ENGINE *e, const char *name); ++int ENGINE_set_RSA(ENGINE *e, const RSA_METHOD *rsa_meth); ++int ENGINE_set_DSA(ENGINE *e, const DSA_METHOD *dsa_meth); ++int ENGINE_set_ECDH(ENGINE *e, const ECDH_METHOD *ecdh_meth); ++int ENGINE_set_ECDSA(ENGINE *e, const ECDSA_METHOD *ecdsa_meth); ++int ENGINE_set_DH(ENGINE *e, const DH_METHOD *dh_meth); ++int ENGINE_set_RAND(ENGINE *e, const RAND_METHOD *rand_meth); ++int ENGINE_set_STORE(ENGINE *e, const STORE_METHOD *store_meth); ++int ENGINE_set_destroy_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR destroy_f); ++int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f); ++int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f); ++int ENGINE_set_ctrl_function(ENGINE *e, ENGINE_CTRL_FUNC_PTR ctrl_f); ++int ENGINE_set_load_privkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpriv_f); ++int ENGINE_set_load_pubkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpub_f); ++int ENGINE_set_load_ssl_client_cert_function(ENGINE *e, ++ ENGINE_SSL_CLIENT_CERT_PTR loadssl_f); ++int ENGINE_set_ciphers(ENGINE *e, ENGINE_CIPHERS_PTR f); ++int ENGINE_set_digests(ENGINE *e, ENGINE_DIGESTS_PTR f); ++int ENGINE_set_pkey_meths(ENGINE *e, ENGINE_PKEY_METHS_PTR f); ++int ENGINE_set_pkey_asn1_meths(ENGINE *e, ENGINE_PKEY_ASN1_METHS_PTR f); ++int ENGINE_set_flags(ENGINE *e, int flags); ++int ENGINE_set_cmd_defns(ENGINE *e, const ENGINE_CMD_DEFN *defns); ++/* These functions allow control over any per-structure ENGINE data. */ ++int ENGINE_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, ++ CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func); ++int ENGINE_set_ex_data(ENGINE *e, int idx, void *arg); ++void *ENGINE_get_ex_data(const ENGINE *e, int idx); ++ ++/* This function cleans up anything that needs it. Eg. the ENGINE_add() function ++ * automatically ensures the list cleanup function is registered to be called ++ * from ENGINE_cleanup(). Similarly, all ENGINE_register_*** functions ensure ++ * ENGINE_cleanup() will clean up after them. */ ++void ENGINE_cleanup(void); ++ ++/* These return values from within the ENGINE structure. These can be useful ++ * with functional references as well as structural references - it depends ++ * which you obtained. Using the result for functional purposes if you only ++ * obtained a structural reference may be problematic! */ ++const char *ENGINE_get_id(const ENGINE *e); ++const char *ENGINE_get_name(const ENGINE *e); ++const RSA_METHOD *ENGINE_get_RSA(const ENGINE *e); ++const DSA_METHOD *ENGINE_get_DSA(const ENGINE *e); ++const ECDH_METHOD *ENGINE_get_ECDH(const ENGINE *e); ++const ECDSA_METHOD *ENGINE_get_ECDSA(const ENGINE *e); ++const DH_METHOD *ENGINE_get_DH(const ENGINE *e); ++const RAND_METHOD *ENGINE_get_RAND(const ENGINE *e); ++const STORE_METHOD *ENGINE_get_STORE(const ENGINE *e); ++ENGINE_GEN_INT_FUNC_PTR ENGINE_get_destroy_function(const ENGINE *e); ++ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE *e); ++ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e); ++ENGINE_CTRL_FUNC_PTR ENGINE_get_ctrl_function(const ENGINE *e); ++ENGINE_LOAD_KEY_PTR ENGINE_get_load_privkey_function(const ENGINE *e); ++ENGINE_LOAD_KEY_PTR ENGINE_get_load_pubkey_function(const ENGINE *e); ++ENGINE_SSL_CLIENT_CERT_PTR ENGINE_get_ssl_client_cert_function(const ENGINE *e); ++ENGINE_CIPHERS_PTR ENGINE_get_ciphers(const ENGINE *e); ++ENGINE_DIGESTS_PTR ENGINE_get_digests(const ENGINE *e); ++ENGINE_PKEY_METHS_PTR ENGINE_get_pkey_meths(const ENGINE *e); ++ENGINE_PKEY_ASN1_METHS_PTR ENGINE_get_pkey_asn1_meths(const ENGINE *e); ++const EVP_CIPHER *ENGINE_get_cipher(ENGINE *e, int nid); ++const EVP_MD *ENGINE_get_digest(ENGINE *e, int nid); ++const EVP_PKEY_METHOD *ENGINE_get_pkey_meth(ENGINE *e, int nid); ++const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth(ENGINE *e, int nid); ++const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth_str(ENGINE *e, ++ const char *str, int len); ++const EVP_PKEY_ASN1_METHOD *ENGINE_pkey_asn1_find_str(ENGINE **pe, ++ const char *str, int len); ++const ENGINE_CMD_DEFN *ENGINE_get_cmd_defns(const ENGINE *e); ++int ENGINE_get_flags(const ENGINE *e); ++ ++/* FUNCTIONAL functions. These functions deal with ENGINE structures ++ * that have (or will) be initialised for use. Broadly speaking, the ++ * structural functions are useful for iterating the list of available ++ * engine types, creating new engine types, and other "list" operations. ++ * These functions actually deal with ENGINEs that are to be used. As ++ * such these functions can fail (if applicable) when particular ++ * engines are unavailable - eg. if a hardware accelerator is not ++ * attached or not functioning correctly. Each ENGINE has 2 reference ++ * counts; structural and functional. Every time a functional reference ++ * is obtained or released, a corresponding structural reference is ++ * automatically obtained or released too. */ ++ ++/* Initialise a engine type for use (or up its reference count if it's ++ * already in use). This will fail if the engine is not currently ++ * operational and cannot initialise. */ ++int ENGINE_init(ENGINE *e); ++/* Free a functional reference to a engine type. This does not require ++ * a corresponding call to ENGINE_free as it also releases a structural ++ * reference. */ ++int ENGINE_finish(ENGINE *e); ++ ++/* The following functions handle keys that are stored in some secondary ++ * location, handled by the engine. The storage may be on a card or ++ * whatever. */ ++EVP_PKEY *ENGINE_load_private_key(ENGINE *e, const char *key_id, ++ UI_METHOD *ui_method, void *callback_data); ++EVP_PKEY *ENGINE_load_public_key(ENGINE *e, const char *key_id, ++ UI_METHOD *ui_method, void *callback_data); ++int ENGINE_load_ssl_client_cert(ENGINE *e, SSL *s, ++ STACK_OF(X509_NAME) *ca_dn, X509 **pcert, EVP_PKEY **ppkey, ++ STACK_OF(X509) **pother, ++ UI_METHOD *ui_method, void *callback_data); ++ ++/* This returns a pointer for the current ENGINE structure that ++ * is (by default) performing any RSA operations. The value returned ++ * is an incremented reference, so it should be free'd (ENGINE_finish) ++ * before it is discarded. */ ++ENGINE *ENGINE_get_default_RSA(void); ++/* Same for the other "methods" */ ++ENGINE *ENGINE_get_default_DSA(void); ++ENGINE *ENGINE_get_default_ECDH(void); ++ENGINE *ENGINE_get_default_ECDSA(void); ++ENGINE *ENGINE_get_default_DH(void); ++ENGINE *ENGINE_get_default_RAND(void); ++/* These functions can be used to get a functional reference to perform ++ * ciphering or digesting corresponding to "nid". */ ++ENGINE *ENGINE_get_cipher_engine(int nid); ++ENGINE *ENGINE_get_digest_engine(int nid); ++ENGINE *ENGINE_get_pkey_meth_engine(int nid); ++ENGINE *ENGINE_get_pkey_asn1_meth_engine(int nid); ++ ++/* This sets a new default ENGINE structure for performing RSA ++ * operations. If the result is non-zero (success) then the ENGINE ++ * structure will have had its reference count up'd so the caller ++ * should still free their own reference 'e'. */ ++int ENGINE_set_default_RSA(ENGINE *e); ++int ENGINE_set_default_string(ENGINE *e, const char *def_list); ++/* Same for the other "methods" */ ++int ENGINE_set_default_DSA(ENGINE *e); ++int ENGINE_set_default_ECDH(ENGINE *e); ++int ENGINE_set_default_ECDSA(ENGINE *e); ++int ENGINE_set_default_DH(ENGINE *e); ++int ENGINE_set_default_RAND(ENGINE *e); ++int ENGINE_set_default_ciphers(ENGINE *e); ++int ENGINE_set_default_digests(ENGINE *e); ++int ENGINE_set_default_pkey_meths(ENGINE *e); ++int ENGINE_set_default_pkey_asn1_meths(ENGINE *e); ++ ++/* The combination "set" - the flags are bitwise "OR"d from the ++ * ENGINE_METHOD_*** defines above. As with the "ENGINE_register_complete()" ++ * function, this function can result in unnecessary static linkage. If your ++ * application requires only specific functionality, consider using more ++ * selective functions. */ ++int ENGINE_set_default(ENGINE *e, unsigned int flags); ++ ++void ENGINE_add_conf_module(void); ++ ++/* Deprecated functions ... */ ++/* int ENGINE_clear_defaults(void); */ ++ ++/**************************/ ++/* DYNAMIC ENGINE SUPPORT */ ++/**************************/ ++ ++/* Binary/behaviour compatibility levels */ ++#define OSSL_DYNAMIC_VERSION (unsigned long)0x00020000 ++/* Binary versions older than this are too old for us (whether we're a loader or ++ * a loadee) */ ++#define OSSL_DYNAMIC_OLDEST (unsigned long)0x00020000 ++ ++/* When compiling an ENGINE entirely as an external shared library, loadable by ++ * the "dynamic" ENGINE, these types are needed. The 'dynamic_fns' structure ++ * type provides the calling application's (or library's) error functionality ++ * and memory management function pointers to the loaded library. These should ++ * be used/set in the loaded library code so that the loading application's ++ * 'state' will be used/changed in all operations. The 'static_state' pointer ++ * allows the loaded library to know if it shares the same static data as the ++ * calling application (or library), and thus whether these callbacks need to be ++ * set or not. */ ++typedef void *(*dyn_MEM_malloc_cb)(size_t); ++typedef void *(*dyn_MEM_realloc_cb)(void *, size_t); ++typedef void (*dyn_MEM_free_cb)(void *); ++typedef struct st_dynamic_MEM_fns { ++ dyn_MEM_malloc_cb malloc_cb; ++ dyn_MEM_realloc_cb realloc_cb; ++ dyn_MEM_free_cb free_cb; ++ } dynamic_MEM_fns; ++/* FIXME: Perhaps the memory and locking code (crypto.h) should declare and use ++ * these types so we (and any other dependant code) can simplify a bit?? */ ++typedef void (*dyn_lock_locking_cb)(int,int,const char *,int); ++typedef int (*dyn_lock_add_lock_cb)(int*,int,int,const char *,int); ++typedef struct CRYPTO_dynlock_value *(*dyn_dynlock_create_cb)( ++ const char *,int); ++typedef void (*dyn_dynlock_lock_cb)(int,struct CRYPTO_dynlock_value *, ++ const char *,int); ++typedef void (*dyn_dynlock_destroy_cb)(struct CRYPTO_dynlock_value *, ++ const char *,int); ++typedef struct st_dynamic_LOCK_fns { ++ dyn_lock_locking_cb lock_locking_cb; ++ dyn_lock_add_lock_cb lock_add_lock_cb; ++ dyn_dynlock_create_cb dynlock_create_cb; ++ dyn_dynlock_lock_cb dynlock_lock_cb; ++ dyn_dynlock_destroy_cb dynlock_destroy_cb; ++ } dynamic_LOCK_fns; ++/* The top-level structure */ ++typedef struct st_dynamic_fns { ++ void *static_state; ++ const ERR_FNS *err_fns; ++ const CRYPTO_EX_DATA_IMPL *ex_data_fns; ++ dynamic_MEM_fns mem_fns; ++ dynamic_LOCK_fns lock_fns; ++ } dynamic_fns; ++ ++/* The version checking function should be of this prototype. NB: The ++ * ossl_version value passed in is the OSSL_DYNAMIC_VERSION of the loading code. ++ * If this function returns zero, it indicates a (potential) version ++ * incompatibility and the loaded library doesn't believe it can proceed. ++ * Otherwise, the returned value is the (latest) version supported by the ++ * loading library. The loader may still decide that the loaded code's version ++ * is unsatisfactory and could veto the load. The function is expected to ++ * be implemented with the symbol name "v_check", and a default implementation ++ * can be fully instantiated with IMPLEMENT_DYNAMIC_CHECK_FN(). */ ++typedef unsigned long (*dynamic_v_check_fn)(unsigned long ossl_version); ++#define IMPLEMENT_DYNAMIC_CHECK_FN() \ ++ OPENSSL_EXPORT unsigned long v_check(unsigned long v) { \ ++ if(v >= OSSL_DYNAMIC_OLDEST) return OSSL_DYNAMIC_VERSION; \ ++ return 0; } ++ ++/* This function is passed the ENGINE structure to initialise with its own ++ * function and command settings. It should not adjust the structural or ++ * functional reference counts. If this function returns zero, (a) the load will ++ * be aborted, (b) the previous ENGINE state will be memcpy'd back onto the ++ * structure, and (c) the shared library will be unloaded. So implementations ++ * should do their own internal cleanup in failure circumstances otherwise they ++ * could leak. The 'id' parameter, if non-NULL, represents the ENGINE id that ++ * the loader is looking for. If this is NULL, the shared library can choose to ++ * return failure or to initialise a 'default' ENGINE. If non-NULL, the shared ++ * library must initialise only an ENGINE matching the passed 'id'. The function ++ * is expected to be implemented with the symbol name "bind_engine". A standard ++ * implementation can be instantiated with IMPLEMENT_DYNAMIC_BIND_FN(fn) where ++ * the parameter 'fn' is a callback function that populates the ENGINE structure ++ * and returns an int value (zero for failure). 'fn' should have prototype; ++ * [static] int fn(ENGINE *e, const char *id); */ ++typedef int (*dynamic_bind_engine)(ENGINE *e, const char *id, ++ const dynamic_fns *fns); ++#define IMPLEMENT_DYNAMIC_BIND_FN(fn) \ ++ OPENSSL_EXPORT \ ++ int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns) { \ ++ if(ENGINE_get_static_state() == fns->static_state) goto skip_cbs; \ ++ if(!CRYPTO_set_mem_functions(fns->mem_fns.malloc_cb, \ ++ fns->mem_fns.realloc_cb, fns->mem_fns.free_cb)) \ ++ return 0; \ ++ CRYPTO_set_locking_callback(fns->lock_fns.lock_locking_cb); \ ++ CRYPTO_set_add_lock_callback(fns->lock_fns.lock_add_lock_cb); \ ++ CRYPTO_set_dynlock_create_callback(fns->lock_fns.dynlock_create_cb); \ ++ CRYPTO_set_dynlock_lock_callback(fns->lock_fns.dynlock_lock_cb); \ ++ CRYPTO_set_dynlock_destroy_callback(fns->lock_fns.dynlock_destroy_cb); \ ++ if(!CRYPTO_set_ex_data_implementation(fns->ex_data_fns)) \ ++ return 0; \ ++ if(!ERR_set_implementation(fns->err_fns)) return 0; \ ++ skip_cbs: \ ++ if(!fn(e,id)) return 0; \ ++ return 1; } ++ ++/* If the loading application (or library) and the loaded ENGINE library share ++ * the same static data (eg. they're both dynamically linked to the same ++ * libcrypto.so) we need a way to avoid trying to set system callbacks - this ++ * would fail, and for the same reason that it's unnecessary to try. If the ++ * loaded ENGINE has (or gets from through the loader) its own copy of the ++ * libcrypto static data, we will need to set the callbacks. The easiest way to ++ * detect this is to have a function that returns a pointer to some static data ++ * and let the loading application and loaded ENGINE compare their respective ++ * values. */ ++void *ENGINE_get_static_state(void); ++ ++#if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV) ++void ENGINE_setup_bsd_cryptodev(void); ++#endif ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_ENGINE_strings(void); ++ ++/* Error codes for the ENGINE functions. */ ++ ++/* Function codes. */ ++#define ENGINE_F_DYNAMIC_CTRL 180 ++#define ENGINE_F_DYNAMIC_GET_DATA_CTX 181 ++#define ENGINE_F_DYNAMIC_LOAD 182 ++#define ENGINE_F_DYNAMIC_SET_DATA_CTX 183 ++#define ENGINE_F_ENGINE_ADD 105 ++#define ENGINE_F_ENGINE_BY_ID 106 ++#define ENGINE_F_ENGINE_CMD_IS_EXECUTABLE 170 ++#define ENGINE_F_ENGINE_CTRL 142 ++#define ENGINE_F_ENGINE_CTRL_CMD 178 ++#define ENGINE_F_ENGINE_CTRL_CMD_STRING 171 ++#define ENGINE_F_ENGINE_FINISH 107 ++#define ENGINE_F_ENGINE_FREE_UTIL 108 ++#define ENGINE_F_ENGINE_GET_CIPHER 185 ++#define ENGINE_F_ENGINE_GET_DEFAULT_TYPE 177 ++#define ENGINE_F_ENGINE_GET_DIGEST 186 ++#define ENGINE_F_ENGINE_GET_NEXT 115 ++#define ENGINE_F_ENGINE_GET_PKEY_ASN1_METH 193 ++#define ENGINE_F_ENGINE_GET_PKEY_METH 192 ++#define ENGINE_F_ENGINE_GET_PREV 116 ++#define ENGINE_F_ENGINE_INIT 119 ++#define ENGINE_F_ENGINE_LIST_ADD 120 ++#define ENGINE_F_ENGINE_LIST_REMOVE 121 ++#define ENGINE_F_ENGINE_LOAD_PRIVATE_KEY 150 ++#define ENGINE_F_ENGINE_LOAD_PUBLIC_KEY 151 ++#define ENGINE_F_ENGINE_LOAD_SSL_CLIENT_CERT 194 ++#define ENGINE_F_ENGINE_NEW 122 ++#define ENGINE_F_ENGINE_REMOVE 123 ++#define ENGINE_F_ENGINE_SET_DEFAULT_STRING 189 ++#define ENGINE_F_ENGINE_SET_DEFAULT_TYPE 126 ++#define ENGINE_F_ENGINE_SET_ID 129 ++#define ENGINE_F_ENGINE_SET_NAME 130 ++#define ENGINE_F_ENGINE_TABLE_REGISTER 184 ++#define ENGINE_F_ENGINE_UNLOAD_KEY 152 ++#define ENGINE_F_ENGINE_UNLOCKED_FINISH 191 ++#define ENGINE_F_ENGINE_UP_REF 190 ++#define ENGINE_F_INT_CTRL_HELPER 172 ++#define ENGINE_F_INT_ENGINE_CONFIGURE 188 ++#define ENGINE_F_INT_ENGINE_MODULE_INIT 187 ++#define ENGINE_F_LOG_MESSAGE 141 ++ ++/* Reason codes. */ ++#define ENGINE_R_ALREADY_LOADED 100 ++#define ENGINE_R_ARGUMENT_IS_NOT_A_NUMBER 133 ++#define ENGINE_R_CMD_NOT_EXECUTABLE 134 ++#define ENGINE_R_COMMAND_TAKES_INPUT 135 ++#define ENGINE_R_COMMAND_TAKES_NO_INPUT 136 ++#define ENGINE_R_CONFLICTING_ENGINE_ID 103 ++#define ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED 119 ++#define ENGINE_R_DH_NOT_IMPLEMENTED 139 ++#define ENGINE_R_DSA_NOT_IMPLEMENTED 140 ++#define ENGINE_R_DSO_FAILURE 104 ++#define ENGINE_R_DSO_NOT_FOUND 132 ++#define ENGINE_R_ENGINES_SECTION_ERROR 148 ++#define ENGINE_R_ENGINE_CONFIGURATION_ERROR 102 ++#define ENGINE_R_ENGINE_IS_NOT_IN_LIST 105 ++#define ENGINE_R_ENGINE_SECTION_ERROR 149 ++#define ENGINE_R_FAILED_LOADING_PRIVATE_KEY 128 ++#define ENGINE_R_FAILED_LOADING_PUBLIC_KEY 129 ++#define ENGINE_R_FINISH_FAILED 106 ++#define ENGINE_R_GET_HANDLE_FAILED 107 ++#define ENGINE_R_ID_OR_NAME_MISSING 108 ++#define ENGINE_R_INIT_FAILED 109 ++#define ENGINE_R_INTERNAL_LIST_ERROR 110 ++#define ENGINE_R_INVALID_ARGUMENT 143 ++#define ENGINE_R_INVALID_CMD_NAME 137 ++#define ENGINE_R_INVALID_CMD_NUMBER 138 ++#define ENGINE_R_INVALID_INIT_VALUE 151 ++#define ENGINE_R_INVALID_STRING 150 ++#define ENGINE_R_NOT_INITIALISED 117 ++#define ENGINE_R_NOT_LOADED 112 ++#define ENGINE_R_NO_CONTROL_FUNCTION 120 ++#define ENGINE_R_NO_INDEX 144 ++#define ENGINE_R_NO_LOAD_FUNCTION 125 ++#define ENGINE_R_NO_REFERENCE 130 ++#define ENGINE_R_NO_SUCH_ENGINE 116 ++#define ENGINE_R_NO_UNLOAD_FUNCTION 126 ++#define ENGINE_R_PROVIDE_PARAMETERS 113 ++#define ENGINE_R_RSA_NOT_IMPLEMENTED 141 ++#define ENGINE_R_UNIMPLEMENTED_CIPHER 146 ++#define ENGINE_R_UNIMPLEMENTED_DIGEST 147 ++#define ENGINE_R_UNIMPLEMENTED_PUBLIC_KEY_METHOD 101 ++#define ENGINE_R_VERSION_INCOMPATIBILITY 145 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/err.h qt.patched/include/openssl/err.h +--- qt.orig/include/openssl/err.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/err.h 2010-08-27 12:01:45.274533500 +0200 +@@ -0,0 +1,385 @@ ++/* crypto/err/err.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++/* ==================================================================== ++ * Copyright (c) 1998-2006 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * openssl-core@openssl.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.openssl.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++ ++#ifndef HEADER_ERR_H ++#define HEADER_ERR_H ++ ++#include ++ ++#ifndef OPENSSL_NO_FP_API ++#include ++#include ++#endif ++ ++#include ++#ifndef OPENSSL_NO_BIO ++#include ++#endif ++#ifndef OPENSSL_NO_LHASH ++#include ++#endif ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#ifndef OPENSSL_NO_ERR ++#define ERR_PUT_error(a,b,c,d,e) ERR_put_error(a,b,c,d,e) ++#else ++#define ERR_PUT_error(a,b,c,d,e) ERR_put_error(a,b,c,NULL,0) ++#endif ++ ++#include ++ ++#define ERR_TXT_MALLOCED 0x01 ++#define ERR_TXT_STRING 0x02 ++ ++#define ERR_FLAG_MARK 0x01 ++ ++#define ERR_NUM_ERRORS 16 ++typedef struct err_state_st ++ { ++ CRYPTO_THREADID tid; ++ int err_flags[ERR_NUM_ERRORS]; ++ unsigned long err_buffer[ERR_NUM_ERRORS]; ++ char *err_data[ERR_NUM_ERRORS]; ++ int err_data_flags[ERR_NUM_ERRORS]; ++ const char *err_file[ERR_NUM_ERRORS]; ++ int err_line[ERR_NUM_ERRORS]; ++ int top,bottom; ++ } ERR_STATE; ++ ++/* library */ ++#define ERR_LIB_NONE 1 ++#define ERR_LIB_SYS 2 ++#define ERR_LIB_BN 3 ++#define ERR_LIB_RSA 4 ++#define ERR_LIB_DH 5 ++#define ERR_LIB_EVP 6 ++#define ERR_LIB_BUF 7 ++#define ERR_LIB_OBJ 8 ++#define ERR_LIB_PEM 9 ++#define ERR_LIB_DSA 10 ++#define ERR_LIB_X509 11 ++/* #define ERR_LIB_METH 12 */ ++#define ERR_LIB_ASN1 13 ++#define ERR_LIB_CONF 14 ++#define ERR_LIB_CRYPTO 15 ++#define ERR_LIB_EC 16 ++#define ERR_LIB_SSL 20 ++/* #define ERR_LIB_SSL23 21 */ ++/* #define ERR_LIB_SSL2 22 */ ++/* #define ERR_LIB_SSL3 23 */ ++/* #define ERR_LIB_RSAREF 30 */ ++/* #define ERR_LIB_PROXY 31 */ ++#define ERR_LIB_BIO 32 ++#define ERR_LIB_PKCS7 33 ++#define ERR_LIB_X509V3 34 ++#define ERR_LIB_PKCS12 35 ++#define ERR_LIB_RAND 36 ++#define ERR_LIB_DSO 37 ++#define ERR_LIB_ENGINE 38 ++#define ERR_LIB_OCSP 39 ++#define ERR_LIB_UI 40 ++#define ERR_LIB_COMP 41 ++#define ERR_LIB_ECDSA 42 ++#define ERR_LIB_ECDH 43 ++#define ERR_LIB_STORE 44 ++#define ERR_LIB_FIPS 45 ++#define ERR_LIB_CMS 46 ++#define ERR_LIB_TS 47 ++#define ERR_LIB_HMAC 48 ++#define ERR_LIB_JPAKE 49 ++ ++#define ERR_LIB_USER 128 ++ ++#define SYSerr(f,r) ERR_PUT_error(ERR_LIB_SYS,(f),(r),__FILE__,__LINE__) ++#define BNerr(f,r) ERR_PUT_error(ERR_LIB_BN,(f),(r),__FILE__,__LINE__) ++#define RSAerr(f,r) ERR_PUT_error(ERR_LIB_RSA,(f),(r),__FILE__,__LINE__) ++#define DHerr(f,r) ERR_PUT_error(ERR_LIB_DH,(f),(r),__FILE__,__LINE__) ++#define EVPerr(f,r) ERR_PUT_error(ERR_LIB_EVP,(f),(r),__FILE__,__LINE__) ++#define BUFerr(f,r) ERR_PUT_error(ERR_LIB_BUF,(f),(r),__FILE__,__LINE__) ++#define OBJerr(f,r) ERR_PUT_error(ERR_LIB_OBJ,(f),(r),__FILE__,__LINE__) ++#define PEMerr(f,r) ERR_PUT_error(ERR_LIB_PEM,(f),(r),__FILE__,__LINE__) ++#define DSAerr(f,r) ERR_PUT_error(ERR_LIB_DSA,(f),(r),__FILE__,__LINE__) ++#define X509err(f,r) ERR_PUT_error(ERR_LIB_X509,(f),(r),__FILE__,__LINE__) ++#define ASN1err(f,r) ERR_PUT_error(ERR_LIB_ASN1,(f),(r),__FILE__,__LINE__) ++#define CONFerr(f,r) ERR_PUT_error(ERR_LIB_CONF,(f),(r),__FILE__,__LINE__) ++#define CRYPTOerr(f,r) ERR_PUT_error(ERR_LIB_CRYPTO,(f),(r),__FILE__,__LINE__) ++#define ECerr(f,r) ERR_PUT_error(ERR_LIB_EC,(f),(r),__FILE__,__LINE__) ++#define SSLerr(f,r) ERR_PUT_error(ERR_LIB_SSL,(f),(r),__FILE__,__LINE__) ++#define BIOerr(f,r) ERR_PUT_error(ERR_LIB_BIO,(f),(r),__FILE__,__LINE__) ++#define PKCS7err(f,r) ERR_PUT_error(ERR_LIB_PKCS7,(f),(r),__FILE__,__LINE__) ++#define X509V3err(f,r) ERR_PUT_error(ERR_LIB_X509V3,(f),(r),__FILE__,__LINE__) ++#define PKCS12err(f,r) ERR_PUT_error(ERR_LIB_PKCS12,(f),(r),__FILE__,__LINE__) ++#define RANDerr(f,r) ERR_PUT_error(ERR_LIB_RAND,(f),(r),__FILE__,__LINE__) ++#define DSOerr(f,r) ERR_PUT_error(ERR_LIB_DSO,(f),(r),__FILE__,__LINE__) ++#define ENGINEerr(f,r) ERR_PUT_error(ERR_LIB_ENGINE,(f),(r),__FILE__,__LINE__) ++#define OCSPerr(f,r) ERR_PUT_error(ERR_LIB_OCSP,(f),(r),__FILE__,__LINE__) ++#define UIerr(f,r) ERR_PUT_error(ERR_LIB_UI,(f),(r),__FILE__,__LINE__) ++#define COMPerr(f,r) ERR_PUT_error(ERR_LIB_COMP,(f),(r),__FILE__,__LINE__) ++#define ECDSAerr(f,r) ERR_PUT_error(ERR_LIB_ECDSA,(f),(r),__FILE__,__LINE__) ++#define ECDHerr(f,r) ERR_PUT_error(ERR_LIB_ECDH,(f),(r),__FILE__,__LINE__) ++#define STOREerr(f,r) ERR_PUT_error(ERR_LIB_STORE,(f),(r),__FILE__,__LINE__) ++#define FIPSerr(f,r) ERR_PUT_error(ERR_LIB_FIPS,(f),(r),__FILE__,__LINE__) ++#define CMSerr(f,r) ERR_PUT_error(ERR_LIB_CMS,(f),(r),__FILE__,__LINE__) ++#define TSerr(f,r) ERR_PUT_error(ERR_LIB_TS,(f),(r),__FILE__,__LINE__) ++#define HMACerr(f,r) ERR_PUT_error(ERR_LIB_HMAC,(f),(r),__FILE__,__LINE__) ++#define JPAKEerr(f,r) ERR_PUT_error(ERR_LIB_JPAKE,(f),(r),__FILE__,__LINE__) ++ ++/* Borland C seems too stupid to be able to shift and do longs in ++ * the pre-processor :-( */ ++#define ERR_PACK(l,f,r) (((((unsigned long)l)&0xffL)*0x1000000)| \ ++ ((((unsigned long)f)&0xfffL)*0x1000)| \ ++ ((((unsigned long)r)&0xfffL))) ++#define ERR_GET_LIB(l) (int)((((unsigned long)l)>>24L)&0xffL) ++#define ERR_GET_FUNC(l) (int)((((unsigned long)l)>>12L)&0xfffL) ++#define ERR_GET_REASON(l) (int)((l)&0xfffL) ++#define ERR_FATAL_ERROR(l) (int)((l)&ERR_R_FATAL) ++ ++ ++/* OS functions */ ++#define SYS_F_FOPEN 1 ++#define SYS_F_CONNECT 2 ++#define SYS_F_GETSERVBYNAME 3 ++#define SYS_F_SOCKET 4 ++#define SYS_F_IOCTLSOCKET 5 ++#define SYS_F_BIND 6 ++#define SYS_F_LISTEN 7 ++#define SYS_F_ACCEPT 8 ++#define SYS_F_WSASTARTUP 9 /* Winsock stuff */ ++#define SYS_F_OPENDIR 10 ++#define SYS_F_FREAD 11 ++ ++ ++/* reasons */ ++#define ERR_R_SYS_LIB ERR_LIB_SYS /* 2 */ ++#define ERR_R_BN_LIB ERR_LIB_BN /* 3 */ ++#define ERR_R_RSA_LIB ERR_LIB_RSA /* 4 */ ++#define ERR_R_DH_LIB ERR_LIB_DH /* 5 */ ++#define ERR_R_EVP_LIB ERR_LIB_EVP /* 6 */ ++#define ERR_R_BUF_LIB ERR_LIB_BUF /* 7 */ ++#define ERR_R_OBJ_LIB ERR_LIB_OBJ /* 8 */ ++#define ERR_R_PEM_LIB ERR_LIB_PEM /* 9 */ ++#define ERR_R_DSA_LIB ERR_LIB_DSA /* 10 */ ++#define ERR_R_X509_LIB ERR_LIB_X509 /* 11 */ ++#define ERR_R_ASN1_LIB ERR_LIB_ASN1 /* 13 */ ++#define ERR_R_CONF_LIB ERR_LIB_CONF /* 14 */ ++#define ERR_R_CRYPTO_LIB ERR_LIB_CRYPTO /* 15 */ ++#define ERR_R_EC_LIB ERR_LIB_EC /* 16 */ ++#define ERR_R_SSL_LIB ERR_LIB_SSL /* 20 */ ++#define ERR_R_BIO_LIB ERR_LIB_BIO /* 32 */ ++#define ERR_R_PKCS7_LIB ERR_LIB_PKCS7 /* 33 */ ++#define ERR_R_X509V3_LIB ERR_LIB_X509V3 /* 34 */ ++#define ERR_R_PKCS12_LIB ERR_LIB_PKCS12 /* 35 */ ++#define ERR_R_RAND_LIB ERR_LIB_RAND /* 36 */ ++#define ERR_R_DSO_LIB ERR_LIB_DSO /* 37 */ ++#define ERR_R_ENGINE_LIB ERR_LIB_ENGINE /* 38 */ ++#define ERR_R_OCSP_LIB ERR_LIB_OCSP /* 39 */ ++#define ERR_R_UI_LIB ERR_LIB_UI /* 40 */ ++#define ERR_R_COMP_LIB ERR_LIB_COMP /* 41 */ ++#define ERR_R_ECDSA_LIB ERR_LIB_ECDSA /* 42 */ ++#define ERR_R_ECDH_LIB ERR_LIB_ECDH /* 43 */ ++#define ERR_R_STORE_LIB ERR_LIB_STORE /* 44 */ ++#define ERR_R_TS_LIB ERR_LIB_TS /* 45 */ ++ ++#define ERR_R_NESTED_ASN1_ERROR 58 ++#define ERR_R_BAD_ASN1_OBJECT_HEADER 59 ++#define ERR_R_BAD_GET_ASN1_OBJECT_CALL 60 ++#define ERR_R_EXPECTING_AN_ASN1_SEQUENCE 61 ++#define ERR_R_ASN1_LENGTH_MISMATCH 62 ++#define ERR_R_MISSING_ASN1_EOS 63 ++ ++/* fatal error */ ++#define ERR_R_FATAL 64 ++#define ERR_R_MALLOC_FAILURE (1|ERR_R_FATAL) ++#define ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED (2|ERR_R_FATAL) ++#define ERR_R_PASSED_NULL_PARAMETER (3|ERR_R_FATAL) ++#define ERR_R_INTERNAL_ERROR (4|ERR_R_FATAL) ++#define ERR_R_DISABLED (5|ERR_R_FATAL) ++ ++/* 99 is the maximum possible ERR_R_... code, higher values ++ * are reserved for the individual libraries */ ++ ++ ++typedef struct ERR_string_data_st ++ { ++ unsigned long error; ++ const char *string; ++ } ERR_STRING_DATA; ++ ++void ERR_put_error(int lib, int func,int reason,const char *file,int line); ++void ERR_set_error_data(char *data,int flags); ++ ++unsigned long ERR_get_error(void); ++unsigned long ERR_get_error_line(const char **file,int *line); ++unsigned long ERR_get_error_line_data(const char **file,int *line, ++ const char **data, int *flags); ++unsigned long ERR_peek_error(void); ++unsigned long ERR_peek_error_line(const char **file,int *line); ++unsigned long ERR_peek_error_line_data(const char **file,int *line, ++ const char **data,int *flags); ++unsigned long ERR_peek_last_error(void); ++unsigned long ERR_peek_last_error_line(const char **file,int *line); ++unsigned long ERR_peek_last_error_line_data(const char **file,int *line, ++ const char **data,int *flags); ++void ERR_clear_error(void ); ++char *ERR_error_string(unsigned long e,char *buf); ++void ERR_error_string_n(unsigned long e, char *buf, size_t len); ++const char *ERR_lib_error_string(unsigned long e); ++const char *ERR_func_error_string(unsigned long e); ++const char *ERR_reason_error_string(unsigned long e); ++void ERR_print_errors_cb(int (*cb)(const char *str, size_t len, void *u), ++ void *u); ++#ifndef OPENSSL_NO_FP_API ++void ERR_print_errors_fp(FILE *fp); ++#endif ++#ifndef OPENSSL_NO_BIO ++void ERR_print_errors(BIO *bp); ++void ERR_add_error_data(int num, ...); ++#endif ++void ERR_load_strings(int lib,ERR_STRING_DATA str[]); ++void ERR_unload_strings(int lib,ERR_STRING_DATA str[]); ++void ERR_load_ERR_strings(void); ++void ERR_load_crypto_strings(void); ++void ERR_free_strings(void); ++ ++void ERR_remove_thread_state(const CRYPTO_THREADID *tid); ++#ifndef OPENSSL_NO_DEPRECATED ++void ERR_remove_state(unsigned long pid); /* if zero we look it up */ ++#endif ++ERR_STATE *ERR_get_state(void); ++ ++#ifndef OPENSSL_NO_LHASH ++LHASH_OF(ERR_STRING_DATA) *ERR_get_string_table(void); ++LHASH_OF(ERR_STATE) *ERR_get_err_state_table(void); ++void ERR_release_err_state_table(LHASH_OF(ERR_STATE) **hash); ++#endif ++ ++int ERR_get_next_error_library(void); ++ ++int ERR_set_mark(void); ++int ERR_pop_to_mark(void); ++ ++/* Already defined in ossl_typ.h */ ++/* typedef struct st_ERR_FNS ERR_FNS; */ ++/* An application can use this function and provide the return value to loaded ++ * modules that should use the application's ERR state/functionality */ ++const ERR_FNS *ERR_get_implementation(void); ++/* A loaded module should call this function prior to any ERR operations using ++ * the application's "ERR_FNS". */ ++int ERR_set_implementation(const ERR_FNS *fns); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff -urN qt.orig/include/openssl/evp.h qt.patched/include/openssl/evp.h +--- qt.orig/include/openssl/evp.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/evp.h 2010-08-27 12:01:45.290157900 +0200 +@@ -0,0 +1,1324 @@ ++/* crypto/evp/evp.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_ENVELOPE_H ++#define HEADER_ENVELOPE_H ++ ++#ifdef OPENSSL_ALGORITHM_DEFINES ++# include ++#else ++# define OPENSSL_ALGORITHM_DEFINES ++# include ++# undef OPENSSL_ALGORITHM_DEFINES ++#endif ++ ++#include ++ ++#include ++ ++#ifndef OPENSSL_NO_BIO ++#include ++#endif ++ ++/* ++#define EVP_RC2_KEY_SIZE 16 ++#define EVP_RC4_KEY_SIZE 16 ++#define EVP_BLOWFISH_KEY_SIZE 16 ++#define EVP_CAST5_KEY_SIZE 16 ++#define EVP_RC5_32_12_16_KEY_SIZE 16 ++*/ ++#define EVP_MAX_MD_SIZE 64 /* longest known is SHA512 */ ++#define EVP_MAX_KEY_LENGTH 32 ++#define EVP_MAX_IV_LENGTH 16 ++#define EVP_MAX_BLOCK_LENGTH 32 ++ ++#define PKCS5_SALT_LEN 8 ++/* Default PKCS#5 iteration count */ ++#define PKCS5_DEFAULT_ITER 2048 ++ ++#include ++ ++#define EVP_PK_RSA 0x0001 ++#define EVP_PK_DSA 0x0002 ++#define EVP_PK_DH 0x0004 ++#define EVP_PK_EC 0x0008 ++#define EVP_PKT_SIGN 0x0010 ++#define EVP_PKT_ENC 0x0020 ++#define EVP_PKT_EXCH 0x0040 ++#define EVP_PKS_RSA 0x0100 ++#define EVP_PKS_DSA 0x0200 ++#define EVP_PKS_EC 0x0400 ++#define EVP_PKT_EXP 0x1000 /* <= 512 bit key */ ++ ++#define EVP_PKEY_NONE NID_undef ++#define EVP_PKEY_RSA NID_rsaEncryption ++#define EVP_PKEY_RSA2 NID_rsa ++#define EVP_PKEY_DSA NID_dsa ++#define EVP_PKEY_DSA1 NID_dsa_2 ++#define EVP_PKEY_DSA2 NID_dsaWithSHA ++#define EVP_PKEY_DSA3 NID_dsaWithSHA1 ++#define EVP_PKEY_DSA4 NID_dsaWithSHA1_2 ++#define EVP_PKEY_DH NID_dhKeyAgreement ++#define EVP_PKEY_EC NID_X9_62_id_ecPublicKey ++#define EVP_PKEY_HMAC NID_hmac ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* Type needs to be a bit field ++ * Sub-type needs to be for variations on the method, as in, can it do ++ * arbitrary encryption.... */ ++struct evp_pkey_st ++ { ++ int type; ++ int save_type; ++ int references; ++ const EVP_PKEY_ASN1_METHOD *ameth; ++ ENGINE *engine; ++ union { ++ char *ptr; ++#ifndef OPENSSL_NO_RSA ++ struct rsa_st *rsa; /* RSA */ ++#endif ++#ifndef OPENSSL_NO_DSA ++ struct dsa_st *dsa; /* DSA */ ++#endif ++#ifndef OPENSSL_NO_DH ++ struct dh_st *dh; /* DH */ ++#endif ++#ifndef OPENSSL_NO_EC ++ struct ec_key_st *ec; /* ECC */ ++#endif ++ } pkey; ++ int save_parameters; ++ STACK_OF(X509_ATTRIBUTE) *attributes; /* [ 0 ] */ ++ } /* EVP_PKEY */; ++ ++#define EVP_PKEY_MO_SIGN 0x0001 ++#define EVP_PKEY_MO_VERIFY 0x0002 ++#define EVP_PKEY_MO_ENCRYPT 0x0004 ++#define EVP_PKEY_MO_DECRYPT 0x0008 ++ ++#ifndef EVP_MD ++struct env_md_st ++ { ++ int type; ++ int pkey_type; ++ int md_size; ++ unsigned long flags; ++ int (*init)(EVP_MD_CTX *ctx); ++ int (*update)(EVP_MD_CTX *ctx,const void *data,size_t count); ++ int (*final)(EVP_MD_CTX *ctx,unsigned char *md); ++ int (*copy)(EVP_MD_CTX *to,const EVP_MD_CTX *from); ++ int (*cleanup)(EVP_MD_CTX *ctx); ++ ++ /* FIXME: prototype these some day */ ++ int (*sign)(int type, const unsigned char *m, unsigned int m_length, ++ unsigned char *sigret, unsigned int *siglen, void *key); ++ int (*verify)(int type, const unsigned char *m, unsigned int m_length, ++ const unsigned char *sigbuf, unsigned int siglen, ++ void *key); ++ int required_pkey_type[5]; /*EVP_PKEY_xxx */ ++ int block_size; ++ int ctx_size; /* how big does the ctx->md_data need to be */ ++ /* control function */ ++ int (*md_ctrl)(EVP_MD_CTX *ctx, int cmd, int p1, void *p2); ++ } /* EVP_MD */; ++ ++typedef int evp_sign_method(int type,const unsigned char *m, ++ unsigned int m_length,unsigned char *sigret, ++ unsigned int *siglen, void *key); ++typedef int evp_verify_method(int type,const unsigned char *m, ++ unsigned int m_length,const unsigned char *sigbuf, ++ unsigned int siglen, void *key); ++ ++#define EVP_MD_FLAG_ONESHOT 0x0001 /* digest can only handle a single ++ * block */ ++ ++#define EVP_MD_FLAG_PKEY_DIGEST 0x0002 /* digest is a "clone" digest used ++ * which is a copy of an existing ++ * one for a specific public key type. ++ * EVP_dss1() etc */ ++ ++/* Digest uses EVP_PKEY_METHOD for signing instead of MD specific signing */ ++ ++#define EVP_MD_FLAG_PKEY_METHOD_SIGNATURE 0x0004 ++ ++/* DigestAlgorithmIdentifier flags... */ ++ ++#define EVP_MD_FLAG_DIGALGID_MASK 0x0018 ++ ++/* NULL or absent parameter accepted. Use NULL */ ++ ++#define EVP_MD_FLAG_DIGALGID_NULL 0x0000 ++ ++/* NULL or absent parameter accepted. Use NULL for PKCS#1 otherwise absent */ ++ ++#define EVP_MD_FLAG_DIGALGID_ABSENT 0x0008 ++ ++/* Custom handling via ctrl */ ++ ++#define EVP_MD_FLAG_DIGALGID_CUSTOM 0x0018 ++ ++/* Digest ctrls */ ++ ++#define EVP_MD_CTRL_DIGALGID 0x1 ++#define EVP_MD_CTRL_MICALG 0x2 ++ ++/* Minimum Algorithm specific ctrl value */ ++ ++#define EVP_MD_CTRL_ALG_CTRL 0x1000 ++ ++#define EVP_PKEY_NULL_method NULL,NULL,{0,0,0,0} ++ ++#ifndef OPENSSL_NO_DSA ++#define EVP_PKEY_DSA_method (evp_sign_method *)DSA_sign, \ ++ (evp_verify_method *)DSA_verify, \ ++ {EVP_PKEY_DSA,EVP_PKEY_DSA2,EVP_PKEY_DSA3, \ ++ EVP_PKEY_DSA4,0} ++#else ++#define EVP_PKEY_DSA_method EVP_PKEY_NULL_method ++#endif ++ ++#ifndef OPENSSL_NO_ECDSA ++#define EVP_PKEY_ECDSA_method (evp_sign_method *)ECDSA_sign, \ ++ (evp_verify_method *)ECDSA_verify, \ ++ {EVP_PKEY_EC,0,0,0} ++#else ++#define EVP_PKEY_ECDSA_method EVP_PKEY_NULL_method ++#endif ++ ++#ifndef OPENSSL_NO_RSA ++#define EVP_PKEY_RSA_method (evp_sign_method *)RSA_sign, \ ++ (evp_verify_method *)RSA_verify, \ ++ {EVP_PKEY_RSA,EVP_PKEY_RSA2,0,0} ++#define EVP_PKEY_RSA_ASN1_OCTET_STRING_method \ ++ (evp_sign_method *)RSA_sign_ASN1_OCTET_STRING, \ ++ (evp_verify_method *)RSA_verify_ASN1_OCTET_STRING, \ ++ {EVP_PKEY_RSA,EVP_PKEY_RSA2,0,0} ++#else ++#define EVP_PKEY_RSA_method EVP_PKEY_NULL_method ++#define EVP_PKEY_RSA_ASN1_OCTET_STRING_method EVP_PKEY_NULL_method ++#endif ++ ++#endif /* !EVP_MD */ ++ ++struct env_md_ctx_st ++ { ++ const EVP_MD *digest; ++ ENGINE *engine; /* functional reference if 'digest' is ENGINE-provided */ ++ unsigned long flags; ++ void *md_data; ++ /* Public key context for sign/verify */ ++ EVP_PKEY_CTX *pctx; ++ /* Update function: usually copied from EVP_MD */ ++ int (*update)(EVP_MD_CTX *ctx,const void *data,size_t count); ++ } /* EVP_MD_CTX */; ++ ++/* values for EVP_MD_CTX flags */ ++ ++#define EVP_MD_CTX_FLAG_ONESHOT 0x0001 /* digest update will be called ++ * once only */ ++#define EVP_MD_CTX_FLAG_CLEANED 0x0002 /* context has already been ++ * cleaned */ ++#define EVP_MD_CTX_FLAG_REUSE 0x0004 /* Don't free up ctx->md_data ++ * in EVP_MD_CTX_cleanup */ ++/* FIPS and pad options are ignored in 1.0.0, definitions are here ++ * so we don't accidentally reuse the values for other purposes. ++ */ ++ ++#define EVP_MD_CTX_FLAG_NON_FIPS_ALLOW 0x0008 /* Allow use of non FIPS digest ++ * in FIPS mode */ ++ ++/* The following PAD options are also currently ignored in 1.0.0, digest ++ * parameters are handled through EVP_DigestSign*() and EVP_DigestVerify*() ++ * instead. ++ */ ++#define EVP_MD_CTX_FLAG_PAD_MASK 0xF0 /* RSA mode to use */ ++#define EVP_MD_CTX_FLAG_PAD_PKCS1 0x00 /* PKCS#1 v1.5 mode */ ++#define EVP_MD_CTX_FLAG_PAD_X931 0x10 /* X9.31 mode */ ++#define EVP_MD_CTX_FLAG_PAD_PSS 0x20 /* PSS mode */ ++ ++#define EVP_MD_CTX_FLAG_NO_INIT 0x0100 /* Don't initialize md_data */ ++ ++struct evp_cipher_st ++ { ++ int nid; ++ int block_size; ++ int key_len; /* Default value for variable length ciphers */ ++ int iv_len; ++ unsigned long flags; /* Various flags */ ++ int (*init)(EVP_CIPHER_CTX *ctx, const unsigned char *key, ++ const unsigned char *iv, int enc); /* init key */ ++ int (*do_cipher)(EVP_CIPHER_CTX *ctx, unsigned char *out, ++ const unsigned char *in, size_t inl);/* encrypt/decrypt data */ ++ int (*cleanup)(EVP_CIPHER_CTX *); /* cleanup ctx */ ++ int ctx_size; /* how big ctx->cipher_data needs to be */ ++ int (*set_asn1_parameters)(EVP_CIPHER_CTX *, ASN1_TYPE *); /* Populate a ASN1_TYPE with parameters */ ++ int (*get_asn1_parameters)(EVP_CIPHER_CTX *, ASN1_TYPE *); /* Get parameters from a ASN1_TYPE */ ++ int (*ctrl)(EVP_CIPHER_CTX *, int type, int arg, void *ptr); /* Miscellaneous operations */ ++ void *app_data; /* Application data */ ++ } /* EVP_CIPHER */; ++ ++/* Values for cipher flags */ ++ ++/* Modes for ciphers */ ++ ++#define EVP_CIPH_STREAM_CIPHER 0x0 ++#define EVP_CIPH_ECB_MODE 0x1 ++#define EVP_CIPH_CBC_MODE 0x2 ++#define EVP_CIPH_CFB_MODE 0x3 ++#define EVP_CIPH_OFB_MODE 0x4 ++#define EVP_CIPH_MODE 0xF0007 ++/* Set if variable length cipher */ ++#define EVP_CIPH_VARIABLE_LENGTH 0x8 ++/* Set if the iv handling should be done by the cipher itself */ ++#define EVP_CIPH_CUSTOM_IV 0x10 ++/* Set if the cipher's init() function should be called if key is NULL */ ++#define EVP_CIPH_ALWAYS_CALL_INIT 0x20 ++/* Call ctrl() to init cipher parameters */ ++#define EVP_CIPH_CTRL_INIT 0x40 ++/* Don't use standard key length function */ ++#define EVP_CIPH_CUSTOM_KEY_LENGTH 0x80 ++/* Don't use standard block padding */ ++#define EVP_CIPH_NO_PADDING 0x100 ++/* cipher handles random key generation */ ++#define EVP_CIPH_RAND_KEY 0x200 ++/* cipher has its own additional copying logic */ ++#define EVP_CIPH_CUSTOM_COPY 0x400 ++/* Allow use default ASN1 get/set iv */ ++#define EVP_CIPH_FLAG_DEFAULT_ASN1 0x1000 ++/* Buffer length in bits not bytes: CFB1 mode only */ ++#define EVP_CIPH_FLAG_LENGTH_BITS 0x2000 ++ ++/* ctrl() values */ ++ ++#define EVP_CTRL_INIT 0x0 ++#define EVP_CTRL_SET_KEY_LENGTH 0x1 ++#define EVP_CTRL_GET_RC2_KEY_BITS 0x2 ++#define EVP_CTRL_SET_RC2_KEY_BITS 0x3 ++#define EVP_CTRL_GET_RC5_ROUNDS 0x4 ++#define EVP_CTRL_SET_RC5_ROUNDS 0x5 ++#define EVP_CTRL_RAND_KEY 0x6 ++#define EVP_CTRL_PBE_PRF_NID 0x7 ++#define EVP_CTRL_COPY 0x8 ++ ++typedef struct evp_cipher_info_st ++ { ++ const EVP_CIPHER *cipher; ++ unsigned char iv[EVP_MAX_IV_LENGTH]; ++ } EVP_CIPHER_INFO; ++ ++struct evp_cipher_ctx_st ++ { ++ const EVP_CIPHER *cipher; ++ ENGINE *engine; /* functional reference if 'cipher' is ENGINE-provided */ ++ int encrypt; /* encrypt or decrypt */ ++ int buf_len; /* number we have left */ ++ ++ unsigned char oiv[EVP_MAX_IV_LENGTH]; /* original iv */ ++ unsigned char iv[EVP_MAX_IV_LENGTH]; /* working iv */ ++ unsigned char buf[EVP_MAX_BLOCK_LENGTH];/* saved partial block */ ++ int num; /* used by cfb/ofb mode */ ++ ++ void *app_data; /* application stuff */ ++ int key_len; /* May change for variable length cipher */ ++ unsigned long flags; /* Various flags */ ++ void *cipher_data; /* per EVP data */ ++ int final_used; ++ int block_mask; ++ unsigned char final[EVP_MAX_BLOCK_LENGTH];/* possible final block */ ++ } /* EVP_CIPHER_CTX */; ++ ++typedef struct evp_Encode_Ctx_st ++ { ++ int num; /* number saved in a partial encode/decode */ ++ int length; /* The length is either the output line length ++ * (in input bytes) or the shortest input line ++ * length that is ok. Once decoding begins, ++ * the length is adjusted up each time a longer ++ * line is decoded */ ++ unsigned char enc_data[80]; /* data to encode */ ++ int line_num; /* number read on current line */ ++ int expect_nl; ++ } EVP_ENCODE_CTX; ++ ++/* Password based encryption function */ ++typedef int (EVP_PBE_KEYGEN)(EVP_CIPHER_CTX *ctx, const char *pass, int passlen, ++ ASN1_TYPE *param, const EVP_CIPHER *cipher, ++ const EVP_MD *md, int en_de); ++ ++#ifndef OPENSSL_NO_RSA ++#define EVP_PKEY_assign_RSA(pkey,rsa) EVP_PKEY_assign((pkey),EVP_PKEY_RSA,\ ++ (char *)(rsa)) ++#endif ++ ++#ifndef OPENSSL_NO_DSA ++#define EVP_PKEY_assign_DSA(pkey,dsa) EVP_PKEY_assign((pkey),EVP_PKEY_DSA,\ ++ (char *)(dsa)) ++#endif ++ ++#ifndef OPENSSL_NO_DH ++#define EVP_PKEY_assign_DH(pkey,dh) EVP_PKEY_assign((pkey),EVP_PKEY_DH,\ ++ (char *)(dh)) ++#endif ++ ++#ifndef OPENSSL_NO_EC ++#define EVP_PKEY_assign_EC_KEY(pkey,eckey) EVP_PKEY_assign((pkey),EVP_PKEY_EC,\ ++ (char *)(eckey)) ++#endif ++ ++/* Add some extra combinations */ ++#define EVP_get_digestbynid(a) EVP_get_digestbyname(OBJ_nid2sn(a)) ++#define EVP_get_digestbyobj(a) EVP_get_digestbynid(OBJ_obj2nid(a)) ++#define EVP_get_cipherbynid(a) EVP_get_cipherbyname(OBJ_nid2sn(a)) ++#define EVP_get_cipherbyobj(a) EVP_get_cipherbynid(OBJ_obj2nid(a)) ++ ++int EVP_MD_type(const EVP_MD *md); ++#define EVP_MD_nid(e) EVP_MD_type(e) ++#define EVP_MD_name(e) OBJ_nid2sn(EVP_MD_nid(e)) ++int EVP_MD_pkey_type(const EVP_MD *md); ++int EVP_MD_size(const EVP_MD *md); ++int EVP_MD_block_size(const EVP_MD *md); ++unsigned long EVP_MD_flags(const EVP_MD *md); ++ ++const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx); ++#define EVP_MD_CTX_size(e) EVP_MD_size(EVP_MD_CTX_md(e)) ++#define EVP_MD_CTX_block_size(e) EVP_MD_block_size(EVP_MD_CTX_md(e)) ++#define EVP_MD_CTX_type(e) EVP_MD_type(EVP_MD_CTX_md(e)) ++ ++int EVP_CIPHER_nid(const EVP_CIPHER *cipher); ++#define EVP_CIPHER_name(e) OBJ_nid2sn(EVP_CIPHER_nid(e)) ++int EVP_CIPHER_block_size(const EVP_CIPHER *cipher); ++int EVP_CIPHER_key_length(const EVP_CIPHER *cipher); ++int EVP_CIPHER_iv_length(const EVP_CIPHER *cipher); ++unsigned long EVP_CIPHER_flags(const EVP_CIPHER *cipher); ++#define EVP_CIPHER_mode(e) (EVP_CIPHER_flags(e) & EVP_CIPH_MODE) ++ ++const EVP_CIPHER * EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX *ctx); ++int EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx); ++int EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx); ++int EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx); ++int EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx); ++int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in); ++void * EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx); ++void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data); ++#define EVP_CIPHER_CTX_type(c) EVP_CIPHER_type(EVP_CIPHER_CTX_cipher(c)) ++unsigned long EVP_CIPHER_CTX_flags(const EVP_CIPHER_CTX *ctx); ++#define EVP_CIPHER_CTX_mode(e) (EVP_CIPHER_CTX_flags(e) & EVP_CIPH_MODE) ++ ++#define EVP_ENCODE_LENGTH(l) (((l+2)/3*4)+(l/48+1)*2+80) ++#define EVP_DECODE_LENGTH(l) ((l+3)/4*3+80) ++ ++#define EVP_SignInit_ex(a,b,c) EVP_DigestInit_ex(a,b,c) ++#define EVP_SignInit(a,b) EVP_DigestInit(a,b) ++#define EVP_SignUpdate(a,b,c) EVP_DigestUpdate(a,b,c) ++#define EVP_VerifyInit_ex(a,b,c) EVP_DigestInit_ex(a,b,c) ++#define EVP_VerifyInit(a,b) EVP_DigestInit(a,b) ++#define EVP_VerifyUpdate(a,b,c) EVP_DigestUpdate(a,b,c) ++#define EVP_OpenUpdate(a,b,c,d,e) EVP_DecryptUpdate(a,b,c,d,e) ++#define EVP_SealUpdate(a,b,c,d,e) EVP_EncryptUpdate(a,b,c,d,e) ++#define EVP_DigestSignUpdate(a,b,c) EVP_DigestUpdate(a,b,c) ++#define EVP_DigestVerifyUpdate(a,b,c) EVP_DigestUpdate(a,b,c) ++ ++#ifdef CONST_STRICT ++void BIO_set_md(BIO *,const EVP_MD *md); ++#else ++# define BIO_set_md(b,md) BIO_ctrl(b,BIO_C_SET_MD,0,(char *)md) ++#endif ++#define BIO_get_md(b,mdp) BIO_ctrl(b,BIO_C_GET_MD,0,(char *)mdp) ++#define BIO_get_md_ctx(b,mdcp) BIO_ctrl(b,BIO_C_GET_MD_CTX,0,(char *)mdcp) ++#define BIO_set_md_ctx(b,mdcp) BIO_ctrl(b,BIO_C_SET_MD_CTX,0,(char *)mdcp) ++#define BIO_get_cipher_status(b) BIO_ctrl(b,BIO_C_GET_CIPHER_STATUS,0,NULL) ++#define BIO_get_cipher_ctx(b,c_pp) BIO_ctrl(b,BIO_C_GET_CIPHER_CTX,0,(char *)c_pp) ++ ++int EVP_Cipher(EVP_CIPHER_CTX *c, ++ unsigned char *out, ++ const unsigned char *in, ++ unsigned int inl); ++ ++#define EVP_add_cipher_alias(n,alias) \ ++ OBJ_NAME_add((alias),OBJ_NAME_TYPE_CIPHER_METH|OBJ_NAME_ALIAS,(n)) ++#define EVP_add_digest_alias(n,alias) \ ++ OBJ_NAME_add((alias),OBJ_NAME_TYPE_MD_METH|OBJ_NAME_ALIAS,(n)) ++#define EVP_delete_cipher_alias(alias) \ ++ OBJ_NAME_remove(alias,OBJ_NAME_TYPE_CIPHER_METH|OBJ_NAME_ALIAS); ++#define EVP_delete_digest_alias(alias) \ ++ OBJ_NAME_remove(alias,OBJ_NAME_TYPE_MD_METH|OBJ_NAME_ALIAS); ++ ++void EVP_MD_CTX_init(EVP_MD_CTX *ctx); ++int EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx); ++EVP_MD_CTX *EVP_MD_CTX_create(void); ++void EVP_MD_CTX_destroy(EVP_MD_CTX *ctx); ++int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out,const EVP_MD_CTX *in); ++void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags); ++void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags); ++int EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx,int flags); ++int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ENGINE *impl); ++int EVP_DigestUpdate(EVP_MD_CTX *ctx,const void *d, ++ size_t cnt); ++int EVP_DigestFinal_ex(EVP_MD_CTX *ctx,unsigned char *md,unsigned int *s); ++int EVP_Digest(const void *data, size_t count, ++ unsigned char *md, unsigned int *size, const EVP_MD *type, ENGINE *impl); ++ ++int EVP_MD_CTX_copy(EVP_MD_CTX *out,const EVP_MD_CTX *in); ++int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type); ++int EVP_DigestFinal(EVP_MD_CTX *ctx,unsigned char *md,unsigned int *s); ++ ++int EVP_read_pw_string(char *buf,int length,const char *prompt,int verify); ++int EVP_read_pw_string_min(char *buf,int minlen,int maxlen,const char *prompt,int verify); ++void EVP_set_pw_prompt(const char *prompt); ++char * EVP_get_pw_prompt(void); ++ ++int EVP_BytesToKey(const EVP_CIPHER *type,const EVP_MD *md, ++ const unsigned char *salt, const unsigned char *data, ++ int datal, int count, unsigned char *key,unsigned char *iv); ++ ++void EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX *ctx, int flags); ++void EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX *ctx, int flags); ++int EVP_CIPHER_CTX_test_flags(const EVP_CIPHER_CTX *ctx,int flags); ++ ++int EVP_EncryptInit(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *cipher, ++ const unsigned char *key, const unsigned char *iv); ++int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *cipher, ENGINE *impl, ++ const unsigned char *key, const unsigned char *iv); ++int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, ++ int *outl, const unsigned char *in, int inl); ++int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl); ++int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl); ++ ++int EVP_DecryptInit(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *cipher, ++ const unsigned char *key, const unsigned char *iv); ++int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *cipher, ENGINE *impl, ++ const unsigned char *key, const unsigned char *iv); ++int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, ++ int *outl, const unsigned char *in, int inl); ++int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl); ++int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl); ++ ++int EVP_CipherInit(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *cipher, ++ const unsigned char *key,const unsigned char *iv, ++ int enc); ++int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *cipher, ENGINE *impl, ++ const unsigned char *key,const unsigned char *iv, ++ int enc); ++int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, ++ int *outl, const unsigned char *in, int inl); ++int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl); ++int EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm, int *outl); ++ ++int EVP_SignFinal(EVP_MD_CTX *ctx,unsigned char *md,unsigned int *s, ++ EVP_PKEY *pkey); ++ ++int EVP_VerifyFinal(EVP_MD_CTX *ctx,const unsigned char *sigbuf, ++ unsigned int siglen,EVP_PKEY *pkey); ++ ++int EVP_DigestSignInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, ++ const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey); ++int EVP_DigestSignFinal(EVP_MD_CTX *ctx, ++ unsigned char *sigret, size_t *siglen); ++ ++int EVP_DigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, ++ const EVP_MD *type, ENGINE *e, EVP_PKEY *pkey); ++int EVP_DigestVerifyFinal(EVP_MD_CTX *ctx, ++ unsigned char *sig, size_t siglen); ++ ++int EVP_OpenInit(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *type, ++ const unsigned char *ek, int ekl, const unsigned char *iv, ++ EVP_PKEY *priv); ++int EVP_OpenFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl); ++ ++int EVP_SealInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type, ++ unsigned char **ek, int *ekl, unsigned char *iv, ++ EVP_PKEY **pubk, int npubk); ++int EVP_SealFinal(EVP_CIPHER_CTX *ctx,unsigned char *out,int *outl); ++ ++void EVP_EncodeInit(EVP_ENCODE_CTX *ctx); ++void EVP_EncodeUpdate(EVP_ENCODE_CTX *ctx,unsigned char *out,int *outl, ++ const unsigned char *in,int inl); ++void EVP_EncodeFinal(EVP_ENCODE_CTX *ctx,unsigned char *out,int *outl); ++int EVP_EncodeBlock(unsigned char *t, const unsigned char *f, int n); ++ ++void EVP_DecodeInit(EVP_ENCODE_CTX *ctx); ++int EVP_DecodeUpdate(EVP_ENCODE_CTX *ctx,unsigned char *out,int *outl, ++ const unsigned char *in, int inl); ++int EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, unsigned ++ char *out, int *outl); ++int EVP_DecodeBlock(unsigned char *t, const unsigned char *f, int n); ++ ++void EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *a); ++int EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *a); ++EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void); ++void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *a); ++int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *x, int keylen); ++int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *c, int pad); ++int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr); ++int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key); ++ ++#ifndef OPENSSL_NO_BIO ++BIO_METHOD *BIO_f_md(void); ++BIO_METHOD *BIO_f_base64(void); ++BIO_METHOD *BIO_f_cipher(void); ++BIO_METHOD *BIO_f_reliable(void); ++void BIO_set_cipher(BIO *b,const EVP_CIPHER *c,const unsigned char *k, ++ const unsigned char *i, int enc); ++#endif ++ ++const EVP_MD *EVP_md_null(void); ++#ifndef OPENSSL_NO_MD2 ++const EVP_MD *EVP_md2(void); ++#endif ++#ifndef OPENSSL_NO_MD4 ++const EVP_MD *EVP_md4(void); ++#endif ++#ifndef OPENSSL_NO_MD5 ++const EVP_MD *EVP_md5(void); ++#endif ++#ifndef OPENSSL_NO_SHA ++const EVP_MD *EVP_sha(void); ++const EVP_MD *EVP_sha1(void); ++const EVP_MD *EVP_dss(void); ++const EVP_MD *EVP_dss1(void); ++const EVP_MD *EVP_ecdsa(void); ++#endif ++#ifndef OPENSSL_NO_SHA256 ++const EVP_MD *EVP_sha224(void); ++const EVP_MD *EVP_sha256(void); ++#endif ++#ifndef OPENSSL_NO_SHA512 ++const EVP_MD *EVP_sha384(void); ++const EVP_MD *EVP_sha512(void); ++#endif ++#ifndef OPENSSL_NO_MDC2 ++const EVP_MD *EVP_mdc2(void); ++#endif ++#ifndef OPENSSL_NO_RIPEMD ++const EVP_MD *EVP_ripemd160(void); ++#endif ++#ifndef OPENSSL_NO_WHIRLPOOL ++const EVP_MD *EVP_whirlpool(void); ++#endif ++const EVP_CIPHER *EVP_enc_null(void); /* does nothing :-) */ ++#ifndef OPENSSL_NO_DES ++const EVP_CIPHER *EVP_des_ecb(void); ++const EVP_CIPHER *EVP_des_ede(void); ++const EVP_CIPHER *EVP_des_ede3(void); ++const EVP_CIPHER *EVP_des_ede_ecb(void); ++const EVP_CIPHER *EVP_des_ede3_ecb(void); ++const EVP_CIPHER *EVP_des_cfb64(void); ++# define EVP_des_cfb EVP_des_cfb64 ++const EVP_CIPHER *EVP_des_cfb1(void); ++const EVP_CIPHER *EVP_des_cfb8(void); ++const EVP_CIPHER *EVP_des_ede_cfb64(void); ++# define EVP_des_ede_cfb EVP_des_ede_cfb64 ++#if 0 ++const EVP_CIPHER *EVP_des_ede_cfb1(void); ++const EVP_CIPHER *EVP_des_ede_cfb8(void); ++#endif ++const EVP_CIPHER *EVP_des_ede3_cfb64(void); ++# define EVP_des_ede3_cfb EVP_des_ede3_cfb64 ++const EVP_CIPHER *EVP_des_ede3_cfb1(void); ++const EVP_CIPHER *EVP_des_ede3_cfb8(void); ++const EVP_CIPHER *EVP_des_ofb(void); ++const EVP_CIPHER *EVP_des_ede_ofb(void); ++const EVP_CIPHER *EVP_des_ede3_ofb(void); ++const EVP_CIPHER *EVP_des_cbc(void); ++const EVP_CIPHER *EVP_des_ede_cbc(void); ++const EVP_CIPHER *EVP_des_ede3_cbc(void); ++const EVP_CIPHER *EVP_desx_cbc(void); ++/* This should now be supported through the dev_crypto ENGINE. But also, why are ++ * rc4 and md5 declarations made here inside a "NO_DES" precompiler branch? */ ++#if 0 ++# ifdef OPENSSL_OPENBSD_DEV_CRYPTO ++const EVP_CIPHER *EVP_dev_crypto_des_ede3_cbc(void); ++const EVP_CIPHER *EVP_dev_crypto_rc4(void); ++const EVP_MD *EVP_dev_crypto_md5(void); ++# endif ++#endif ++#endif ++#ifndef OPENSSL_NO_RC4 ++const EVP_CIPHER *EVP_rc4(void); ++const EVP_CIPHER *EVP_rc4_40(void); ++#endif ++#ifndef OPENSSL_NO_IDEA ++const EVP_CIPHER *EVP_idea_ecb(void); ++const EVP_CIPHER *EVP_idea_cfb64(void); ++# define EVP_idea_cfb EVP_idea_cfb64 ++const EVP_CIPHER *EVP_idea_ofb(void); ++const EVP_CIPHER *EVP_idea_cbc(void); ++#endif ++#ifndef OPENSSL_NO_RC2 ++const EVP_CIPHER *EVP_rc2_ecb(void); ++const EVP_CIPHER *EVP_rc2_cbc(void); ++const EVP_CIPHER *EVP_rc2_40_cbc(void); ++const EVP_CIPHER *EVP_rc2_64_cbc(void); ++const EVP_CIPHER *EVP_rc2_cfb64(void); ++# define EVP_rc2_cfb EVP_rc2_cfb64 ++const EVP_CIPHER *EVP_rc2_ofb(void); ++#endif ++#ifndef OPENSSL_NO_BF ++const EVP_CIPHER *EVP_bf_ecb(void); ++const EVP_CIPHER *EVP_bf_cbc(void); ++const EVP_CIPHER *EVP_bf_cfb64(void); ++# define EVP_bf_cfb EVP_bf_cfb64 ++const EVP_CIPHER *EVP_bf_ofb(void); ++#endif ++#ifndef OPENSSL_NO_CAST ++const EVP_CIPHER *EVP_cast5_ecb(void); ++const EVP_CIPHER *EVP_cast5_cbc(void); ++const EVP_CIPHER *EVP_cast5_cfb64(void); ++# define EVP_cast5_cfb EVP_cast5_cfb64 ++const EVP_CIPHER *EVP_cast5_ofb(void); ++#endif ++#ifndef OPENSSL_NO_RC5 ++const EVP_CIPHER *EVP_rc5_32_12_16_cbc(void); ++const EVP_CIPHER *EVP_rc5_32_12_16_ecb(void); ++const EVP_CIPHER *EVP_rc5_32_12_16_cfb64(void); ++# define EVP_rc5_32_12_16_cfb EVP_rc5_32_12_16_cfb64 ++const EVP_CIPHER *EVP_rc5_32_12_16_ofb(void); ++#endif ++#ifndef OPENSSL_NO_AES ++const EVP_CIPHER *EVP_aes_128_ecb(void); ++const EVP_CIPHER *EVP_aes_128_cbc(void); ++const EVP_CIPHER *EVP_aes_128_cfb1(void); ++const EVP_CIPHER *EVP_aes_128_cfb8(void); ++const EVP_CIPHER *EVP_aes_128_cfb128(void); ++# define EVP_aes_128_cfb EVP_aes_128_cfb128 ++const EVP_CIPHER *EVP_aes_128_ofb(void); ++#if 0 ++const EVP_CIPHER *EVP_aes_128_ctr(void); ++#endif ++const EVP_CIPHER *EVP_aes_192_ecb(void); ++const EVP_CIPHER *EVP_aes_192_cbc(void); ++const EVP_CIPHER *EVP_aes_192_cfb1(void); ++const EVP_CIPHER *EVP_aes_192_cfb8(void); ++const EVP_CIPHER *EVP_aes_192_cfb128(void); ++# define EVP_aes_192_cfb EVP_aes_192_cfb128 ++const EVP_CIPHER *EVP_aes_192_ofb(void); ++#if 0 ++const EVP_CIPHER *EVP_aes_192_ctr(void); ++#endif ++const EVP_CIPHER *EVP_aes_256_ecb(void); ++const EVP_CIPHER *EVP_aes_256_cbc(void); ++const EVP_CIPHER *EVP_aes_256_cfb1(void); ++const EVP_CIPHER *EVP_aes_256_cfb8(void); ++const EVP_CIPHER *EVP_aes_256_cfb128(void); ++# define EVP_aes_256_cfb EVP_aes_256_cfb128 ++const EVP_CIPHER *EVP_aes_256_ofb(void); ++#if 0 ++const EVP_CIPHER *EVP_aes_256_ctr(void); ++#endif ++#endif ++#ifndef OPENSSL_NO_CAMELLIA ++const EVP_CIPHER *EVP_camellia_128_ecb(void); ++const EVP_CIPHER *EVP_camellia_128_cbc(void); ++const EVP_CIPHER *EVP_camellia_128_cfb1(void); ++const EVP_CIPHER *EVP_camellia_128_cfb8(void); ++const EVP_CIPHER *EVP_camellia_128_cfb128(void); ++# define EVP_camellia_128_cfb EVP_camellia_128_cfb128 ++const EVP_CIPHER *EVP_camellia_128_ofb(void); ++const EVP_CIPHER *EVP_camellia_192_ecb(void); ++const EVP_CIPHER *EVP_camellia_192_cbc(void); ++const EVP_CIPHER *EVP_camellia_192_cfb1(void); ++const EVP_CIPHER *EVP_camellia_192_cfb8(void); ++const EVP_CIPHER *EVP_camellia_192_cfb128(void); ++# define EVP_camellia_192_cfb EVP_camellia_192_cfb128 ++const EVP_CIPHER *EVP_camellia_192_ofb(void); ++const EVP_CIPHER *EVP_camellia_256_ecb(void); ++const EVP_CIPHER *EVP_camellia_256_cbc(void); ++const EVP_CIPHER *EVP_camellia_256_cfb1(void); ++const EVP_CIPHER *EVP_camellia_256_cfb8(void); ++const EVP_CIPHER *EVP_camellia_256_cfb128(void); ++# define EVP_camellia_256_cfb EVP_camellia_256_cfb128 ++const EVP_CIPHER *EVP_camellia_256_ofb(void); ++#endif ++ ++#ifndef OPENSSL_NO_SEED ++const EVP_CIPHER *EVP_seed_ecb(void); ++const EVP_CIPHER *EVP_seed_cbc(void); ++const EVP_CIPHER *EVP_seed_cfb128(void); ++# define EVP_seed_cfb EVP_seed_cfb128 ++const EVP_CIPHER *EVP_seed_ofb(void); ++#endif ++ ++void OPENSSL_add_all_algorithms_noconf(void); ++void OPENSSL_add_all_algorithms_conf(void); ++ ++#ifdef OPENSSL_LOAD_CONF ++#define OpenSSL_add_all_algorithms() \ ++ OPENSSL_add_all_algorithms_conf() ++#else ++#define OpenSSL_add_all_algorithms() \ ++ OPENSSL_add_all_algorithms_noconf() ++#endif ++ ++void OpenSSL_add_all_ciphers(void); ++void OpenSSL_add_all_digests(void); ++#define SSLeay_add_all_algorithms() OpenSSL_add_all_algorithms() ++#define SSLeay_add_all_ciphers() OpenSSL_add_all_ciphers() ++#define SSLeay_add_all_digests() OpenSSL_add_all_digests() ++ ++int EVP_add_cipher(const EVP_CIPHER *cipher); ++int EVP_add_digest(const EVP_MD *digest); ++ ++const EVP_CIPHER *EVP_get_cipherbyname(const char *name); ++const EVP_MD *EVP_get_digestbyname(const char *name); ++void EVP_cleanup(void); ++ ++void EVP_CIPHER_do_all(void (*fn)(const EVP_CIPHER *ciph, ++ const char *from, const char *to, void *x), void *arg); ++void EVP_CIPHER_do_all_sorted(void (*fn)(const EVP_CIPHER *ciph, ++ const char *from, const char *to, void *x), void *arg); ++ ++void EVP_MD_do_all(void (*fn)(const EVP_MD *ciph, ++ const char *from, const char *to, void *x), void *arg); ++void EVP_MD_do_all_sorted(void (*fn)(const EVP_MD *ciph, ++ const char *from, const char *to, void *x), void *arg); ++ ++int EVP_PKEY_decrypt_old(unsigned char *dec_key, ++ const unsigned char *enc_key,int enc_key_len, ++ EVP_PKEY *private_key); ++int EVP_PKEY_encrypt_old(unsigned char *enc_key, ++ const unsigned char *key,int key_len, ++ EVP_PKEY *pub_key); ++int EVP_PKEY_type(int type); ++int EVP_PKEY_id(const EVP_PKEY *pkey); ++int EVP_PKEY_base_id(const EVP_PKEY *pkey); ++int EVP_PKEY_bits(EVP_PKEY *pkey); ++int EVP_PKEY_size(EVP_PKEY *pkey); ++int EVP_PKEY_set_type(EVP_PKEY *pkey,int type); ++int EVP_PKEY_set_type_str(EVP_PKEY *pkey, const char *str, int len); ++int EVP_PKEY_assign(EVP_PKEY *pkey,int type,void *key); ++void * EVP_PKEY_get0(EVP_PKEY *pkey); ++ ++#ifndef OPENSSL_NO_RSA ++struct rsa_st; ++int EVP_PKEY_set1_RSA(EVP_PKEY *pkey,struct rsa_st *key); ++struct rsa_st *EVP_PKEY_get1_RSA(EVP_PKEY *pkey); ++#endif ++#ifndef OPENSSL_NO_DSA ++struct dsa_st; ++int EVP_PKEY_set1_DSA(EVP_PKEY *pkey,struct dsa_st *key); ++struct dsa_st *EVP_PKEY_get1_DSA(EVP_PKEY *pkey); ++#endif ++#ifndef OPENSSL_NO_DH ++struct dh_st; ++int EVP_PKEY_set1_DH(EVP_PKEY *pkey,struct dh_st *key); ++struct dh_st *EVP_PKEY_get1_DH(EVP_PKEY *pkey); ++#endif ++#ifndef OPENSSL_NO_EC ++struct ec_key_st; ++int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey,struct ec_key_st *key); ++struct ec_key_st *EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey); ++#endif ++ ++EVP_PKEY * EVP_PKEY_new(void); ++void EVP_PKEY_free(EVP_PKEY *pkey); ++ ++EVP_PKEY * d2i_PublicKey(int type,EVP_PKEY **a, const unsigned char **pp, ++ long length); ++int i2d_PublicKey(EVP_PKEY *a, unsigned char **pp); ++ ++EVP_PKEY * d2i_PrivateKey(int type,EVP_PKEY **a, const unsigned char **pp, ++ long length); ++EVP_PKEY * d2i_AutoPrivateKey(EVP_PKEY **a, const unsigned char **pp, ++ long length); ++int i2d_PrivateKey(EVP_PKEY *a, unsigned char **pp); ++ ++int EVP_PKEY_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from); ++int EVP_PKEY_missing_parameters(const EVP_PKEY *pkey); ++int EVP_PKEY_save_parameters(EVP_PKEY *pkey,int mode); ++int EVP_PKEY_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b); ++ ++int EVP_PKEY_cmp(const EVP_PKEY *a, const EVP_PKEY *b); ++ ++int EVP_PKEY_print_public(BIO *out, const EVP_PKEY *pkey, ++ int indent, ASN1_PCTX *pctx); ++int EVP_PKEY_print_private(BIO *out, const EVP_PKEY *pkey, ++ int indent, ASN1_PCTX *pctx); ++int EVP_PKEY_print_params(BIO *out, const EVP_PKEY *pkey, ++ int indent, ASN1_PCTX *pctx); ++ ++int EVP_PKEY_get_default_digest_nid(EVP_PKEY *pkey, int *pnid); ++ ++int EVP_CIPHER_type(const EVP_CIPHER *ctx); ++ ++/* calls methods */ ++int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type); ++int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type); ++ ++/* These are used by EVP_CIPHER methods */ ++int EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX *c,ASN1_TYPE *type); ++int EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c,ASN1_TYPE *type); ++ ++/* PKCS5 password based encryption */ ++int PKCS5_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen, ++ ASN1_TYPE *param, const EVP_CIPHER *cipher, const EVP_MD *md, ++ int en_de); ++int PKCS5_PBKDF2_HMAC_SHA1(const char *pass, int passlen, ++ const unsigned char *salt, int saltlen, int iter, ++ int keylen, unsigned char *out); ++int PKCS5_PBKDF2_HMAC(const char *pass, int passlen, ++ const unsigned char *salt, int saltlen, int iter, ++ const EVP_MD *digest, ++ int keylen, unsigned char *out); ++int PKCS5_v2_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen, ++ ASN1_TYPE *param, const EVP_CIPHER *cipher, const EVP_MD *md, ++ int en_de); ++ ++void PKCS5_PBE_add(void); ++ ++int EVP_PBE_CipherInit (ASN1_OBJECT *pbe_obj, const char *pass, int passlen, ++ ASN1_TYPE *param, EVP_CIPHER_CTX *ctx, int en_de); ++ ++/* PBE type */ ++ ++/* Can appear as the outermost AlgorithmIdentifier */ ++#define EVP_PBE_TYPE_OUTER 0x0 ++/* Is an PRF type OID */ ++#define EVP_PBE_TYPE_PRF 0x1 ++ ++int EVP_PBE_alg_add_type(int pbe_type, int pbe_nid, int cipher_nid, int md_nid, ++ EVP_PBE_KEYGEN *keygen); ++int EVP_PBE_alg_add(int nid, const EVP_CIPHER *cipher, const EVP_MD *md, ++ EVP_PBE_KEYGEN *keygen); ++int EVP_PBE_find(int type, int pbe_nid, ++ int *pcnid, int *pmnid, EVP_PBE_KEYGEN **pkeygen); ++void EVP_PBE_cleanup(void); ++ ++#define ASN1_PKEY_ALIAS 0x1 ++#define ASN1_PKEY_DYNAMIC 0x2 ++#define ASN1_PKEY_SIGPARAM_NULL 0x4 ++ ++#define ASN1_PKEY_CTRL_PKCS7_SIGN 0x1 ++#define ASN1_PKEY_CTRL_PKCS7_ENCRYPT 0x2 ++#define ASN1_PKEY_CTRL_DEFAULT_MD_NID 0x3 ++#define ASN1_PKEY_CTRL_CMS_SIGN 0x5 ++#define ASN1_PKEY_CTRL_CMS_ENVELOPE 0x7 ++ ++int EVP_PKEY_asn1_get_count(void); ++const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_get0(int idx); ++const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find(ENGINE **pe, int type); ++const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find_str(ENGINE **pe, ++ const char *str, int len); ++int EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD *ameth); ++int EVP_PKEY_asn1_add_alias(int to, int from); ++int EVP_PKEY_asn1_get0_info(int *ppkey_id, int *pkey_base_id, int *ppkey_flags, ++ const char **pinfo, const char **ppem_str, ++ const EVP_PKEY_ASN1_METHOD *ameth); ++ ++const EVP_PKEY_ASN1_METHOD* EVP_PKEY_get0_asn1(EVP_PKEY *pkey); ++EVP_PKEY_ASN1_METHOD* EVP_PKEY_asn1_new(int id, int flags, ++ const char *pem_str, const char *info); ++void EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD *dst, ++ const EVP_PKEY_ASN1_METHOD *src); ++void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth); ++void EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth, ++ int (*pub_decode)(EVP_PKEY *pk, X509_PUBKEY *pub), ++ int (*pub_encode)(X509_PUBKEY *pub, const EVP_PKEY *pk), ++ int (*pub_cmp)(const EVP_PKEY *a, const EVP_PKEY *b), ++ int (*pub_print)(BIO *out, const EVP_PKEY *pkey, int indent, ++ ASN1_PCTX *pctx), ++ int (*pkey_size)(const EVP_PKEY *pk), ++ int (*pkey_bits)(const EVP_PKEY *pk)); ++void EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth, ++ int (*priv_decode)(EVP_PKEY *pk, PKCS8_PRIV_KEY_INFO *p8inf), ++ int (*priv_encode)(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pk), ++ int (*priv_print)(BIO *out, const EVP_PKEY *pkey, int indent, ++ ASN1_PCTX *pctx)); ++void EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth, ++ int (*param_decode)(EVP_PKEY *pkey, ++ const unsigned char **pder, int derlen), ++ int (*param_encode)(const EVP_PKEY *pkey, unsigned char **pder), ++ int (*param_missing)(const EVP_PKEY *pk), ++ int (*param_copy)(EVP_PKEY *to, const EVP_PKEY *from), ++ int (*param_cmp)(const EVP_PKEY *a, const EVP_PKEY *b), ++ int (*param_print)(BIO *out, const EVP_PKEY *pkey, int indent, ++ ASN1_PCTX *pctx)); ++ ++void EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth, ++ void (*pkey_free)(EVP_PKEY *pkey)); ++void EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth, ++ int (*pkey_ctrl)(EVP_PKEY *pkey, int op, ++ long arg1, void *arg2)); ++ ++ ++#define EVP_PKEY_OP_UNDEFINED 0 ++#define EVP_PKEY_OP_PARAMGEN (1<<1) ++#define EVP_PKEY_OP_KEYGEN (1<<2) ++#define EVP_PKEY_OP_SIGN (1<<3) ++#define EVP_PKEY_OP_VERIFY (1<<4) ++#define EVP_PKEY_OP_VERIFYRECOVER (1<<5) ++#define EVP_PKEY_OP_SIGNCTX (1<<6) ++#define EVP_PKEY_OP_VERIFYCTX (1<<7) ++#define EVP_PKEY_OP_ENCRYPT (1<<8) ++#define EVP_PKEY_OP_DECRYPT (1<<9) ++#define EVP_PKEY_OP_DERIVE (1<<10) ++ ++#define EVP_PKEY_OP_TYPE_SIG \ ++ (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY | EVP_PKEY_OP_VERIFYRECOVER \ ++ | EVP_PKEY_OP_SIGNCTX | EVP_PKEY_OP_VERIFYCTX) ++ ++#define EVP_PKEY_OP_TYPE_CRYPT \ ++ (EVP_PKEY_OP_ENCRYPT | EVP_PKEY_OP_DECRYPT) ++ ++#define EVP_PKEY_OP_TYPE_NOGEN \ ++ (EVP_PKEY_OP_SIG | EVP_PKEY_OP_CRYPT | EVP_PKEY_OP_DERIVE) ++ ++#define EVP_PKEY_OP_TYPE_GEN \ ++ (EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN) ++ ++#define EVP_PKEY_CTX_set_signature_md(ctx, md) \ ++ EVP_PKEY_CTX_ctrl(ctx, -1, EVP_PKEY_OP_TYPE_SIG, \ ++ EVP_PKEY_CTRL_MD, 0, (void *)md) ++ ++#define EVP_PKEY_CTRL_MD 1 ++#define EVP_PKEY_CTRL_PEER_KEY 2 ++ ++#define EVP_PKEY_CTRL_PKCS7_ENCRYPT 3 ++#define EVP_PKEY_CTRL_PKCS7_DECRYPT 4 ++ ++#define EVP_PKEY_CTRL_PKCS7_SIGN 5 ++ ++#define EVP_PKEY_CTRL_SET_MAC_KEY 6 ++ ++#define EVP_PKEY_CTRL_DIGESTINIT 7 ++ ++/* Used by GOST key encryption in TLS */ ++#define EVP_PKEY_CTRL_SET_IV 8 ++ ++#define EVP_PKEY_CTRL_CMS_ENCRYPT 9 ++#define EVP_PKEY_CTRL_CMS_DECRYPT 10 ++#define EVP_PKEY_CTRL_CMS_SIGN 11 ++ ++#define EVP_PKEY_ALG_CTRL 0x1000 ++ ++ ++#define EVP_PKEY_FLAG_AUTOARGLEN 2 ++ ++const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type); ++EVP_PKEY_METHOD* EVP_PKEY_meth_new(int id, int flags); ++void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth); ++int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth); ++ ++EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e); ++EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e); ++EVP_PKEY_CTX *EVP_PKEY_CTX_dup(EVP_PKEY_CTX *ctx); ++void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx); ++ ++int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype, ++ int cmd, int p1, void *p2); ++int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx, const char *type, ++ const char *value); ++ ++int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx); ++void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen); ++ ++EVP_PKEY *EVP_PKEY_new_mac_key(int type, ENGINE *e, ++ unsigned char *key, int keylen); ++ ++void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data); ++void *EVP_PKEY_CTX_get_data(EVP_PKEY_CTX *ctx); ++EVP_PKEY *EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx); ++ ++EVP_PKEY *EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx); ++ ++void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data); ++void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx); ++ ++int EVP_PKEY_sign_init(EVP_PKEY_CTX *ctx); ++int EVP_PKEY_sign(EVP_PKEY_CTX *ctx, ++ unsigned char *sig, size_t *siglen, ++ const unsigned char *tbs, size_t tbslen); ++int EVP_PKEY_verify_init(EVP_PKEY_CTX *ctx); ++int EVP_PKEY_verify(EVP_PKEY_CTX *ctx, ++ const unsigned char *sig, size_t siglen, ++ const unsigned char *tbs, size_t tbslen); ++int EVP_PKEY_verify_recover_init(EVP_PKEY_CTX *ctx); ++int EVP_PKEY_verify_recover(EVP_PKEY_CTX *ctx, ++ unsigned char *rout, size_t *routlen, ++ const unsigned char *sig, size_t siglen); ++int EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx); ++int EVP_PKEY_encrypt(EVP_PKEY_CTX *ctx, ++ unsigned char *out, size_t *outlen, ++ const unsigned char *in, size_t inlen); ++int EVP_PKEY_decrypt_init(EVP_PKEY_CTX *ctx); ++int EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx, ++ unsigned char *out, size_t *outlen, ++ const unsigned char *in, size_t inlen); ++ ++int EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx); ++int EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer); ++int EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen); ++ ++typedef int EVP_PKEY_gen_cb(EVP_PKEY_CTX *ctx); ++ ++int EVP_PKEY_paramgen_init(EVP_PKEY_CTX *ctx); ++int EVP_PKEY_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey); ++int EVP_PKEY_keygen_init(EVP_PKEY_CTX *ctx); ++int EVP_PKEY_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey); ++ ++void EVP_PKEY_CTX_set_cb(EVP_PKEY_CTX *ctx, EVP_PKEY_gen_cb *cb); ++EVP_PKEY_gen_cb *EVP_PKEY_CTX_get_cb(EVP_PKEY_CTX *ctx); ++ ++int EVP_PKEY_CTX_get_keygen_info(EVP_PKEY_CTX *ctx, int idx); ++ ++void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth, ++ int (*init)(EVP_PKEY_CTX *ctx)); ++ ++void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth, ++ int (*copy)(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)); ++ ++void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth, ++ void (*cleanup)(EVP_PKEY_CTX *ctx)); ++ ++void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth, ++ int (*paramgen_init)(EVP_PKEY_CTX *ctx), ++ int (*paramgen)(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)); ++ ++void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth, ++ int (*keygen_init)(EVP_PKEY_CTX *ctx), ++ int (*keygen)(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)); ++ ++void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth, ++ int (*sign_init)(EVP_PKEY_CTX *ctx), ++ int (*sign)(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen, ++ const unsigned char *tbs, size_t tbslen)); ++ ++void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth, ++ int (*verify_init)(EVP_PKEY_CTX *ctx), ++ int (*verify)(EVP_PKEY_CTX *ctx, const unsigned char *sig, size_t siglen, ++ const unsigned char *tbs, size_t tbslen)); ++ ++void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth, ++ int (*verify_recover_init)(EVP_PKEY_CTX *ctx), ++ int (*verify_recover)(EVP_PKEY_CTX *ctx, ++ unsigned char *sig, size_t *siglen, ++ const unsigned char *tbs, size_t tbslen)); ++ ++void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth, ++ int (*signctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx), ++ int (*signctx)(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen, ++ EVP_MD_CTX *mctx)); ++ ++void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth, ++ int (*verifyctx_init)(EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx), ++ int (*verifyctx)(EVP_PKEY_CTX *ctx, const unsigned char *sig,int siglen, ++ EVP_MD_CTX *mctx)); ++ ++void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth, ++ int (*encrypt_init)(EVP_PKEY_CTX *ctx), ++ int (*encryptfn)(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen, ++ const unsigned char *in, size_t inlen)); ++ ++void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth, ++ int (*decrypt_init)(EVP_PKEY_CTX *ctx), ++ int (*decrypt)(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen, ++ const unsigned char *in, size_t inlen)); ++ ++void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth, ++ int (*derive_init)(EVP_PKEY_CTX *ctx), ++ int (*derive)(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen)); ++ ++void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth, ++ int (*ctrl)(EVP_PKEY_CTX *ctx, int type, int p1, void *p2), ++ int (*ctrl_str)(EVP_PKEY_CTX *ctx, ++ const char *type, const char *value)); ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_EVP_strings(void); ++ ++/* Error codes for the EVP functions. */ ++ ++/* Function codes. */ ++#define EVP_F_AES_INIT_KEY 133 ++#define EVP_F_CAMELLIA_INIT_KEY 159 ++#define EVP_F_D2I_PKEY 100 ++#define EVP_F_DO_SIGVER_INIT 161 ++#define EVP_F_DSAPKEY2PKCS8 134 ++#define EVP_F_DSA_PKEY2PKCS8 135 ++#define EVP_F_ECDSA_PKEY2PKCS8 129 ++#define EVP_F_ECKEY_PKEY2PKCS8 132 ++#define EVP_F_EVP_CIPHERINIT_EX 123 ++#define EVP_F_EVP_CIPHER_CTX_COPY 163 ++#define EVP_F_EVP_CIPHER_CTX_CTRL 124 ++#define EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH 122 ++#define EVP_F_EVP_DECRYPTFINAL_EX 101 ++#define EVP_F_EVP_DIGESTINIT_EX 128 ++#define EVP_F_EVP_ENCRYPTFINAL_EX 127 ++#define EVP_F_EVP_MD_CTX_COPY_EX 110 ++#define EVP_F_EVP_MD_SIZE 162 ++#define EVP_F_EVP_OPENINIT 102 ++#define EVP_F_EVP_PBE_ALG_ADD 115 ++#define EVP_F_EVP_PBE_ALG_ADD_TYPE 160 ++#define EVP_F_EVP_PBE_CIPHERINIT 116 ++#define EVP_F_EVP_PKCS82PKEY 111 ++#define EVP_F_EVP_PKCS82PKEY_BROKEN 136 ++#define EVP_F_EVP_PKEY2PKCS8_BROKEN 113 ++#define EVP_F_EVP_PKEY_COPY_PARAMETERS 103 ++#define EVP_F_EVP_PKEY_CTX_CTRL 137 ++#define EVP_F_EVP_PKEY_CTX_CTRL_STR 150 ++#define EVP_F_EVP_PKEY_CTX_DUP 156 ++#define EVP_F_EVP_PKEY_DECRYPT 104 ++#define EVP_F_EVP_PKEY_DECRYPT_INIT 138 ++#define EVP_F_EVP_PKEY_DECRYPT_OLD 151 ++#define EVP_F_EVP_PKEY_DERIVE 153 ++#define EVP_F_EVP_PKEY_DERIVE_INIT 154 ++#define EVP_F_EVP_PKEY_DERIVE_SET_PEER 155 ++#define EVP_F_EVP_PKEY_ENCRYPT 105 ++#define EVP_F_EVP_PKEY_ENCRYPT_INIT 139 ++#define EVP_F_EVP_PKEY_ENCRYPT_OLD 152 ++#define EVP_F_EVP_PKEY_GET1_DH 119 ++#define EVP_F_EVP_PKEY_GET1_DSA 120 ++#define EVP_F_EVP_PKEY_GET1_ECDSA 130 ++#define EVP_F_EVP_PKEY_GET1_EC_KEY 131 ++#define EVP_F_EVP_PKEY_GET1_RSA 121 ++#define EVP_F_EVP_PKEY_KEYGEN 146 ++#define EVP_F_EVP_PKEY_KEYGEN_INIT 147 ++#define EVP_F_EVP_PKEY_NEW 106 ++#define EVP_F_EVP_PKEY_PARAMGEN 148 ++#define EVP_F_EVP_PKEY_PARAMGEN_INIT 149 ++#define EVP_F_EVP_PKEY_SIGN 140 ++#define EVP_F_EVP_PKEY_SIGN_INIT 141 ++#define EVP_F_EVP_PKEY_VERIFY 142 ++#define EVP_F_EVP_PKEY_VERIFY_INIT 143 ++#define EVP_F_EVP_PKEY_VERIFY_RECOVER 144 ++#define EVP_F_EVP_PKEY_VERIFY_RECOVER_INIT 145 ++#define EVP_F_EVP_RIJNDAEL 126 ++#define EVP_F_EVP_SIGNFINAL 107 ++#define EVP_F_EVP_VERIFYFINAL 108 ++#define EVP_F_INT_CTX_NEW 157 ++#define EVP_F_PKCS5_PBE_KEYIVGEN 117 ++#define EVP_F_PKCS5_V2_PBE_KEYIVGEN 118 ++#define EVP_F_PKCS8_SET_BROKEN 112 ++#define EVP_F_PKEY_SET_TYPE 158 ++#define EVP_F_RC2_MAGIC_TO_METH 109 ++#define EVP_F_RC5_CTRL 125 ++ ++/* Reason codes. */ ++#define EVP_R_AES_KEY_SETUP_FAILED 143 ++#define EVP_R_ASN1_LIB 140 ++#define EVP_R_BAD_BLOCK_LENGTH 136 ++#define EVP_R_BAD_DECRYPT 100 ++#define EVP_R_BAD_KEY_LENGTH 137 ++#define EVP_R_BN_DECODE_ERROR 112 ++#define EVP_R_BN_PUBKEY_ERROR 113 ++#define EVP_R_BUFFER_TOO_SMALL 155 ++#define EVP_R_CAMELLIA_KEY_SETUP_FAILED 157 ++#define EVP_R_CIPHER_PARAMETER_ERROR 122 ++#define EVP_R_COMMAND_NOT_SUPPORTED 147 ++#define EVP_R_CTRL_NOT_IMPLEMENTED 132 ++#define EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED 133 ++#define EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH 138 ++#define EVP_R_DECODE_ERROR 114 ++#define EVP_R_DIFFERENT_KEY_TYPES 101 ++#define EVP_R_DIFFERENT_PARAMETERS 153 ++#define EVP_R_ENCODE_ERROR 115 ++#define EVP_R_EVP_PBE_CIPHERINIT_ERROR 119 ++#define EVP_R_EXPECTING_AN_RSA_KEY 127 ++#define EVP_R_EXPECTING_A_DH_KEY 128 ++#define EVP_R_EXPECTING_A_DSA_KEY 129 ++#define EVP_R_EXPECTING_A_ECDSA_KEY 141 ++#define EVP_R_EXPECTING_A_EC_KEY 142 ++#define EVP_R_INITIALIZATION_ERROR 134 ++#define EVP_R_INPUT_NOT_INITIALIZED 111 ++#define EVP_R_INVALID_DIGEST 152 ++#define EVP_R_INVALID_KEY_LENGTH 130 ++#define EVP_R_INVALID_OPERATION 148 ++#define EVP_R_IV_TOO_LARGE 102 ++#define EVP_R_KEYGEN_FAILURE 120 ++#define EVP_R_MESSAGE_DIGEST_IS_NULL 159 ++#define EVP_R_METHOD_NOT_SUPPORTED 144 ++#define EVP_R_MISSING_PARAMETERS 103 ++#define EVP_R_NO_CIPHER_SET 131 ++#define EVP_R_NO_DEFAULT_DIGEST 158 ++#define EVP_R_NO_DIGEST_SET 139 ++#define EVP_R_NO_DSA_PARAMETERS 116 ++#define EVP_R_NO_KEY_SET 154 ++#define EVP_R_NO_OPERATION_SET 149 ++#define EVP_R_NO_SIGN_FUNCTION_CONFIGURED 104 ++#define EVP_R_NO_VERIFY_FUNCTION_CONFIGURED 105 ++#define EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE 150 ++#define EVP_R_OPERATON_NOT_INITIALIZED 151 ++#define EVP_R_PKCS8_UNKNOWN_BROKEN_TYPE 117 ++#define EVP_R_PRIVATE_KEY_DECODE_ERROR 145 ++#define EVP_R_PRIVATE_KEY_ENCODE_ERROR 146 ++#define EVP_R_PUBLIC_KEY_NOT_RSA 106 ++#define EVP_R_UNKNOWN_CIPHER 160 ++#define EVP_R_UNKNOWN_DIGEST 161 ++#define EVP_R_UNKNOWN_PBE_ALGORITHM 121 ++#define EVP_R_UNSUPORTED_NUMBER_OF_ROUNDS 135 ++#define EVP_R_UNSUPPORTED_ALGORITHM 156 ++#define EVP_R_UNSUPPORTED_CIPHER 107 ++#define EVP_R_UNSUPPORTED_KEYLENGTH 123 ++#define EVP_R_UNSUPPORTED_KEY_DERIVATION_FUNCTION 124 ++#define EVP_R_UNSUPPORTED_KEY_SIZE 108 ++#define EVP_R_UNSUPPORTED_PRF 125 ++#define EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM 118 ++#define EVP_R_UNSUPPORTED_SALT_TYPE 126 ++#define EVP_R_WRONG_FINAL_BLOCK_LENGTH 109 ++#define EVP_R_WRONG_PUBLIC_KEY_TYPE 110 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/hmac.h qt.patched/include/openssl/hmac.h +--- qt.orig/include/openssl/hmac.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/hmac.h 2010-08-27 12:01:45.305782300 +0200 +@@ -0,0 +1,110 @@ ++/* crypto/hmac/hmac.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++#ifndef HEADER_HMAC_H ++#define HEADER_HMAC_H ++ ++#include ++ ++#ifdef OPENSSL_NO_HMAC ++#error HMAC is disabled. ++#endif ++ ++#include ++ ++#define HMAC_MAX_MD_CBLOCK 128 /* largest known is SHA512 */ ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++typedef struct hmac_ctx_st ++ { ++ const EVP_MD *md; ++ EVP_MD_CTX md_ctx; ++ EVP_MD_CTX i_ctx; ++ EVP_MD_CTX o_ctx; ++ unsigned int key_length; ++ unsigned char key[HMAC_MAX_MD_CBLOCK]; ++ } HMAC_CTX; ++ ++#define HMAC_size(e) (EVP_MD_size((e)->md)) ++ ++ ++void HMAC_CTX_init(HMAC_CTX *ctx); ++void HMAC_CTX_cleanup(HMAC_CTX *ctx); ++ ++#define HMAC_cleanup(ctx) HMAC_CTX_cleanup(ctx) /* deprecated */ ++ ++int HMAC_Init(HMAC_CTX *ctx, const void *key, int len, ++ const EVP_MD *md); /* deprecated */ ++int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len, ++ const EVP_MD *md, ENGINE *impl); ++int HMAC_Update(HMAC_CTX *ctx, const unsigned char *data, size_t len); ++int HMAC_Final(HMAC_CTX *ctx, unsigned char *md, unsigned int *len); ++unsigned char *HMAC(const EVP_MD *evp_md, const void *key, int key_len, ++ const unsigned char *d, size_t n, unsigned char *md, ++ unsigned int *md_len); ++int HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx); ++ ++void HMAC_CTX_set_flags(HMAC_CTX *ctx, unsigned long flags); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff -urN qt.orig/include/openssl/idea.h qt.patched/include/openssl/idea.h +--- qt.orig/include/openssl/idea.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/idea.h 2010-08-27 12:01:45.321406700 +0200 +@@ -0,0 +1,100 @@ ++/* crypto/idea/idea.h */ ++/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_IDEA_H ++#define HEADER_IDEA_H ++ ++#include /* IDEA_INT, OPENSSL_NO_IDEA */ ++ ++#ifdef OPENSSL_NO_IDEA ++#error IDEA is disabled. ++#endif ++ ++#define IDEA_ENCRYPT 1 ++#define IDEA_DECRYPT 0 ++ ++#define IDEA_BLOCK 8 ++#define IDEA_KEY_LENGTH 16 ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++typedef struct idea_key_st ++ { ++ IDEA_INT data[9][6]; ++ } IDEA_KEY_SCHEDULE; ++ ++const char *idea_options(void); ++void idea_ecb_encrypt(const unsigned char *in, unsigned char *out, ++ IDEA_KEY_SCHEDULE *ks); ++void idea_set_encrypt_key(const unsigned char *key, IDEA_KEY_SCHEDULE *ks); ++void idea_set_decrypt_key(IDEA_KEY_SCHEDULE *ek, IDEA_KEY_SCHEDULE *dk); ++void idea_cbc_encrypt(const unsigned char *in, unsigned char *out, ++ long length, IDEA_KEY_SCHEDULE *ks, unsigned char *iv,int enc); ++void idea_cfb64_encrypt(const unsigned char *in, unsigned char *out, ++ long length, IDEA_KEY_SCHEDULE *ks, unsigned char *iv, ++ int *num,int enc); ++void idea_ofb64_encrypt(const unsigned char *in, unsigned char *out, ++ long length, IDEA_KEY_SCHEDULE *ks, unsigned char *iv, int *num); ++void idea_encrypt(unsigned long *in, IDEA_KEY_SCHEDULE *ks); ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff -urN qt.orig/include/openssl/krb5_asn.h qt.patched/include/openssl/krb5_asn.h +--- qt.orig/include/openssl/krb5_asn.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/krb5_asn.h 2010-08-27 12:01:45.321406700 +0200 +@@ -0,0 +1,256 @@ ++/* krb5_asn.h */ ++/* Written by Vern Staats for the OpenSSL project, ++** using ocsp/{*.h,*asn*.c} as a starting point ++*/ ++ ++/* ==================================================================== ++ * Copyright (c) 1998-2000 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * openssl-core@openssl.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.openssl.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++ ++#ifndef HEADER_KRB5_ASN_H ++#define HEADER_KRB5_ASN_H ++ ++/* ++#include ++*/ ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++ ++/* ASN.1 from Kerberos RFC 1510 ++*/ ++ ++/* EncryptedData ::= SEQUENCE { ++** etype[0] INTEGER, -- EncryptionType ++** kvno[1] INTEGER OPTIONAL, ++** cipher[2] OCTET STRING -- ciphertext ++** } ++*/ ++typedef struct krb5_encdata_st ++ { ++ ASN1_INTEGER *etype; ++ ASN1_INTEGER *kvno; ++ ASN1_OCTET_STRING *cipher; ++ } KRB5_ENCDATA; ++ ++DECLARE_STACK_OF(KRB5_ENCDATA) ++ ++/* PrincipalName ::= SEQUENCE { ++** name-type[0] INTEGER, ++** name-string[1] SEQUENCE OF GeneralString ++** } ++*/ ++typedef struct krb5_princname_st ++ { ++ ASN1_INTEGER *nametype; ++ STACK_OF(ASN1_GENERALSTRING) *namestring; ++ } KRB5_PRINCNAME; ++ ++DECLARE_STACK_OF(KRB5_PRINCNAME) ++ ++ ++/* Ticket ::= [APPLICATION 1] SEQUENCE { ++** tkt-vno[0] INTEGER, ++** realm[1] Realm, ++** sname[2] PrincipalName, ++** enc-part[3] EncryptedData ++** } ++*/ ++typedef struct krb5_tktbody_st ++ { ++ ASN1_INTEGER *tktvno; ++ ASN1_GENERALSTRING *realm; ++ KRB5_PRINCNAME *sname; ++ KRB5_ENCDATA *encdata; ++ } KRB5_TKTBODY; ++ ++typedef STACK_OF(KRB5_TKTBODY) KRB5_TICKET; ++DECLARE_STACK_OF(KRB5_TKTBODY) ++ ++ ++/* AP-REQ ::= [APPLICATION 14] SEQUENCE { ++** pvno[0] INTEGER, ++** msg-type[1] INTEGER, ++** ap-options[2] APOptions, ++** ticket[3] Ticket, ++** authenticator[4] EncryptedData ++** } ++** ++** APOptions ::= BIT STRING { ++** reserved(0), use-session-key(1), mutual-required(2) } ++*/ ++typedef struct krb5_ap_req_st ++ { ++ ASN1_INTEGER *pvno; ++ ASN1_INTEGER *msgtype; ++ ASN1_BIT_STRING *apoptions; ++ KRB5_TICKET *ticket; ++ KRB5_ENCDATA *authenticator; ++ } KRB5_APREQBODY; ++ ++typedef STACK_OF(KRB5_APREQBODY) KRB5_APREQ; ++DECLARE_STACK_OF(KRB5_APREQBODY) ++ ++ ++/* Authenticator Stuff */ ++ ++ ++/* Checksum ::= SEQUENCE { ++** cksumtype[0] INTEGER, ++** checksum[1] OCTET STRING ++** } ++*/ ++typedef struct krb5_checksum_st ++ { ++ ASN1_INTEGER *ctype; ++ ASN1_OCTET_STRING *checksum; ++ } KRB5_CHECKSUM; ++ ++DECLARE_STACK_OF(KRB5_CHECKSUM) ++ ++ ++/* EncryptionKey ::= SEQUENCE { ++** keytype[0] INTEGER, ++** keyvalue[1] OCTET STRING ++** } ++*/ ++typedef struct krb5_encryptionkey_st ++ { ++ ASN1_INTEGER *ktype; ++ ASN1_OCTET_STRING *keyvalue; ++ } KRB5_ENCKEY; ++ ++DECLARE_STACK_OF(KRB5_ENCKEY) ++ ++ ++/* AuthorizationData ::= SEQUENCE OF SEQUENCE { ++** ad-type[0] INTEGER, ++** ad-data[1] OCTET STRING ++** } ++*/ ++typedef struct krb5_authorization_st ++ { ++ ASN1_INTEGER *adtype; ++ ASN1_OCTET_STRING *addata; ++ } KRB5_AUTHDATA; ++ ++DECLARE_STACK_OF(KRB5_AUTHDATA) ++ ++ ++/* -- Unencrypted authenticator ++** Authenticator ::= [APPLICATION 2] SEQUENCE { ++** authenticator-vno[0] INTEGER, ++** crealm[1] Realm, ++** cname[2] PrincipalName, ++** cksum[3] Checksum OPTIONAL, ++** cusec[4] INTEGER, ++** ctime[5] KerberosTime, ++** subkey[6] EncryptionKey OPTIONAL, ++** seq-number[7] INTEGER OPTIONAL, ++** authorization-data[8] AuthorizationData OPTIONAL ++** } ++*/ ++typedef struct krb5_authenticator_st ++ { ++ ASN1_INTEGER *avno; ++ ASN1_GENERALSTRING *crealm; ++ KRB5_PRINCNAME *cname; ++ KRB5_CHECKSUM *cksum; ++ ASN1_INTEGER *cusec; ++ ASN1_GENERALIZEDTIME *ctime; ++ KRB5_ENCKEY *subkey; ++ ASN1_INTEGER *seqnum; ++ KRB5_AUTHDATA *authorization; ++ } KRB5_AUTHENTBODY; ++ ++typedef STACK_OF(KRB5_AUTHENTBODY) KRB5_AUTHENT; ++DECLARE_STACK_OF(KRB5_AUTHENTBODY) ++ ++ ++/* DECLARE_ASN1_FUNCTIONS(type) = DECLARE_ASN1_FUNCTIONS_name(type, type) = ++** type *name##_new(void); ++** void name##_free(type *a); ++** DECLARE_ASN1_ENCODE_FUNCTIONS(type, name, name) = ++** 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) = OPENSSL_EXTERN const ASN1_ITEM itname##_it ++*/ ++ ++DECLARE_ASN1_FUNCTIONS(KRB5_ENCDATA) ++DECLARE_ASN1_FUNCTIONS(KRB5_PRINCNAME) ++DECLARE_ASN1_FUNCTIONS(KRB5_TKTBODY) ++DECLARE_ASN1_FUNCTIONS(KRB5_APREQBODY) ++DECLARE_ASN1_FUNCTIONS(KRB5_TICKET) ++DECLARE_ASN1_FUNCTIONS(KRB5_APREQ) ++ ++DECLARE_ASN1_FUNCTIONS(KRB5_CHECKSUM) ++DECLARE_ASN1_FUNCTIONS(KRB5_ENCKEY) ++DECLARE_ASN1_FUNCTIONS(KRB5_AUTHDATA) ++DECLARE_ASN1_FUNCTIONS(KRB5_AUTHENTBODY) ++DECLARE_ASN1_FUNCTIONS(KRB5_AUTHENT) ++ ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++ ++#ifdef __cplusplus ++} ++#endif ++#endif ++ +diff -urN qt.orig/include/openssl/kssl.h qt.patched/include/openssl/kssl.h +--- qt.orig/include/openssl/kssl.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/kssl.h 2010-08-27 12:01:45.337031100 +0200 +@@ -0,0 +1,179 @@ ++/* ssl/kssl.h -*- mode: C; c-file-style: "eay" -*- */ ++/* Written by Vern Staats for the OpenSSL project 2000. ++ * project 2000. ++ */ ++/* ==================================================================== ++ * Copyright (c) 2000 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * licensing@OpenSSL.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++ ++/* ++** 19990701 VRS Started. ++*/ ++ ++#ifndef KSSL_H ++#define KSSL_H ++ ++#include ++ ++#ifndef OPENSSL_NO_KRB5 ++ ++#include ++#include ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* ++** Depending on which KRB5 implementation used, some types from ++** the other may be missing. Resolve that here and now ++*/ ++#ifdef KRB5_HEIMDAL ++typedef unsigned char krb5_octet; ++#define FAR ++#else ++ ++#ifndef FAR ++#define FAR ++#endif ++ ++#endif ++ ++/* Uncomment this to debug kssl problems or ++** to trace usage of the Kerberos session key ++** ++** #define KSSL_DEBUG ++*/ ++ ++#ifndef KRB5SVC ++#define KRB5SVC "host" ++#endif ++ ++#ifndef KRB5KEYTAB ++#define KRB5KEYTAB "/etc/krb5.keytab" ++#endif ++ ++#ifndef KRB5SENDAUTH ++#define KRB5SENDAUTH 1 ++#endif ++ ++#ifndef KRB5CHECKAUTH ++#define KRB5CHECKAUTH 1 ++#endif ++ ++#ifndef KSSL_CLOCKSKEW ++#define KSSL_CLOCKSKEW 300; ++#endif ++ ++#define KSSL_ERR_MAX 255 ++typedef struct kssl_err_st { ++ int reason; ++ char text[KSSL_ERR_MAX+1]; ++ } KSSL_ERR; ++ ++ ++/* Context for passing ++** (1) Kerberos session key to SSL, and ++** (2) Config data between application and SSL lib ++*/ ++typedef struct kssl_ctx_st ++ { ++ /* used by: disposition: */ ++ char *service_name; /* C,S default ok (kssl) */ ++ char *service_host; /* C input, REQUIRED */ ++ char *client_princ; /* S output from krb5 ticket */ ++ char *keytab_file; /* S NULL (/etc/krb5.keytab) */ ++ char *cred_cache; /* C NULL (default) */ ++ krb5_enctype enctype; ++ int length; ++ krb5_octet FAR *key; ++ } KSSL_CTX; ++ ++#define KSSL_CLIENT 1 ++#define KSSL_SERVER 2 ++#define KSSL_SERVICE 3 ++#define KSSL_KEYTAB 4 ++ ++#define KSSL_CTX_OK 0 ++#define KSSL_CTX_ERR 1 ++#define KSSL_NOMEM 2 ++ ++/* Public (for use by applications that use OpenSSL with Kerberos 5 support */ ++krb5_error_code kssl_ctx_setstring(KSSL_CTX *kssl_ctx, int which, char *text); ++KSSL_CTX *kssl_ctx_new(void); ++KSSL_CTX *kssl_ctx_free(KSSL_CTX *kssl_ctx); ++void kssl_ctx_show(KSSL_CTX *kssl_ctx); ++krb5_error_code kssl_ctx_setprinc(KSSL_CTX *kssl_ctx, int which, ++ krb5_data *realm, krb5_data *entity, int nentities); ++krb5_error_code kssl_cget_tkt(KSSL_CTX *kssl_ctx, krb5_data **enc_tktp, ++ krb5_data *authenp, KSSL_ERR *kssl_err); ++krb5_error_code kssl_sget_tkt(KSSL_CTX *kssl_ctx, krb5_data *indata, ++ krb5_ticket_times *ttimes, KSSL_ERR *kssl_err); ++krb5_error_code kssl_ctx_setkey(KSSL_CTX *kssl_ctx, krb5_keyblock *session); ++void kssl_err_set(KSSL_ERR *kssl_err, int reason, char *text); ++void kssl_krb5_free_data_contents(krb5_context context, krb5_data *data); ++krb5_error_code kssl_build_principal_2(krb5_context context, ++ krb5_principal *princ, int rlen, const char *realm, ++ int slen, const char *svc, int hlen, const char *host); ++krb5_error_code kssl_validate_times(krb5_timestamp atime, ++ krb5_ticket_times *ttimes); ++krb5_error_code kssl_check_authent(KSSL_CTX *kssl_ctx, krb5_data *authentp, ++ krb5_timestamp *atimep, KSSL_ERR *kssl_err); ++unsigned char *kssl_skip_confound(krb5_enctype enctype, unsigned char *authn); ++ ++#ifdef __cplusplus ++} ++#endif ++#endif /* OPENSSL_NO_KRB5 */ ++#endif /* KSSL_H */ +diff -urN qt.orig/include/openssl/lhash.h qt.patched/include/openssl/lhash.h +--- qt.orig/include/openssl/lhash.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/lhash.h 2010-08-27 12:01:45.352655500 +0200 +@@ -0,0 +1,241 @@ ++/* crypto/lhash/lhash.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++/* Header for dynamic hash table routines ++ * Author - Eric Young ++ */ ++ ++#ifndef HEADER_LHASH_H ++#define HEADER_LHASH_H ++ ++#include ++#ifndef OPENSSL_NO_FP_API ++#include ++#endif ++ ++#ifndef OPENSSL_NO_BIO ++#include ++#endif ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++typedef struct lhash_node_st ++ { ++ void *data; ++ struct lhash_node_st *next; ++#ifndef OPENSSL_NO_HASH_COMP ++ unsigned long hash; ++#endif ++ } LHASH_NODE; ++ ++typedef int (*LHASH_COMP_FN_TYPE)(const void *, const void *); ++typedef unsigned long (*LHASH_HASH_FN_TYPE)(const void *); ++typedef void (*LHASH_DOALL_FN_TYPE)(void *); ++typedef void (*LHASH_DOALL_ARG_FN_TYPE)(void *, void *); ++ ++/* Macros for declaring and implementing type-safe wrappers for LHASH callbacks. ++ * This way, callbacks can be provided to LHASH structures without function ++ * pointer casting and the macro-defined callbacks provide per-variable casting ++ * before deferring to the underlying type-specific callbacks. NB: It is ++ * possible to place a "static" in front of both the DECLARE and IMPLEMENT ++ * macros if the functions are strictly internal. */ ++ ++/* First: "hash" functions */ ++#define DECLARE_LHASH_HASH_FN(name, o_type) \ ++ unsigned long name##_LHASH_HASH(const void *); ++#define IMPLEMENT_LHASH_HASH_FN(name, o_type) \ ++ unsigned long name##_LHASH_HASH(const void *arg) { \ ++ const o_type *a = arg; \ ++ return name##_hash(a); } ++#define LHASH_HASH_FN(name) name##_LHASH_HASH ++ ++/* Second: "compare" functions */ ++#define DECLARE_LHASH_COMP_FN(name, o_type) \ ++ int name##_LHASH_COMP(const void *, const void *); ++#define IMPLEMENT_LHASH_COMP_FN(name, o_type) \ ++ int name##_LHASH_COMP(const void *arg1, const void *arg2) { \ ++ const o_type *a = arg1; \ ++ const o_type *b = arg2; \ ++ return name##_cmp(a,b); } ++#define LHASH_COMP_FN(name) name##_LHASH_COMP ++ ++/* Third: "doall" functions */ ++#define DECLARE_LHASH_DOALL_FN(name, o_type) \ ++ void name##_LHASH_DOALL(void *); ++#define IMPLEMENT_LHASH_DOALL_FN(name, o_type) \ ++ void name##_LHASH_DOALL(void *arg) { \ ++ o_type *a = arg; \ ++ name##_doall(a); } ++#define LHASH_DOALL_FN(name) name##_LHASH_DOALL ++ ++/* Fourth: "doall_arg" functions */ ++#define DECLARE_LHASH_DOALL_ARG_FN(name, o_type, a_type) \ ++ void name##_LHASH_DOALL_ARG(void *, void *); ++#define IMPLEMENT_LHASH_DOALL_ARG_FN(name, o_type, a_type) \ ++ void name##_LHASH_DOALL_ARG(void *arg1, void *arg2) { \ ++ o_type *a = arg1; \ ++ a_type *b = arg2; \ ++ name##_doall_arg(a, b); } ++#define LHASH_DOALL_ARG_FN(name) name##_LHASH_DOALL_ARG ++ ++typedef struct lhash_st ++ { ++ LHASH_NODE **b; ++ LHASH_COMP_FN_TYPE comp; ++ LHASH_HASH_FN_TYPE hash; ++ unsigned int num_nodes; ++ unsigned int num_alloc_nodes; ++ unsigned int p; ++ unsigned int pmax; ++ unsigned long up_load; /* load times 256 */ ++ unsigned long down_load; /* load times 256 */ ++ unsigned long num_items; ++ ++ unsigned long num_expands; ++ unsigned long num_expand_reallocs; ++ unsigned long num_contracts; ++ unsigned long num_contract_reallocs; ++ unsigned long num_hash_calls; ++ unsigned long num_comp_calls; ++ unsigned long num_insert; ++ unsigned long num_replace; ++ unsigned long num_delete; ++ unsigned long num_no_delete; ++ unsigned long num_retrieve; ++ unsigned long num_retrieve_miss; ++ unsigned long num_hash_comps; ++ ++ int error; ++ } _LHASH; /* Do not use _LHASH directly, use LHASH_OF ++ * and friends */ ++ ++#define LH_LOAD_MULT 256 ++ ++/* Indicates a malloc() error in the last call, this is only bad ++ * in lh_insert(). */ ++#define lh_error(lh) ((lh)->error) ++ ++_LHASH *lh_new(LHASH_HASH_FN_TYPE h, LHASH_COMP_FN_TYPE c); ++void lh_free(_LHASH *lh); ++void *lh_insert(_LHASH *lh, void *data); ++void *lh_delete(_LHASH *lh, const void *data); ++void *lh_retrieve(_LHASH *lh, const void *data); ++void lh_doall(_LHASH *lh, LHASH_DOALL_FN_TYPE func); ++void lh_doall_arg(_LHASH *lh, LHASH_DOALL_ARG_FN_TYPE func, void *arg); ++unsigned long lh_strhash(const char *c); ++unsigned long lh_num_items(const _LHASH *lh); ++ ++#ifndef OPENSSL_NO_FP_API ++void lh_stats(const _LHASH *lh, FILE *out); ++void lh_node_stats(const _LHASH *lh, FILE *out); ++void lh_node_usage_stats(const _LHASH *lh, FILE *out); ++#endif ++ ++#ifndef OPENSSL_NO_BIO ++void lh_stats_bio(const _LHASH *lh, BIO *out); ++void lh_node_stats_bio(const _LHASH *lh, BIO *out); ++void lh_node_usage_stats_bio(const _LHASH *lh, BIO *out); ++#endif ++ ++/* Type checking... */ ++ ++#define LHASH_OF(type) struct lhash_st_##type ++ ++#define DECLARE_LHASH_OF(type) LHASH_OF(type) { int dummy; } ++ ++#define CHECKED_LHASH_OF(type,lh) \ ++ ((_LHASH *)CHECKED_PTR_OF(LHASH_OF(type),lh)) ++ ++/* Define wrapper functions. */ ++#define LHM_lh_new(type, name) \ ++ ((LHASH_OF(type) *)lh_new(LHASH_HASH_FN(name), LHASH_COMP_FN(name))) ++#define LHM_lh_error(type, lh) \ ++ lh_error(CHECKED_LHASH_OF(type,lh)) ++#define LHM_lh_insert(type, lh, inst) \ ++ ((type *)lh_insert(CHECKED_LHASH_OF(type, lh), \ ++ CHECKED_PTR_OF(type, inst))) ++#define LHM_lh_retrieve(type, lh, inst) \ ++ ((type *)lh_retrieve(CHECKED_LHASH_OF(type, lh), \ ++ CHECKED_PTR_OF(type, inst))) ++#define LHM_lh_delete(type, lh, inst) \ ++ ((type *)lh_delete(CHECKED_LHASH_OF(type, lh), \ ++ CHECKED_PTR_OF(type, inst))) ++#define LHM_lh_doall(type, lh,fn) lh_doall(CHECKED_LHASH_OF(type, lh), fn) ++#define LHM_lh_doall_arg(type, lh, fn, arg_type, arg) \ ++ lh_doall_arg(CHECKED_LHASH_OF(type, lh), fn, CHECKED_PTR_OF(arg_type, arg)) ++#define LHM_lh_num_items(type, lh) lh_num_items(CHECKED_LHASH_OF(type, lh)) ++#define LHM_lh_down_load(type, lh) (CHECKED_LHASH_OF(type, lh)->down_load) ++#define LHM_lh_node_stats_bio(type, lh, out) \ ++ lh_node_stats_bio(CHECKED_LHASH_OF(type, lh), out) ++#define LHM_lh_node_usage_stats_bio(type, lh, out) \ ++ lh_node_usage_stats_bio(CHECKED_LHASH_OF(type, lh), out) ++#define LHM_lh_stats_bio(type, lh, out) \ ++ lh_stats_bio(CHECKED_LHASH_OF(type, lh), out) ++#define LHM_lh_free(type, lh) lh_free(CHECKED_LHASH_OF(type, lh)) ++ ++DECLARE_LHASH_OF(OPENSSL_STRING); ++DECLARE_LHASH_OF(OPENSSL_CSTRING); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif ++ +diff -urN qt.orig/include/openssl/md4.h qt.patched/include/openssl/md4.h +--- qt.orig/include/openssl/md4.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/md4.h 2010-08-27 12:01:45.352655500 +0200 +@@ -0,0 +1,117 @@ ++/* crypto/md4/md4.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_MD4_H ++#define HEADER_MD4_H ++ ++#include ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#ifdef OPENSSL_NO_MD4 ++#error MD4 is disabled. ++#endif ++ ++/* ++ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ++ * ! MD4_LONG has to be at least 32 bits wide. If it's wider, then ! ++ * ! MD4_LONG_LOG2 has to be defined along. ! ++ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ++ */ ++ ++#if defined(__LP32__) ++#define MD4_LONG unsigned long ++#elif defined(OPENSSL_SYS_CRAY) || defined(__ILP64__) ++#define MD4_LONG unsigned long ++#define MD4_LONG_LOG2 3 ++/* ++ * _CRAY note. I could declare short, but I have no idea what impact ++ * does it have on performance on none-T3E machines. I could declare ++ * int, but at least on C90 sizeof(int) can be chosen at compile time. ++ * So I've chosen long... ++ * ++ */ ++#else ++#define MD4_LONG unsigned int ++#endif ++ ++#define MD4_CBLOCK 64 ++#define MD4_LBLOCK (MD4_CBLOCK/4) ++#define MD4_DIGEST_LENGTH 16 ++ ++typedef struct MD4state_st ++ { ++ MD4_LONG A,B,C,D; ++ MD4_LONG Nl,Nh; ++ MD4_LONG data[MD4_LBLOCK]; ++ unsigned int num; ++ } MD4_CTX; ++ ++int MD4_Init(MD4_CTX *c); ++int MD4_Update(MD4_CTX *c, const void *data, size_t len); ++int MD4_Final(unsigned char *md, MD4_CTX *c); ++unsigned char *MD4(const unsigned char *d, size_t n, unsigned char *md); ++void MD4_Transform(MD4_CTX *c, const unsigned char *b); ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff -urN qt.orig/include/openssl/md5.h qt.patched/include/openssl/md5.h +--- qt.orig/include/openssl/md5.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/md5.h 2010-08-27 12:01:45.368279900 +0200 +@@ -0,0 +1,117 @@ ++/* crypto/md5/md5.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_MD5_H ++#define HEADER_MD5_H ++ ++#include ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#ifdef OPENSSL_NO_MD5 ++#error MD5 is disabled. ++#endif ++ ++/* ++ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ++ * ! MD5_LONG has to be at least 32 bits wide. If it's wider, then ! ++ * ! MD5_LONG_LOG2 has to be defined along. ! ++ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ++ */ ++ ++#if defined(__LP32__) ++#define MD5_LONG unsigned long ++#elif defined(OPENSSL_SYS_CRAY) || defined(__ILP64__) ++#define MD5_LONG unsigned long ++#define MD5_LONG_LOG2 3 ++/* ++ * _CRAY note. I could declare short, but I have no idea what impact ++ * does it have on performance on none-T3E machines. I could declare ++ * int, but at least on C90 sizeof(int) can be chosen at compile time. ++ * So I've chosen long... ++ * ++ */ ++#else ++#define MD5_LONG unsigned int ++#endif ++ ++#define MD5_CBLOCK 64 ++#define MD5_LBLOCK (MD5_CBLOCK/4) ++#define MD5_DIGEST_LENGTH 16 ++ ++typedef struct MD5state_st ++ { ++ MD5_LONG A,B,C,D; ++ MD5_LONG Nl,Nh; ++ MD5_LONG data[MD5_LBLOCK]; ++ unsigned int num; ++ } MD5_CTX; ++ ++int MD5_Init(MD5_CTX *c); ++int MD5_Update(MD5_CTX *c, const void *data, size_t len); ++int MD5_Final(unsigned char *md, MD5_CTX *c); ++unsigned char *MD5(const unsigned char *d, size_t n, unsigned char *md); ++void MD5_Transform(MD5_CTX *c, const unsigned char *b); ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff -urN qt.orig/include/openssl/mdc2.h qt.patched/include/openssl/mdc2.h +--- qt.orig/include/openssl/mdc2.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/mdc2.h 2010-08-27 12:01:45.368279900 +0200 +@@ -0,0 +1,95 @@ ++/* crypto/mdc2/mdc2.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_MDC2_H ++#define HEADER_MDC2_H ++ ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#ifdef OPENSSL_NO_MDC2 ++#error MDC2 is disabled. ++#endif ++ ++#define MDC2_BLOCK 8 ++#define MDC2_DIGEST_LENGTH 16 ++ ++typedef struct mdc2_ctx_st ++ { ++ unsigned int num; ++ unsigned char data[MDC2_BLOCK]; ++ DES_cblock h,hh; ++ int pad_type; /* either 1 or 2, default 1 */ ++ } MDC2_CTX; ++ ++ ++int MDC2_Init(MDC2_CTX *c); ++int MDC2_Update(MDC2_CTX *c, const unsigned char *data, size_t len); ++int MDC2_Final(unsigned char *md, MDC2_CTX *c); ++unsigned char *MDC2(const unsigned char *d, size_t n, ++ unsigned char *md); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif ++ +diff -urN qt.orig/include/openssl/modes.h qt.patched/include/openssl/modes.h +--- qt.orig/include/openssl/modes.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/modes.h 2010-08-27 12:01:45.383904300 +0200 +@@ -0,0 +1,59 @@ ++/* ==================================================================== ++ * Copyright (c) 2008 The OpenSSL Project. All rights reserved. ++ * ++ * Rights for redistribution and usage in source and binary ++ * forms are granted according to the OpenSSL license. ++ */ ++ ++#include ++ ++typedef void (*block128_f)(const unsigned char in[16], ++ unsigned char out[16], ++ const void *key); ++ ++typedef void (*cbc128_f)(const unsigned char *in, unsigned char *out, ++ size_t len, const void *key, ++ unsigned char ivec[16], int enc); ++ ++void CRYPTO_cbc128_encrypt(const unsigned char *in, unsigned char *out, ++ size_t len, const void *key, ++ unsigned char ivec[16], block128_f block); ++void CRYPTO_cbc128_decrypt(const unsigned char *in, unsigned char *out, ++ size_t len, const void *key, ++ unsigned char ivec[16], block128_f block); ++ ++void CRYPTO_ctr128_encrypt(const unsigned char *in, unsigned char *out, ++ size_t len, const void *key, ++ unsigned char ivec[16], unsigned char ecount_buf[16], ++ unsigned int *num, block128_f block); ++ ++void CRYPTO_ofb128_encrypt(const unsigned char *in, unsigned char *out, ++ size_t len, const void *key, ++ unsigned char ivec[16], int *num, ++ block128_f block); ++ ++void CRYPTO_cfb128_encrypt(const unsigned char *in, unsigned char *out, ++ size_t len, const void *key, ++ unsigned char ivec[16], int *num, ++ int enc, block128_f block); ++void CRYPTO_cfb128_8_encrypt(const unsigned char *in, unsigned char *out, ++ size_t length, const void *key, ++ unsigned char ivec[16], int *num, ++ int enc, block128_f block); ++void CRYPTO_cfb128_1_encrypt(const unsigned char *in, unsigned char *out, ++ size_t bits, const void *key, ++ unsigned char ivec[16], int *num, ++ int enc, block128_f block); ++ ++size_t CRYPTO_cts128_encrypt_block(const unsigned char *in, unsigned char *out, ++ size_t len, const void *key, ++ unsigned char ivec[16], block128_f block); ++size_t CRYPTO_cts128_encrypt(const unsigned char *in, unsigned char *out, ++ size_t len, const void *key, ++ unsigned char ivec[16], cbc128_f cbc); ++size_t CRYPTO_cts128_decrypt_block(const unsigned char *in, unsigned char *out, ++ size_t len, const void *key, ++ unsigned char ivec[16], block128_f block); ++size_t CRYPTO_cts128_decrypt(const unsigned char *in, unsigned char *out, ++ size_t len, const void *key, ++ unsigned char ivec[16], cbc128_f cbc); +diff -urN qt.orig/include/openssl/obj_mac.h qt.patched/include/openssl/obj_mac.h +--- qt.orig/include/openssl/obj_mac.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/obj_mac.h 2010-08-27 12:01:45.399528700 +0200 +@@ -0,0 +1,3914 @@ ++/* crypto/objects/obj_mac.h */ ++ ++/* THIS FILE IS GENERATED FROM objects.txt by objects.pl via the ++ * following command: ++ * perl objects.pl objects.txt obj_mac.num obj_mac.h ++ */ ++ ++/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#define SN_undef "UNDEF" ++#define LN_undef "undefined" ++#define NID_undef 0 ++#define OBJ_undef 0L ++ ++#define SN_itu_t "ITU-T" ++#define LN_itu_t "itu-t" ++#define NID_itu_t 645 ++#define OBJ_itu_t 0L ++ ++#define NID_ccitt 404 ++#define OBJ_ccitt OBJ_itu_t ++ ++#define SN_iso "ISO" ++#define LN_iso "iso" ++#define NID_iso 181 ++#define OBJ_iso 1L ++ ++#define SN_joint_iso_itu_t "JOINT-ISO-ITU-T" ++#define LN_joint_iso_itu_t "joint-iso-itu-t" ++#define NID_joint_iso_itu_t 646 ++#define OBJ_joint_iso_itu_t 2L ++ ++#define NID_joint_iso_ccitt 393 ++#define OBJ_joint_iso_ccitt OBJ_joint_iso_itu_t ++ ++#define SN_member_body "member-body" ++#define LN_member_body "ISO Member Body" ++#define NID_member_body 182 ++#define OBJ_member_body OBJ_iso,2L ++ ++#define SN_identified_organization "identified-organization" ++#define NID_identified_organization 676 ++#define OBJ_identified_organization OBJ_iso,3L ++ ++#define SN_hmac_md5 "HMAC-MD5" ++#define LN_hmac_md5 "hmac-md5" ++#define NID_hmac_md5 780 ++#define OBJ_hmac_md5 OBJ_identified_organization,6L,1L,5L,5L,8L,1L,1L ++ ++#define SN_hmac_sha1 "HMAC-SHA1" ++#define LN_hmac_sha1 "hmac-sha1" ++#define NID_hmac_sha1 781 ++#define OBJ_hmac_sha1 OBJ_identified_organization,6L,1L,5L,5L,8L,1L,2L ++ ++#define SN_certicom_arc "certicom-arc" ++#define NID_certicom_arc 677 ++#define OBJ_certicom_arc OBJ_identified_organization,132L ++ ++#define SN_international_organizations "international-organizations" ++#define LN_international_organizations "International Organizations" ++#define NID_international_organizations 647 ++#define OBJ_international_organizations OBJ_joint_iso_itu_t,23L ++ ++#define SN_wap "wap" ++#define NID_wap 678 ++#define OBJ_wap OBJ_international_organizations,43L ++ ++#define SN_wap_wsg "wap-wsg" ++#define NID_wap_wsg 679 ++#define OBJ_wap_wsg OBJ_wap,1L ++ ++#define SN_selected_attribute_types "selected-attribute-types" ++#define LN_selected_attribute_types "Selected Attribute Types" ++#define NID_selected_attribute_types 394 ++#define OBJ_selected_attribute_types OBJ_joint_iso_itu_t,5L,1L,5L ++ ++#define SN_clearance "clearance" ++#define NID_clearance 395 ++#define OBJ_clearance OBJ_selected_attribute_types,55L ++ ++#define SN_ISO_US "ISO-US" ++#define LN_ISO_US "ISO US Member Body" ++#define NID_ISO_US 183 ++#define OBJ_ISO_US OBJ_member_body,840L ++ ++#define SN_X9_57 "X9-57" ++#define LN_X9_57 "X9.57" ++#define NID_X9_57 184 ++#define OBJ_X9_57 OBJ_ISO_US,10040L ++ ++#define SN_X9cm "X9cm" ++#define LN_X9cm "X9.57 CM ?" ++#define NID_X9cm 185 ++#define OBJ_X9cm OBJ_X9_57,4L ++ ++#define SN_dsa "DSA" ++#define LN_dsa "dsaEncryption" ++#define NID_dsa 116 ++#define OBJ_dsa OBJ_X9cm,1L ++ ++#define SN_dsaWithSHA1 "DSA-SHA1" ++#define LN_dsaWithSHA1 "dsaWithSHA1" ++#define NID_dsaWithSHA1 113 ++#define OBJ_dsaWithSHA1 OBJ_X9cm,3L ++ ++#define SN_ansi_X9_62 "ansi-X9-62" ++#define LN_ansi_X9_62 "ANSI X9.62" ++#define NID_ansi_X9_62 405 ++#define OBJ_ansi_X9_62 OBJ_ISO_US,10045L ++ ++#define OBJ_X9_62_id_fieldType OBJ_ansi_X9_62,1L ++ ++#define SN_X9_62_prime_field "prime-field" ++#define NID_X9_62_prime_field 406 ++#define OBJ_X9_62_prime_field OBJ_X9_62_id_fieldType,1L ++ ++#define SN_X9_62_characteristic_two_field "characteristic-two-field" ++#define NID_X9_62_characteristic_two_field 407 ++#define OBJ_X9_62_characteristic_two_field OBJ_X9_62_id_fieldType,2L ++ ++#define SN_X9_62_id_characteristic_two_basis "id-characteristic-two-basis" ++#define NID_X9_62_id_characteristic_two_basis 680 ++#define OBJ_X9_62_id_characteristic_two_basis OBJ_X9_62_characteristic_two_field,3L ++ ++#define SN_X9_62_onBasis "onBasis" ++#define NID_X9_62_onBasis 681 ++#define OBJ_X9_62_onBasis OBJ_X9_62_id_characteristic_two_basis,1L ++ ++#define SN_X9_62_tpBasis "tpBasis" ++#define NID_X9_62_tpBasis 682 ++#define OBJ_X9_62_tpBasis OBJ_X9_62_id_characteristic_two_basis,2L ++ ++#define SN_X9_62_ppBasis "ppBasis" ++#define NID_X9_62_ppBasis 683 ++#define OBJ_X9_62_ppBasis OBJ_X9_62_id_characteristic_two_basis,3L ++ ++#define OBJ_X9_62_id_publicKeyType OBJ_ansi_X9_62,2L ++ ++#define SN_X9_62_id_ecPublicKey "id-ecPublicKey" ++#define NID_X9_62_id_ecPublicKey 408 ++#define OBJ_X9_62_id_ecPublicKey OBJ_X9_62_id_publicKeyType,1L ++ ++#define OBJ_X9_62_ellipticCurve OBJ_ansi_X9_62,3L ++ ++#define OBJ_X9_62_c_TwoCurve OBJ_X9_62_ellipticCurve,0L ++ ++#define SN_X9_62_c2pnb163v1 "c2pnb163v1" ++#define NID_X9_62_c2pnb163v1 684 ++#define OBJ_X9_62_c2pnb163v1 OBJ_X9_62_c_TwoCurve,1L ++ ++#define SN_X9_62_c2pnb163v2 "c2pnb163v2" ++#define NID_X9_62_c2pnb163v2 685 ++#define OBJ_X9_62_c2pnb163v2 OBJ_X9_62_c_TwoCurve,2L ++ ++#define SN_X9_62_c2pnb163v3 "c2pnb163v3" ++#define NID_X9_62_c2pnb163v3 686 ++#define OBJ_X9_62_c2pnb163v3 OBJ_X9_62_c_TwoCurve,3L ++ ++#define SN_X9_62_c2pnb176v1 "c2pnb176v1" ++#define NID_X9_62_c2pnb176v1 687 ++#define OBJ_X9_62_c2pnb176v1 OBJ_X9_62_c_TwoCurve,4L ++ ++#define SN_X9_62_c2tnb191v1 "c2tnb191v1" ++#define NID_X9_62_c2tnb191v1 688 ++#define OBJ_X9_62_c2tnb191v1 OBJ_X9_62_c_TwoCurve,5L ++ ++#define SN_X9_62_c2tnb191v2 "c2tnb191v2" ++#define NID_X9_62_c2tnb191v2 689 ++#define OBJ_X9_62_c2tnb191v2 OBJ_X9_62_c_TwoCurve,6L ++ ++#define SN_X9_62_c2tnb191v3 "c2tnb191v3" ++#define NID_X9_62_c2tnb191v3 690 ++#define OBJ_X9_62_c2tnb191v3 OBJ_X9_62_c_TwoCurve,7L ++ ++#define SN_X9_62_c2onb191v4 "c2onb191v4" ++#define NID_X9_62_c2onb191v4 691 ++#define OBJ_X9_62_c2onb191v4 OBJ_X9_62_c_TwoCurve,8L ++ ++#define SN_X9_62_c2onb191v5 "c2onb191v5" ++#define NID_X9_62_c2onb191v5 692 ++#define OBJ_X9_62_c2onb191v5 OBJ_X9_62_c_TwoCurve,9L ++ ++#define SN_X9_62_c2pnb208w1 "c2pnb208w1" ++#define NID_X9_62_c2pnb208w1 693 ++#define OBJ_X9_62_c2pnb208w1 OBJ_X9_62_c_TwoCurve,10L ++ ++#define SN_X9_62_c2tnb239v1 "c2tnb239v1" ++#define NID_X9_62_c2tnb239v1 694 ++#define OBJ_X9_62_c2tnb239v1 OBJ_X9_62_c_TwoCurve,11L ++ ++#define SN_X9_62_c2tnb239v2 "c2tnb239v2" ++#define NID_X9_62_c2tnb239v2 695 ++#define OBJ_X9_62_c2tnb239v2 OBJ_X9_62_c_TwoCurve,12L ++ ++#define SN_X9_62_c2tnb239v3 "c2tnb239v3" ++#define NID_X9_62_c2tnb239v3 696 ++#define OBJ_X9_62_c2tnb239v3 OBJ_X9_62_c_TwoCurve,13L ++ ++#define SN_X9_62_c2onb239v4 "c2onb239v4" ++#define NID_X9_62_c2onb239v4 697 ++#define OBJ_X9_62_c2onb239v4 OBJ_X9_62_c_TwoCurve,14L ++ ++#define SN_X9_62_c2onb239v5 "c2onb239v5" ++#define NID_X9_62_c2onb239v5 698 ++#define OBJ_X9_62_c2onb239v5 OBJ_X9_62_c_TwoCurve,15L ++ ++#define SN_X9_62_c2pnb272w1 "c2pnb272w1" ++#define NID_X9_62_c2pnb272w1 699 ++#define OBJ_X9_62_c2pnb272w1 OBJ_X9_62_c_TwoCurve,16L ++ ++#define SN_X9_62_c2pnb304w1 "c2pnb304w1" ++#define NID_X9_62_c2pnb304w1 700 ++#define OBJ_X9_62_c2pnb304w1 OBJ_X9_62_c_TwoCurve,17L ++ ++#define SN_X9_62_c2tnb359v1 "c2tnb359v1" ++#define NID_X9_62_c2tnb359v1 701 ++#define OBJ_X9_62_c2tnb359v1 OBJ_X9_62_c_TwoCurve,18L ++ ++#define SN_X9_62_c2pnb368w1 "c2pnb368w1" ++#define NID_X9_62_c2pnb368w1 702 ++#define OBJ_X9_62_c2pnb368w1 OBJ_X9_62_c_TwoCurve,19L ++ ++#define SN_X9_62_c2tnb431r1 "c2tnb431r1" ++#define NID_X9_62_c2tnb431r1 703 ++#define OBJ_X9_62_c2tnb431r1 OBJ_X9_62_c_TwoCurve,20L ++ ++#define OBJ_X9_62_primeCurve OBJ_X9_62_ellipticCurve,1L ++ ++#define SN_X9_62_prime192v1 "prime192v1" ++#define NID_X9_62_prime192v1 409 ++#define OBJ_X9_62_prime192v1 OBJ_X9_62_primeCurve,1L ++ ++#define SN_X9_62_prime192v2 "prime192v2" ++#define NID_X9_62_prime192v2 410 ++#define OBJ_X9_62_prime192v2 OBJ_X9_62_primeCurve,2L ++ ++#define SN_X9_62_prime192v3 "prime192v3" ++#define NID_X9_62_prime192v3 411 ++#define OBJ_X9_62_prime192v3 OBJ_X9_62_primeCurve,3L ++ ++#define SN_X9_62_prime239v1 "prime239v1" ++#define NID_X9_62_prime239v1 412 ++#define OBJ_X9_62_prime239v1 OBJ_X9_62_primeCurve,4L ++ ++#define SN_X9_62_prime239v2 "prime239v2" ++#define NID_X9_62_prime239v2 413 ++#define OBJ_X9_62_prime239v2 OBJ_X9_62_primeCurve,5L ++ ++#define SN_X9_62_prime239v3 "prime239v3" ++#define NID_X9_62_prime239v3 414 ++#define OBJ_X9_62_prime239v3 OBJ_X9_62_primeCurve,6L ++ ++#define SN_X9_62_prime256v1 "prime256v1" ++#define NID_X9_62_prime256v1 415 ++#define OBJ_X9_62_prime256v1 OBJ_X9_62_primeCurve,7L ++ ++#define OBJ_X9_62_id_ecSigType OBJ_ansi_X9_62,4L ++ ++#define SN_ecdsa_with_SHA1 "ecdsa-with-SHA1" ++#define NID_ecdsa_with_SHA1 416 ++#define OBJ_ecdsa_with_SHA1 OBJ_X9_62_id_ecSigType,1L ++ ++#define SN_ecdsa_with_Recommended "ecdsa-with-Recommended" ++#define NID_ecdsa_with_Recommended 791 ++#define OBJ_ecdsa_with_Recommended OBJ_X9_62_id_ecSigType,2L ++ ++#define SN_ecdsa_with_Specified "ecdsa-with-Specified" ++#define NID_ecdsa_with_Specified 792 ++#define OBJ_ecdsa_with_Specified OBJ_X9_62_id_ecSigType,3L ++ ++#define SN_ecdsa_with_SHA224 "ecdsa-with-SHA224" ++#define NID_ecdsa_with_SHA224 793 ++#define OBJ_ecdsa_with_SHA224 OBJ_ecdsa_with_Specified,1L ++ ++#define SN_ecdsa_with_SHA256 "ecdsa-with-SHA256" ++#define NID_ecdsa_with_SHA256 794 ++#define OBJ_ecdsa_with_SHA256 OBJ_ecdsa_with_Specified,2L ++ ++#define SN_ecdsa_with_SHA384 "ecdsa-with-SHA384" ++#define NID_ecdsa_with_SHA384 795 ++#define OBJ_ecdsa_with_SHA384 OBJ_ecdsa_with_Specified,3L ++ ++#define SN_ecdsa_with_SHA512 "ecdsa-with-SHA512" ++#define NID_ecdsa_with_SHA512 796 ++#define OBJ_ecdsa_with_SHA512 OBJ_ecdsa_with_Specified,4L ++ ++#define OBJ_secg_ellipticCurve OBJ_certicom_arc,0L ++ ++#define SN_secp112r1 "secp112r1" ++#define NID_secp112r1 704 ++#define OBJ_secp112r1 OBJ_secg_ellipticCurve,6L ++ ++#define SN_secp112r2 "secp112r2" ++#define NID_secp112r2 705 ++#define OBJ_secp112r2 OBJ_secg_ellipticCurve,7L ++ ++#define SN_secp128r1 "secp128r1" ++#define NID_secp128r1 706 ++#define OBJ_secp128r1 OBJ_secg_ellipticCurve,28L ++ ++#define SN_secp128r2 "secp128r2" ++#define NID_secp128r2 707 ++#define OBJ_secp128r2 OBJ_secg_ellipticCurve,29L ++ ++#define SN_secp160k1 "secp160k1" ++#define NID_secp160k1 708 ++#define OBJ_secp160k1 OBJ_secg_ellipticCurve,9L ++ ++#define SN_secp160r1 "secp160r1" ++#define NID_secp160r1 709 ++#define OBJ_secp160r1 OBJ_secg_ellipticCurve,8L ++ ++#define SN_secp160r2 "secp160r2" ++#define NID_secp160r2 710 ++#define OBJ_secp160r2 OBJ_secg_ellipticCurve,30L ++ ++#define SN_secp192k1 "secp192k1" ++#define NID_secp192k1 711 ++#define OBJ_secp192k1 OBJ_secg_ellipticCurve,31L ++ ++#define SN_secp224k1 "secp224k1" ++#define NID_secp224k1 712 ++#define OBJ_secp224k1 OBJ_secg_ellipticCurve,32L ++ ++#define SN_secp224r1 "secp224r1" ++#define NID_secp224r1 713 ++#define OBJ_secp224r1 OBJ_secg_ellipticCurve,33L ++ ++#define SN_secp256k1 "secp256k1" ++#define NID_secp256k1 714 ++#define OBJ_secp256k1 OBJ_secg_ellipticCurve,10L ++ ++#define SN_secp384r1 "secp384r1" ++#define NID_secp384r1 715 ++#define OBJ_secp384r1 OBJ_secg_ellipticCurve,34L ++ ++#define SN_secp521r1 "secp521r1" ++#define NID_secp521r1 716 ++#define OBJ_secp521r1 OBJ_secg_ellipticCurve,35L ++ ++#define SN_sect113r1 "sect113r1" ++#define NID_sect113r1 717 ++#define OBJ_sect113r1 OBJ_secg_ellipticCurve,4L ++ ++#define SN_sect113r2 "sect113r2" ++#define NID_sect113r2 718 ++#define OBJ_sect113r2 OBJ_secg_ellipticCurve,5L ++ ++#define SN_sect131r1 "sect131r1" ++#define NID_sect131r1 719 ++#define OBJ_sect131r1 OBJ_secg_ellipticCurve,22L ++ ++#define SN_sect131r2 "sect131r2" ++#define NID_sect131r2 720 ++#define OBJ_sect131r2 OBJ_secg_ellipticCurve,23L ++ ++#define SN_sect163k1 "sect163k1" ++#define NID_sect163k1 721 ++#define OBJ_sect163k1 OBJ_secg_ellipticCurve,1L ++ ++#define SN_sect163r1 "sect163r1" ++#define NID_sect163r1 722 ++#define OBJ_sect163r1 OBJ_secg_ellipticCurve,2L ++ ++#define SN_sect163r2 "sect163r2" ++#define NID_sect163r2 723 ++#define OBJ_sect163r2 OBJ_secg_ellipticCurve,15L ++ ++#define SN_sect193r1 "sect193r1" ++#define NID_sect193r1 724 ++#define OBJ_sect193r1 OBJ_secg_ellipticCurve,24L ++ ++#define SN_sect193r2 "sect193r2" ++#define NID_sect193r2 725 ++#define OBJ_sect193r2 OBJ_secg_ellipticCurve,25L ++ ++#define SN_sect233k1 "sect233k1" ++#define NID_sect233k1 726 ++#define OBJ_sect233k1 OBJ_secg_ellipticCurve,26L ++ ++#define SN_sect233r1 "sect233r1" ++#define NID_sect233r1 727 ++#define OBJ_sect233r1 OBJ_secg_ellipticCurve,27L ++ ++#define SN_sect239k1 "sect239k1" ++#define NID_sect239k1 728 ++#define OBJ_sect239k1 OBJ_secg_ellipticCurve,3L ++ ++#define SN_sect283k1 "sect283k1" ++#define NID_sect283k1 729 ++#define OBJ_sect283k1 OBJ_secg_ellipticCurve,16L ++ ++#define SN_sect283r1 "sect283r1" ++#define NID_sect283r1 730 ++#define OBJ_sect283r1 OBJ_secg_ellipticCurve,17L ++ ++#define SN_sect409k1 "sect409k1" ++#define NID_sect409k1 731 ++#define OBJ_sect409k1 OBJ_secg_ellipticCurve,36L ++ ++#define SN_sect409r1 "sect409r1" ++#define NID_sect409r1 732 ++#define OBJ_sect409r1 OBJ_secg_ellipticCurve,37L ++ ++#define SN_sect571k1 "sect571k1" ++#define NID_sect571k1 733 ++#define OBJ_sect571k1 OBJ_secg_ellipticCurve,38L ++ ++#define SN_sect571r1 "sect571r1" ++#define NID_sect571r1 734 ++#define OBJ_sect571r1 OBJ_secg_ellipticCurve,39L ++ ++#define OBJ_wap_wsg_idm_ecid OBJ_wap_wsg,4L ++ ++#define SN_wap_wsg_idm_ecid_wtls1 "wap-wsg-idm-ecid-wtls1" ++#define NID_wap_wsg_idm_ecid_wtls1 735 ++#define OBJ_wap_wsg_idm_ecid_wtls1 OBJ_wap_wsg_idm_ecid,1L ++ ++#define SN_wap_wsg_idm_ecid_wtls3 "wap-wsg-idm-ecid-wtls3" ++#define NID_wap_wsg_idm_ecid_wtls3 736 ++#define OBJ_wap_wsg_idm_ecid_wtls3 OBJ_wap_wsg_idm_ecid,3L ++ ++#define SN_wap_wsg_idm_ecid_wtls4 "wap-wsg-idm-ecid-wtls4" ++#define NID_wap_wsg_idm_ecid_wtls4 737 ++#define OBJ_wap_wsg_idm_ecid_wtls4 OBJ_wap_wsg_idm_ecid,4L ++ ++#define SN_wap_wsg_idm_ecid_wtls5 "wap-wsg-idm-ecid-wtls5" ++#define NID_wap_wsg_idm_ecid_wtls5 738 ++#define OBJ_wap_wsg_idm_ecid_wtls5 OBJ_wap_wsg_idm_ecid,5L ++ ++#define SN_wap_wsg_idm_ecid_wtls6 "wap-wsg-idm-ecid-wtls6" ++#define NID_wap_wsg_idm_ecid_wtls6 739 ++#define OBJ_wap_wsg_idm_ecid_wtls6 OBJ_wap_wsg_idm_ecid,6L ++ ++#define SN_wap_wsg_idm_ecid_wtls7 "wap-wsg-idm-ecid-wtls7" ++#define NID_wap_wsg_idm_ecid_wtls7 740 ++#define OBJ_wap_wsg_idm_ecid_wtls7 OBJ_wap_wsg_idm_ecid,7L ++ ++#define SN_wap_wsg_idm_ecid_wtls8 "wap-wsg-idm-ecid-wtls8" ++#define NID_wap_wsg_idm_ecid_wtls8 741 ++#define OBJ_wap_wsg_idm_ecid_wtls8 OBJ_wap_wsg_idm_ecid,8L ++ ++#define SN_wap_wsg_idm_ecid_wtls9 "wap-wsg-idm-ecid-wtls9" ++#define NID_wap_wsg_idm_ecid_wtls9 742 ++#define OBJ_wap_wsg_idm_ecid_wtls9 OBJ_wap_wsg_idm_ecid,9L ++ ++#define SN_wap_wsg_idm_ecid_wtls10 "wap-wsg-idm-ecid-wtls10" ++#define NID_wap_wsg_idm_ecid_wtls10 743 ++#define OBJ_wap_wsg_idm_ecid_wtls10 OBJ_wap_wsg_idm_ecid,10L ++ ++#define SN_wap_wsg_idm_ecid_wtls11 "wap-wsg-idm-ecid-wtls11" ++#define NID_wap_wsg_idm_ecid_wtls11 744 ++#define OBJ_wap_wsg_idm_ecid_wtls11 OBJ_wap_wsg_idm_ecid,11L ++ ++#define SN_wap_wsg_idm_ecid_wtls12 "wap-wsg-idm-ecid-wtls12" ++#define NID_wap_wsg_idm_ecid_wtls12 745 ++#define OBJ_wap_wsg_idm_ecid_wtls12 OBJ_wap_wsg_idm_ecid,12L ++ ++#define SN_cast5_cbc "CAST5-CBC" ++#define LN_cast5_cbc "cast5-cbc" ++#define NID_cast5_cbc 108 ++#define OBJ_cast5_cbc OBJ_ISO_US,113533L,7L,66L,10L ++ ++#define SN_cast5_ecb "CAST5-ECB" ++#define LN_cast5_ecb "cast5-ecb" ++#define NID_cast5_ecb 109 ++ ++#define SN_cast5_cfb64 "CAST5-CFB" ++#define LN_cast5_cfb64 "cast5-cfb" ++#define NID_cast5_cfb64 110 ++ ++#define SN_cast5_ofb64 "CAST5-OFB" ++#define LN_cast5_ofb64 "cast5-ofb" ++#define NID_cast5_ofb64 111 ++ ++#define LN_pbeWithMD5AndCast5_CBC "pbeWithMD5AndCast5CBC" ++#define NID_pbeWithMD5AndCast5_CBC 112 ++#define OBJ_pbeWithMD5AndCast5_CBC OBJ_ISO_US,113533L,7L,66L,12L ++ ++#define SN_id_PasswordBasedMAC "id-PasswordBasedMAC" ++#define LN_id_PasswordBasedMAC "password based MAC" ++#define NID_id_PasswordBasedMAC 782 ++#define OBJ_id_PasswordBasedMAC OBJ_ISO_US,113533L,7L,66L,13L ++ ++#define SN_id_DHBasedMac "id-DHBasedMac" ++#define LN_id_DHBasedMac "Diffie-Hellman based MAC" ++#define NID_id_DHBasedMac 783 ++#define OBJ_id_DHBasedMac OBJ_ISO_US,113533L,7L,66L,30L ++ ++#define SN_rsadsi "rsadsi" ++#define LN_rsadsi "RSA Data Security, Inc." ++#define NID_rsadsi 1 ++#define OBJ_rsadsi OBJ_ISO_US,113549L ++ ++#define SN_pkcs "pkcs" ++#define LN_pkcs "RSA Data Security, Inc. PKCS" ++#define NID_pkcs 2 ++#define OBJ_pkcs OBJ_rsadsi,1L ++ ++#define SN_pkcs1 "pkcs1" ++#define NID_pkcs1 186 ++#define OBJ_pkcs1 OBJ_pkcs,1L ++ ++#define LN_rsaEncryption "rsaEncryption" ++#define NID_rsaEncryption 6 ++#define OBJ_rsaEncryption OBJ_pkcs1,1L ++ ++#define SN_md2WithRSAEncryption "RSA-MD2" ++#define LN_md2WithRSAEncryption "md2WithRSAEncryption" ++#define NID_md2WithRSAEncryption 7 ++#define OBJ_md2WithRSAEncryption OBJ_pkcs1,2L ++ ++#define SN_md4WithRSAEncryption "RSA-MD4" ++#define LN_md4WithRSAEncryption "md4WithRSAEncryption" ++#define NID_md4WithRSAEncryption 396 ++#define OBJ_md4WithRSAEncryption OBJ_pkcs1,3L ++ ++#define SN_md5WithRSAEncryption "RSA-MD5" ++#define LN_md5WithRSAEncryption "md5WithRSAEncryption" ++#define NID_md5WithRSAEncryption 8 ++#define OBJ_md5WithRSAEncryption OBJ_pkcs1,4L ++ ++#define SN_sha1WithRSAEncryption "RSA-SHA1" ++#define LN_sha1WithRSAEncryption "sha1WithRSAEncryption" ++#define NID_sha1WithRSAEncryption 65 ++#define OBJ_sha1WithRSAEncryption OBJ_pkcs1,5L ++ ++#define SN_sha256WithRSAEncryption "RSA-SHA256" ++#define LN_sha256WithRSAEncryption "sha256WithRSAEncryption" ++#define NID_sha256WithRSAEncryption 668 ++#define OBJ_sha256WithRSAEncryption OBJ_pkcs1,11L ++ ++#define SN_sha384WithRSAEncryption "RSA-SHA384" ++#define LN_sha384WithRSAEncryption "sha384WithRSAEncryption" ++#define NID_sha384WithRSAEncryption 669 ++#define OBJ_sha384WithRSAEncryption OBJ_pkcs1,12L ++ ++#define SN_sha512WithRSAEncryption "RSA-SHA512" ++#define LN_sha512WithRSAEncryption "sha512WithRSAEncryption" ++#define NID_sha512WithRSAEncryption 670 ++#define OBJ_sha512WithRSAEncryption OBJ_pkcs1,13L ++ ++#define SN_sha224WithRSAEncryption "RSA-SHA224" ++#define LN_sha224WithRSAEncryption "sha224WithRSAEncryption" ++#define NID_sha224WithRSAEncryption 671 ++#define OBJ_sha224WithRSAEncryption OBJ_pkcs1,14L ++ ++#define SN_pkcs3 "pkcs3" ++#define NID_pkcs3 27 ++#define OBJ_pkcs3 OBJ_pkcs,3L ++ ++#define LN_dhKeyAgreement "dhKeyAgreement" ++#define NID_dhKeyAgreement 28 ++#define OBJ_dhKeyAgreement OBJ_pkcs3,1L ++ ++#define SN_pkcs5 "pkcs5" ++#define NID_pkcs5 187 ++#define OBJ_pkcs5 OBJ_pkcs,5L ++ ++#define SN_pbeWithMD2AndDES_CBC "PBE-MD2-DES" ++#define LN_pbeWithMD2AndDES_CBC "pbeWithMD2AndDES-CBC" ++#define NID_pbeWithMD2AndDES_CBC 9 ++#define OBJ_pbeWithMD2AndDES_CBC OBJ_pkcs5,1L ++ ++#define SN_pbeWithMD5AndDES_CBC "PBE-MD5-DES" ++#define LN_pbeWithMD5AndDES_CBC "pbeWithMD5AndDES-CBC" ++#define NID_pbeWithMD5AndDES_CBC 10 ++#define OBJ_pbeWithMD5AndDES_CBC OBJ_pkcs5,3L ++ ++#define SN_pbeWithMD2AndRC2_CBC "PBE-MD2-RC2-64" ++#define LN_pbeWithMD2AndRC2_CBC "pbeWithMD2AndRC2-CBC" ++#define NID_pbeWithMD2AndRC2_CBC 168 ++#define OBJ_pbeWithMD2AndRC2_CBC OBJ_pkcs5,4L ++ ++#define SN_pbeWithMD5AndRC2_CBC "PBE-MD5-RC2-64" ++#define LN_pbeWithMD5AndRC2_CBC "pbeWithMD5AndRC2-CBC" ++#define NID_pbeWithMD5AndRC2_CBC 169 ++#define OBJ_pbeWithMD5AndRC2_CBC OBJ_pkcs5,6L ++ ++#define SN_pbeWithSHA1AndDES_CBC "PBE-SHA1-DES" ++#define LN_pbeWithSHA1AndDES_CBC "pbeWithSHA1AndDES-CBC" ++#define NID_pbeWithSHA1AndDES_CBC 170 ++#define OBJ_pbeWithSHA1AndDES_CBC OBJ_pkcs5,10L ++ ++#define SN_pbeWithSHA1AndRC2_CBC "PBE-SHA1-RC2-64" ++#define LN_pbeWithSHA1AndRC2_CBC "pbeWithSHA1AndRC2-CBC" ++#define NID_pbeWithSHA1AndRC2_CBC 68 ++#define OBJ_pbeWithSHA1AndRC2_CBC OBJ_pkcs5,11L ++ ++#define LN_id_pbkdf2 "PBKDF2" ++#define NID_id_pbkdf2 69 ++#define OBJ_id_pbkdf2 OBJ_pkcs5,12L ++ ++#define LN_pbes2 "PBES2" ++#define NID_pbes2 161 ++#define OBJ_pbes2 OBJ_pkcs5,13L ++ ++#define LN_pbmac1 "PBMAC1" ++#define NID_pbmac1 162 ++#define OBJ_pbmac1 OBJ_pkcs5,14L ++ ++#define SN_pkcs7 "pkcs7" ++#define NID_pkcs7 20 ++#define OBJ_pkcs7 OBJ_pkcs,7L ++ ++#define LN_pkcs7_data "pkcs7-data" ++#define NID_pkcs7_data 21 ++#define OBJ_pkcs7_data OBJ_pkcs7,1L ++ ++#define LN_pkcs7_signed "pkcs7-signedData" ++#define NID_pkcs7_signed 22 ++#define OBJ_pkcs7_signed OBJ_pkcs7,2L ++ ++#define LN_pkcs7_enveloped "pkcs7-envelopedData" ++#define NID_pkcs7_enveloped 23 ++#define OBJ_pkcs7_enveloped OBJ_pkcs7,3L ++ ++#define LN_pkcs7_signedAndEnveloped "pkcs7-signedAndEnvelopedData" ++#define NID_pkcs7_signedAndEnveloped 24 ++#define OBJ_pkcs7_signedAndEnveloped OBJ_pkcs7,4L ++ ++#define LN_pkcs7_digest "pkcs7-digestData" ++#define NID_pkcs7_digest 25 ++#define OBJ_pkcs7_digest OBJ_pkcs7,5L ++ ++#define LN_pkcs7_encrypted "pkcs7-encryptedData" ++#define NID_pkcs7_encrypted 26 ++#define OBJ_pkcs7_encrypted OBJ_pkcs7,6L ++ ++#define SN_pkcs9 "pkcs9" ++#define NID_pkcs9 47 ++#define OBJ_pkcs9 OBJ_pkcs,9L ++ ++#define LN_pkcs9_emailAddress "emailAddress" ++#define NID_pkcs9_emailAddress 48 ++#define OBJ_pkcs9_emailAddress OBJ_pkcs9,1L ++ ++#define LN_pkcs9_unstructuredName "unstructuredName" ++#define NID_pkcs9_unstructuredName 49 ++#define OBJ_pkcs9_unstructuredName OBJ_pkcs9,2L ++ ++#define LN_pkcs9_contentType "contentType" ++#define NID_pkcs9_contentType 50 ++#define OBJ_pkcs9_contentType OBJ_pkcs9,3L ++ ++#define LN_pkcs9_messageDigest "messageDigest" ++#define NID_pkcs9_messageDigest 51 ++#define OBJ_pkcs9_messageDigest OBJ_pkcs9,4L ++ ++#define LN_pkcs9_signingTime "signingTime" ++#define NID_pkcs9_signingTime 52 ++#define OBJ_pkcs9_signingTime OBJ_pkcs9,5L ++ ++#define LN_pkcs9_countersignature "countersignature" ++#define NID_pkcs9_countersignature 53 ++#define OBJ_pkcs9_countersignature OBJ_pkcs9,6L ++ ++#define LN_pkcs9_challengePassword "challengePassword" ++#define NID_pkcs9_challengePassword 54 ++#define OBJ_pkcs9_challengePassword OBJ_pkcs9,7L ++ ++#define LN_pkcs9_unstructuredAddress "unstructuredAddress" ++#define NID_pkcs9_unstructuredAddress 55 ++#define OBJ_pkcs9_unstructuredAddress OBJ_pkcs9,8L ++ ++#define LN_pkcs9_extCertAttributes "extendedCertificateAttributes" ++#define NID_pkcs9_extCertAttributes 56 ++#define OBJ_pkcs9_extCertAttributes OBJ_pkcs9,9L ++ ++#define SN_ext_req "extReq" ++#define LN_ext_req "Extension Request" ++#define NID_ext_req 172 ++#define OBJ_ext_req OBJ_pkcs9,14L ++ ++#define SN_SMIMECapabilities "SMIME-CAPS" ++#define LN_SMIMECapabilities "S/MIME Capabilities" ++#define NID_SMIMECapabilities 167 ++#define OBJ_SMIMECapabilities OBJ_pkcs9,15L ++ ++#define SN_SMIME "SMIME" ++#define LN_SMIME "S/MIME" ++#define NID_SMIME 188 ++#define OBJ_SMIME OBJ_pkcs9,16L ++ ++#define SN_id_smime_mod "id-smime-mod" ++#define NID_id_smime_mod 189 ++#define OBJ_id_smime_mod OBJ_SMIME,0L ++ ++#define SN_id_smime_ct "id-smime-ct" ++#define NID_id_smime_ct 190 ++#define OBJ_id_smime_ct OBJ_SMIME,1L ++ ++#define SN_id_smime_aa "id-smime-aa" ++#define NID_id_smime_aa 191 ++#define OBJ_id_smime_aa OBJ_SMIME,2L ++ ++#define SN_id_smime_alg "id-smime-alg" ++#define NID_id_smime_alg 192 ++#define OBJ_id_smime_alg OBJ_SMIME,3L ++ ++#define SN_id_smime_cd "id-smime-cd" ++#define NID_id_smime_cd 193 ++#define OBJ_id_smime_cd OBJ_SMIME,4L ++ ++#define SN_id_smime_spq "id-smime-spq" ++#define NID_id_smime_spq 194 ++#define OBJ_id_smime_spq OBJ_SMIME,5L ++ ++#define SN_id_smime_cti "id-smime-cti" ++#define NID_id_smime_cti 195 ++#define OBJ_id_smime_cti OBJ_SMIME,6L ++ ++#define SN_id_smime_mod_cms "id-smime-mod-cms" ++#define NID_id_smime_mod_cms 196 ++#define OBJ_id_smime_mod_cms OBJ_id_smime_mod,1L ++ ++#define SN_id_smime_mod_ess "id-smime-mod-ess" ++#define NID_id_smime_mod_ess 197 ++#define OBJ_id_smime_mod_ess OBJ_id_smime_mod,2L ++ ++#define SN_id_smime_mod_oid "id-smime-mod-oid" ++#define NID_id_smime_mod_oid 198 ++#define OBJ_id_smime_mod_oid OBJ_id_smime_mod,3L ++ ++#define SN_id_smime_mod_msg_v3 "id-smime-mod-msg-v3" ++#define NID_id_smime_mod_msg_v3 199 ++#define OBJ_id_smime_mod_msg_v3 OBJ_id_smime_mod,4L ++ ++#define SN_id_smime_mod_ets_eSignature_88 "id-smime-mod-ets-eSignature-88" ++#define NID_id_smime_mod_ets_eSignature_88 200 ++#define OBJ_id_smime_mod_ets_eSignature_88 OBJ_id_smime_mod,5L ++ ++#define SN_id_smime_mod_ets_eSignature_97 "id-smime-mod-ets-eSignature-97" ++#define NID_id_smime_mod_ets_eSignature_97 201 ++#define OBJ_id_smime_mod_ets_eSignature_97 OBJ_id_smime_mod,6L ++ ++#define SN_id_smime_mod_ets_eSigPolicy_88 "id-smime-mod-ets-eSigPolicy-88" ++#define NID_id_smime_mod_ets_eSigPolicy_88 202 ++#define OBJ_id_smime_mod_ets_eSigPolicy_88 OBJ_id_smime_mod,7L ++ ++#define SN_id_smime_mod_ets_eSigPolicy_97 "id-smime-mod-ets-eSigPolicy-97" ++#define NID_id_smime_mod_ets_eSigPolicy_97 203 ++#define OBJ_id_smime_mod_ets_eSigPolicy_97 OBJ_id_smime_mod,8L ++ ++#define SN_id_smime_ct_receipt "id-smime-ct-receipt" ++#define NID_id_smime_ct_receipt 204 ++#define OBJ_id_smime_ct_receipt OBJ_id_smime_ct,1L ++ ++#define SN_id_smime_ct_authData "id-smime-ct-authData" ++#define NID_id_smime_ct_authData 205 ++#define OBJ_id_smime_ct_authData OBJ_id_smime_ct,2L ++ ++#define SN_id_smime_ct_publishCert "id-smime-ct-publishCert" ++#define NID_id_smime_ct_publishCert 206 ++#define OBJ_id_smime_ct_publishCert OBJ_id_smime_ct,3L ++ ++#define SN_id_smime_ct_TSTInfo "id-smime-ct-TSTInfo" ++#define NID_id_smime_ct_TSTInfo 207 ++#define OBJ_id_smime_ct_TSTInfo OBJ_id_smime_ct,4L ++ ++#define SN_id_smime_ct_TDTInfo "id-smime-ct-TDTInfo" ++#define NID_id_smime_ct_TDTInfo 208 ++#define OBJ_id_smime_ct_TDTInfo OBJ_id_smime_ct,5L ++ ++#define SN_id_smime_ct_contentInfo "id-smime-ct-contentInfo" ++#define NID_id_smime_ct_contentInfo 209 ++#define OBJ_id_smime_ct_contentInfo OBJ_id_smime_ct,6L ++ ++#define SN_id_smime_ct_DVCSRequestData "id-smime-ct-DVCSRequestData" ++#define NID_id_smime_ct_DVCSRequestData 210 ++#define OBJ_id_smime_ct_DVCSRequestData OBJ_id_smime_ct,7L ++ ++#define SN_id_smime_ct_DVCSResponseData "id-smime-ct-DVCSResponseData" ++#define NID_id_smime_ct_DVCSResponseData 211 ++#define OBJ_id_smime_ct_DVCSResponseData OBJ_id_smime_ct,8L ++ ++#define SN_id_smime_ct_compressedData "id-smime-ct-compressedData" ++#define NID_id_smime_ct_compressedData 786 ++#define OBJ_id_smime_ct_compressedData OBJ_id_smime_ct,9L ++ ++#define SN_id_ct_asciiTextWithCRLF "id-ct-asciiTextWithCRLF" ++#define NID_id_ct_asciiTextWithCRLF 787 ++#define OBJ_id_ct_asciiTextWithCRLF OBJ_id_smime_ct,27L ++ ++#define SN_id_smime_aa_receiptRequest "id-smime-aa-receiptRequest" ++#define NID_id_smime_aa_receiptRequest 212 ++#define OBJ_id_smime_aa_receiptRequest OBJ_id_smime_aa,1L ++ ++#define SN_id_smime_aa_securityLabel "id-smime-aa-securityLabel" ++#define NID_id_smime_aa_securityLabel 213 ++#define OBJ_id_smime_aa_securityLabel OBJ_id_smime_aa,2L ++ ++#define SN_id_smime_aa_mlExpandHistory "id-smime-aa-mlExpandHistory" ++#define NID_id_smime_aa_mlExpandHistory 214 ++#define OBJ_id_smime_aa_mlExpandHistory OBJ_id_smime_aa,3L ++ ++#define SN_id_smime_aa_contentHint "id-smime-aa-contentHint" ++#define NID_id_smime_aa_contentHint 215 ++#define OBJ_id_smime_aa_contentHint OBJ_id_smime_aa,4L ++ ++#define SN_id_smime_aa_msgSigDigest "id-smime-aa-msgSigDigest" ++#define NID_id_smime_aa_msgSigDigest 216 ++#define OBJ_id_smime_aa_msgSigDigest OBJ_id_smime_aa,5L ++ ++#define SN_id_smime_aa_encapContentType "id-smime-aa-encapContentType" ++#define NID_id_smime_aa_encapContentType 217 ++#define OBJ_id_smime_aa_encapContentType OBJ_id_smime_aa,6L ++ ++#define SN_id_smime_aa_contentIdentifier "id-smime-aa-contentIdentifier" ++#define NID_id_smime_aa_contentIdentifier 218 ++#define OBJ_id_smime_aa_contentIdentifier OBJ_id_smime_aa,7L ++ ++#define SN_id_smime_aa_macValue "id-smime-aa-macValue" ++#define NID_id_smime_aa_macValue 219 ++#define OBJ_id_smime_aa_macValue OBJ_id_smime_aa,8L ++ ++#define SN_id_smime_aa_equivalentLabels "id-smime-aa-equivalentLabels" ++#define NID_id_smime_aa_equivalentLabels 220 ++#define OBJ_id_smime_aa_equivalentLabels OBJ_id_smime_aa,9L ++ ++#define SN_id_smime_aa_contentReference "id-smime-aa-contentReference" ++#define NID_id_smime_aa_contentReference 221 ++#define OBJ_id_smime_aa_contentReference OBJ_id_smime_aa,10L ++ ++#define SN_id_smime_aa_encrypKeyPref "id-smime-aa-encrypKeyPref" ++#define NID_id_smime_aa_encrypKeyPref 222 ++#define OBJ_id_smime_aa_encrypKeyPref OBJ_id_smime_aa,11L ++ ++#define SN_id_smime_aa_signingCertificate "id-smime-aa-signingCertificate" ++#define NID_id_smime_aa_signingCertificate 223 ++#define OBJ_id_smime_aa_signingCertificate OBJ_id_smime_aa,12L ++ ++#define SN_id_smime_aa_smimeEncryptCerts "id-smime-aa-smimeEncryptCerts" ++#define NID_id_smime_aa_smimeEncryptCerts 224 ++#define OBJ_id_smime_aa_smimeEncryptCerts OBJ_id_smime_aa,13L ++ ++#define SN_id_smime_aa_timeStampToken "id-smime-aa-timeStampToken" ++#define NID_id_smime_aa_timeStampToken 225 ++#define OBJ_id_smime_aa_timeStampToken OBJ_id_smime_aa,14L ++ ++#define SN_id_smime_aa_ets_sigPolicyId "id-smime-aa-ets-sigPolicyId" ++#define NID_id_smime_aa_ets_sigPolicyId 226 ++#define OBJ_id_smime_aa_ets_sigPolicyId OBJ_id_smime_aa,15L ++ ++#define SN_id_smime_aa_ets_commitmentType "id-smime-aa-ets-commitmentType" ++#define NID_id_smime_aa_ets_commitmentType 227 ++#define OBJ_id_smime_aa_ets_commitmentType OBJ_id_smime_aa,16L ++ ++#define SN_id_smime_aa_ets_signerLocation "id-smime-aa-ets-signerLocation" ++#define NID_id_smime_aa_ets_signerLocation 228 ++#define OBJ_id_smime_aa_ets_signerLocation OBJ_id_smime_aa,17L ++ ++#define SN_id_smime_aa_ets_signerAttr "id-smime-aa-ets-signerAttr" ++#define NID_id_smime_aa_ets_signerAttr 229 ++#define OBJ_id_smime_aa_ets_signerAttr OBJ_id_smime_aa,18L ++ ++#define SN_id_smime_aa_ets_otherSigCert "id-smime-aa-ets-otherSigCert" ++#define NID_id_smime_aa_ets_otherSigCert 230 ++#define OBJ_id_smime_aa_ets_otherSigCert OBJ_id_smime_aa,19L ++ ++#define SN_id_smime_aa_ets_contentTimestamp "id-smime-aa-ets-contentTimestamp" ++#define NID_id_smime_aa_ets_contentTimestamp 231 ++#define OBJ_id_smime_aa_ets_contentTimestamp OBJ_id_smime_aa,20L ++ ++#define SN_id_smime_aa_ets_CertificateRefs "id-smime-aa-ets-CertificateRefs" ++#define NID_id_smime_aa_ets_CertificateRefs 232 ++#define OBJ_id_smime_aa_ets_CertificateRefs OBJ_id_smime_aa,21L ++ ++#define SN_id_smime_aa_ets_RevocationRefs "id-smime-aa-ets-RevocationRefs" ++#define NID_id_smime_aa_ets_RevocationRefs 233 ++#define OBJ_id_smime_aa_ets_RevocationRefs OBJ_id_smime_aa,22L ++ ++#define SN_id_smime_aa_ets_certValues "id-smime-aa-ets-certValues" ++#define NID_id_smime_aa_ets_certValues 234 ++#define OBJ_id_smime_aa_ets_certValues OBJ_id_smime_aa,23L ++ ++#define SN_id_smime_aa_ets_revocationValues "id-smime-aa-ets-revocationValues" ++#define NID_id_smime_aa_ets_revocationValues 235 ++#define OBJ_id_smime_aa_ets_revocationValues OBJ_id_smime_aa,24L ++ ++#define SN_id_smime_aa_ets_escTimeStamp "id-smime-aa-ets-escTimeStamp" ++#define NID_id_smime_aa_ets_escTimeStamp 236 ++#define OBJ_id_smime_aa_ets_escTimeStamp OBJ_id_smime_aa,25L ++ ++#define SN_id_smime_aa_ets_certCRLTimestamp "id-smime-aa-ets-certCRLTimestamp" ++#define NID_id_smime_aa_ets_certCRLTimestamp 237 ++#define OBJ_id_smime_aa_ets_certCRLTimestamp OBJ_id_smime_aa,26L ++ ++#define SN_id_smime_aa_ets_archiveTimeStamp "id-smime-aa-ets-archiveTimeStamp" ++#define NID_id_smime_aa_ets_archiveTimeStamp 238 ++#define OBJ_id_smime_aa_ets_archiveTimeStamp OBJ_id_smime_aa,27L ++ ++#define SN_id_smime_aa_signatureType "id-smime-aa-signatureType" ++#define NID_id_smime_aa_signatureType 239 ++#define OBJ_id_smime_aa_signatureType OBJ_id_smime_aa,28L ++ ++#define SN_id_smime_aa_dvcs_dvc "id-smime-aa-dvcs-dvc" ++#define NID_id_smime_aa_dvcs_dvc 240 ++#define OBJ_id_smime_aa_dvcs_dvc OBJ_id_smime_aa,29L ++ ++#define SN_id_smime_alg_ESDHwith3DES "id-smime-alg-ESDHwith3DES" ++#define NID_id_smime_alg_ESDHwith3DES 241 ++#define OBJ_id_smime_alg_ESDHwith3DES OBJ_id_smime_alg,1L ++ ++#define SN_id_smime_alg_ESDHwithRC2 "id-smime-alg-ESDHwithRC2" ++#define NID_id_smime_alg_ESDHwithRC2 242 ++#define OBJ_id_smime_alg_ESDHwithRC2 OBJ_id_smime_alg,2L ++ ++#define SN_id_smime_alg_3DESwrap "id-smime-alg-3DESwrap" ++#define NID_id_smime_alg_3DESwrap 243 ++#define OBJ_id_smime_alg_3DESwrap OBJ_id_smime_alg,3L ++ ++#define SN_id_smime_alg_RC2wrap "id-smime-alg-RC2wrap" ++#define NID_id_smime_alg_RC2wrap 244 ++#define OBJ_id_smime_alg_RC2wrap OBJ_id_smime_alg,4L ++ ++#define SN_id_smime_alg_ESDH "id-smime-alg-ESDH" ++#define NID_id_smime_alg_ESDH 245 ++#define OBJ_id_smime_alg_ESDH OBJ_id_smime_alg,5L ++ ++#define SN_id_smime_alg_CMS3DESwrap "id-smime-alg-CMS3DESwrap" ++#define NID_id_smime_alg_CMS3DESwrap 246 ++#define OBJ_id_smime_alg_CMS3DESwrap OBJ_id_smime_alg,6L ++ ++#define SN_id_smime_alg_CMSRC2wrap "id-smime-alg-CMSRC2wrap" ++#define NID_id_smime_alg_CMSRC2wrap 247 ++#define OBJ_id_smime_alg_CMSRC2wrap OBJ_id_smime_alg,7L ++ ++#define SN_id_smime_cd_ldap "id-smime-cd-ldap" ++#define NID_id_smime_cd_ldap 248 ++#define OBJ_id_smime_cd_ldap OBJ_id_smime_cd,1L ++ ++#define SN_id_smime_spq_ets_sqt_uri "id-smime-spq-ets-sqt-uri" ++#define NID_id_smime_spq_ets_sqt_uri 249 ++#define OBJ_id_smime_spq_ets_sqt_uri OBJ_id_smime_spq,1L ++ ++#define SN_id_smime_spq_ets_sqt_unotice "id-smime-spq-ets-sqt-unotice" ++#define NID_id_smime_spq_ets_sqt_unotice 250 ++#define OBJ_id_smime_spq_ets_sqt_unotice OBJ_id_smime_spq,2L ++ ++#define SN_id_smime_cti_ets_proofOfOrigin "id-smime-cti-ets-proofOfOrigin" ++#define NID_id_smime_cti_ets_proofOfOrigin 251 ++#define OBJ_id_smime_cti_ets_proofOfOrigin OBJ_id_smime_cti,1L ++ ++#define SN_id_smime_cti_ets_proofOfReceipt "id-smime-cti-ets-proofOfReceipt" ++#define NID_id_smime_cti_ets_proofOfReceipt 252 ++#define OBJ_id_smime_cti_ets_proofOfReceipt OBJ_id_smime_cti,2L ++ ++#define SN_id_smime_cti_ets_proofOfDelivery "id-smime-cti-ets-proofOfDelivery" ++#define NID_id_smime_cti_ets_proofOfDelivery 253 ++#define OBJ_id_smime_cti_ets_proofOfDelivery OBJ_id_smime_cti,3L ++ ++#define SN_id_smime_cti_ets_proofOfSender "id-smime-cti-ets-proofOfSender" ++#define NID_id_smime_cti_ets_proofOfSender 254 ++#define OBJ_id_smime_cti_ets_proofOfSender OBJ_id_smime_cti,4L ++ ++#define SN_id_smime_cti_ets_proofOfApproval "id-smime-cti-ets-proofOfApproval" ++#define NID_id_smime_cti_ets_proofOfApproval 255 ++#define OBJ_id_smime_cti_ets_proofOfApproval OBJ_id_smime_cti,5L ++ ++#define SN_id_smime_cti_ets_proofOfCreation "id-smime-cti-ets-proofOfCreation" ++#define NID_id_smime_cti_ets_proofOfCreation 256 ++#define OBJ_id_smime_cti_ets_proofOfCreation OBJ_id_smime_cti,6L ++ ++#define LN_friendlyName "friendlyName" ++#define NID_friendlyName 156 ++#define OBJ_friendlyName OBJ_pkcs9,20L ++ ++#define LN_localKeyID "localKeyID" ++#define NID_localKeyID 157 ++#define OBJ_localKeyID OBJ_pkcs9,21L ++ ++#define SN_ms_csp_name "CSPName" ++#define LN_ms_csp_name "Microsoft CSP Name" ++#define NID_ms_csp_name 417 ++#define OBJ_ms_csp_name 1L,3L,6L,1L,4L,1L,311L,17L,1L ++ ++#define SN_LocalKeySet "LocalKeySet" ++#define LN_LocalKeySet "Microsoft Local Key set" ++#define NID_LocalKeySet 856 ++#define OBJ_LocalKeySet 1L,3L,6L,1L,4L,1L,311L,17L,2L ++ ++#define OBJ_certTypes OBJ_pkcs9,22L ++ ++#define LN_x509Certificate "x509Certificate" ++#define NID_x509Certificate 158 ++#define OBJ_x509Certificate OBJ_certTypes,1L ++ ++#define LN_sdsiCertificate "sdsiCertificate" ++#define NID_sdsiCertificate 159 ++#define OBJ_sdsiCertificate OBJ_certTypes,2L ++ ++#define OBJ_crlTypes OBJ_pkcs9,23L ++ ++#define LN_x509Crl "x509Crl" ++#define NID_x509Crl 160 ++#define OBJ_x509Crl OBJ_crlTypes,1L ++ ++#define OBJ_pkcs12 OBJ_pkcs,12L ++ ++#define OBJ_pkcs12_pbeids OBJ_pkcs12,1L ++ ++#define SN_pbe_WithSHA1And128BitRC4 "PBE-SHA1-RC4-128" ++#define LN_pbe_WithSHA1And128BitRC4 "pbeWithSHA1And128BitRC4" ++#define NID_pbe_WithSHA1And128BitRC4 144 ++#define OBJ_pbe_WithSHA1And128BitRC4 OBJ_pkcs12_pbeids,1L ++ ++#define SN_pbe_WithSHA1And40BitRC4 "PBE-SHA1-RC4-40" ++#define LN_pbe_WithSHA1And40BitRC4 "pbeWithSHA1And40BitRC4" ++#define NID_pbe_WithSHA1And40BitRC4 145 ++#define OBJ_pbe_WithSHA1And40BitRC4 OBJ_pkcs12_pbeids,2L ++ ++#define SN_pbe_WithSHA1And3_Key_TripleDES_CBC "PBE-SHA1-3DES" ++#define LN_pbe_WithSHA1And3_Key_TripleDES_CBC "pbeWithSHA1And3-KeyTripleDES-CBC" ++#define NID_pbe_WithSHA1And3_Key_TripleDES_CBC 146 ++#define OBJ_pbe_WithSHA1And3_Key_TripleDES_CBC OBJ_pkcs12_pbeids,3L ++ ++#define SN_pbe_WithSHA1And2_Key_TripleDES_CBC "PBE-SHA1-2DES" ++#define LN_pbe_WithSHA1And2_Key_TripleDES_CBC "pbeWithSHA1And2-KeyTripleDES-CBC" ++#define NID_pbe_WithSHA1And2_Key_TripleDES_CBC 147 ++#define OBJ_pbe_WithSHA1And2_Key_TripleDES_CBC OBJ_pkcs12_pbeids,4L ++ ++#define SN_pbe_WithSHA1And128BitRC2_CBC "PBE-SHA1-RC2-128" ++#define LN_pbe_WithSHA1And128BitRC2_CBC "pbeWithSHA1And128BitRC2-CBC" ++#define NID_pbe_WithSHA1And128BitRC2_CBC 148 ++#define OBJ_pbe_WithSHA1And128BitRC2_CBC OBJ_pkcs12_pbeids,5L ++ ++#define SN_pbe_WithSHA1And40BitRC2_CBC "PBE-SHA1-RC2-40" ++#define LN_pbe_WithSHA1And40BitRC2_CBC "pbeWithSHA1And40BitRC2-CBC" ++#define NID_pbe_WithSHA1And40BitRC2_CBC 149 ++#define OBJ_pbe_WithSHA1And40BitRC2_CBC OBJ_pkcs12_pbeids,6L ++ ++#define OBJ_pkcs12_Version1 OBJ_pkcs12,10L ++ ++#define OBJ_pkcs12_BagIds OBJ_pkcs12_Version1,1L ++ ++#define LN_keyBag "keyBag" ++#define NID_keyBag 150 ++#define OBJ_keyBag OBJ_pkcs12_BagIds,1L ++ ++#define LN_pkcs8ShroudedKeyBag "pkcs8ShroudedKeyBag" ++#define NID_pkcs8ShroudedKeyBag 151 ++#define OBJ_pkcs8ShroudedKeyBag OBJ_pkcs12_BagIds,2L ++ ++#define LN_certBag "certBag" ++#define NID_certBag 152 ++#define OBJ_certBag OBJ_pkcs12_BagIds,3L ++ ++#define LN_crlBag "crlBag" ++#define NID_crlBag 153 ++#define OBJ_crlBag OBJ_pkcs12_BagIds,4L ++ ++#define LN_secretBag "secretBag" ++#define NID_secretBag 154 ++#define OBJ_secretBag OBJ_pkcs12_BagIds,5L ++ ++#define LN_safeContentsBag "safeContentsBag" ++#define NID_safeContentsBag 155 ++#define OBJ_safeContentsBag OBJ_pkcs12_BagIds,6L ++ ++#define SN_md2 "MD2" ++#define LN_md2 "md2" ++#define NID_md2 3 ++#define OBJ_md2 OBJ_rsadsi,2L,2L ++ ++#define SN_md4 "MD4" ++#define LN_md4 "md4" ++#define NID_md4 257 ++#define OBJ_md4 OBJ_rsadsi,2L,4L ++ ++#define SN_md5 "MD5" ++#define LN_md5 "md5" ++#define NID_md5 4 ++#define OBJ_md5 OBJ_rsadsi,2L,5L ++ ++#define SN_md5_sha1 "MD5-SHA1" ++#define LN_md5_sha1 "md5-sha1" ++#define NID_md5_sha1 114 ++ ++#define LN_hmacWithMD5 "hmacWithMD5" ++#define NID_hmacWithMD5 797 ++#define OBJ_hmacWithMD5 OBJ_rsadsi,2L,6L ++ ++#define LN_hmacWithSHA1 "hmacWithSHA1" ++#define NID_hmacWithSHA1 163 ++#define OBJ_hmacWithSHA1 OBJ_rsadsi,2L,7L ++ ++#define LN_hmacWithSHA224 "hmacWithSHA224" ++#define NID_hmacWithSHA224 798 ++#define OBJ_hmacWithSHA224 OBJ_rsadsi,2L,8L ++ ++#define LN_hmacWithSHA256 "hmacWithSHA256" ++#define NID_hmacWithSHA256 799 ++#define OBJ_hmacWithSHA256 OBJ_rsadsi,2L,9L ++ ++#define LN_hmacWithSHA384 "hmacWithSHA384" ++#define NID_hmacWithSHA384 800 ++#define OBJ_hmacWithSHA384 OBJ_rsadsi,2L,10L ++ ++#define LN_hmacWithSHA512 "hmacWithSHA512" ++#define NID_hmacWithSHA512 801 ++#define OBJ_hmacWithSHA512 OBJ_rsadsi,2L,11L ++ ++#define SN_rc2_cbc "RC2-CBC" ++#define LN_rc2_cbc "rc2-cbc" ++#define NID_rc2_cbc 37 ++#define OBJ_rc2_cbc OBJ_rsadsi,3L,2L ++ ++#define SN_rc2_ecb "RC2-ECB" ++#define LN_rc2_ecb "rc2-ecb" ++#define NID_rc2_ecb 38 ++ ++#define SN_rc2_cfb64 "RC2-CFB" ++#define LN_rc2_cfb64 "rc2-cfb" ++#define NID_rc2_cfb64 39 ++ ++#define SN_rc2_ofb64 "RC2-OFB" ++#define LN_rc2_ofb64 "rc2-ofb" ++#define NID_rc2_ofb64 40 ++ ++#define SN_rc2_40_cbc "RC2-40-CBC" ++#define LN_rc2_40_cbc "rc2-40-cbc" ++#define NID_rc2_40_cbc 98 ++ ++#define SN_rc2_64_cbc "RC2-64-CBC" ++#define LN_rc2_64_cbc "rc2-64-cbc" ++#define NID_rc2_64_cbc 166 ++ ++#define SN_rc4 "RC4" ++#define LN_rc4 "rc4" ++#define NID_rc4 5 ++#define OBJ_rc4 OBJ_rsadsi,3L,4L ++ ++#define SN_rc4_40 "RC4-40" ++#define LN_rc4_40 "rc4-40" ++#define NID_rc4_40 97 ++ ++#define SN_des_ede3_cbc "DES-EDE3-CBC" ++#define LN_des_ede3_cbc "des-ede3-cbc" ++#define NID_des_ede3_cbc 44 ++#define OBJ_des_ede3_cbc OBJ_rsadsi,3L,7L ++ ++#define SN_rc5_cbc "RC5-CBC" ++#define LN_rc5_cbc "rc5-cbc" ++#define NID_rc5_cbc 120 ++#define OBJ_rc5_cbc OBJ_rsadsi,3L,8L ++ ++#define SN_rc5_ecb "RC5-ECB" ++#define LN_rc5_ecb "rc5-ecb" ++#define NID_rc5_ecb 121 ++ ++#define SN_rc5_cfb64 "RC5-CFB" ++#define LN_rc5_cfb64 "rc5-cfb" ++#define NID_rc5_cfb64 122 ++ ++#define SN_rc5_ofb64 "RC5-OFB" ++#define LN_rc5_ofb64 "rc5-ofb" ++#define NID_rc5_ofb64 123 ++ ++#define SN_ms_ext_req "msExtReq" ++#define LN_ms_ext_req "Microsoft Extension Request" ++#define NID_ms_ext_req 171 ++#define OBJ_ms_ext_req 1L,3L,6L,1L,4L,1L,311L,2L,1L,14L ++ ++#define SN_ms_code_ind "msCodeInd" ++#define LN_ms_code_ind "Microsoft Individual Code Signing" ++#define NID_ms_code_ind 134 ++#define OBJ_ms_code_ind 1L,3L,6L,1L,4L,1L,311L,2L,1L,21L ++ ++#define SN_ms_code_com "msCodeCom" ++#define LN_ms_code_com "Microsoft Commercial Code Signing" ++#define NID_ms_code_com 135 ++#define OBJ_ms_code_com 1L,3L,6L,1L,4L,1L,311L,2L,1L,22L ++ ++#define SN_ms_ctl_sign "msCTLSign" ++#define LN_ms_ctl_sign "Microsoft Trust List Signing" ++#define NID_ms_ctl_sign 136 ++#define OBJ_ms_ctl_sign 1L,3L,6L,1L,4L,1L,311L,10L,3L,1L ++ ++#define SN_ms_sgc "msSGC" ++#define LN_ms_sgc "Microsoft Server Gated Crypto" ++#define NID_ms_sgc 137 ++#define OBJ_ms_sgc 1L,3L,6L,1L,4L,1L,311L,10L,3L,3L ++ ++#define SN_ms_efs "msEFS" ++#define LN_ms_efs "Microsoft Encrypted File System" ++#define NID_ms_efs 138 ++#define OBJ_ms_efs 1L,3L,6L,1L,4L,1L,311L,10L,3L,4L ++ ++#define SN_ms_smartcard_login "msSmartcardLogin" ++#define LN_ms_smartcard_login "Microsoft Smartcardlogin" ++#define NID_ms_smartcard_login 648 ++#define OBJ_ms_smartcard_login 1L,3L,6L,1L,4L,1L,311L,20L,2L,2L ++ ++#define SN_ms_upn "msUPN" ++#define LN_ms_upn "Microsoft Universal Principal Name" ++#define NID_ms_upn 649 ++#define OBJ_ms_upn 1L,3L,6L,1L,4L,1L,311L,20L,2L,3L ++ ++#define SN_idea_cbc "IDEA-CBC" ++#define LN_idea_cbc "idea-cbc" ++#define NID_idea_cbc 34 ++#define OBJ_idea_cbc 1L,3L,6L,1L,4L,1L,188L,7L,1L,1L,2L ++ ++#define SN_idea_ecb "IDEA-ECB" ++#define LN_idea_ecb "idea-ecb" ++#define NID_idea_ecb 36 ++ ++#define SN_idea_cfb64 "IDEA-CFB" ++#define LN_idea_cfb64 "idea-cfb" ++#define NID_idea_cfb64 35 ++ ++#define SN_idea_ofb64 "IDEA-OFB" ++#define LN_idea_ofb64 "idea-ofb" ++#define NID_idea_ofb64 46 ++ ++#define SN_bf_cbc "BF-CBC" ++#define LN_bf_cbc "bf-cbc" ++#define NID_bf_cbc 91 ++#define OBJ_bf_cbc 1L,3L,6L,1L,4L,1L,3029L,1L,2L ++ ++#define SN_bf_ecb "BF-ECB" ++#define LN_bf_ecb "bf-ecb" ++#define NID_bf_ecb 92 ++ ++#define SN_bf_cfb64 "BF-CFB" ++#define LN_bf_cfb64 "bf-cfb" ++#define NID_bf_cfb64 93 ++ ++#define SN_bf_ofb64 "BF-OFB" ++#define LN_bf_ofb64 "bf-ofb" ++#define NID_bf_ofb64 94 ++ ++#define SN_id_pkix "PKIX" ++#define NID_id_pkix 127 ++#define OBJ_id_pkix 1L,3L,6L,1L,5L,5L,7L ++ ++#define SN_id_pkix_mod "id-pkix-mod" ++#define NID_id_pkix_mod 258 ++#define OBJ_id_pkix_mod OBJ_id_pkix,0L ++ ++#define SN_id_pe "id-pe" ++#define NID_id_pe 175 ++#define OBJ_id_pe OBJ_id_pkix,1L ++ ++#define SN_id_qt "id-qt" ++#define NID_id_qt 259 ++#define OBJ_id_qt OBJ_id_pkix,2L ++ ++#define SN_id_kp "id-kp" ++#define NID_id_kp 128 ++#define OBJ_id_kp OBJ_id_pkix,3L ++ ++#define SN_id_it "id-it" ++#define NID_id_it 260 ++#define OBJ_id_it OBJ_id_pkix,4L ++ ++#define SN_id_pkip "id-pkip" ++#define NID_id_pkip 261 ++#define OBJ_id_pkip OBJ_id_pkix,5L ++ ++#define SN_id_alg "id-alg" ++#define NID_id_alg 262 ++#define OBJ_id_alg OBJ_id_pkix,6L ++ ++#define SN_id_cmc "id-cmc" ++#define NID_id_cmc 263 ++#define OBJ_id_cmc OBJ_id_pkix,7L ++ ++#define SN_id_on "id-on" ++#define NID_id_on 264 ++#define OBJ_id_on OBJ_id_pkix,8L ++ ++#define SN_id_pda "id-pda" ++#define NID_id_pda 265 ++#define OBJ_id_pda OBJ_id_pkix,9L ++ ++#define SN_id_aca "id-aca" ++#define NID_id_aca 266 ++#define OBJ_id_aca OBJ_id_pkix,10L ++ ++#define SN_id_qcs "id-qcs" ++#define NID_id_qcs 267 ++#define OBJ_id_qcs OBJ_id_pkix,11L ++ ++#define SN_id_cct "id-cct" ++#define NID_id_cct 268 ++#define OBJ_id_cct OBJ_id_pkix,12L ++ ++#define SN_id_ppl "id-ppl" ++#define NID_id_ppl 662 ++#define OBJ_id_ppl OBJ_id_pkix,21L ++ ++#define SN_id_ad "id-ad" ++#define NID_id_ad 176 ++#define OBJ_id_ad OBJ_id_pkix,48L ++ ++#define SN_id_pkix1_explicit_88 "id-pkix1-explicit-88" ++#define NID_id_pkix1_explicit_88 269 ++#define OBJ_id_pkix1_explicit_88 OBJ_id_pkix_mod,1L ++ ++#define SN_id_pkix1_implicit_88 "id-pkix1-implicit-88" ++#define NID_id_pkix1_implicit_88 270 ++#define OBJ_id_pkix1_implicit_88 OBJ_id_pkix_mod,2L ++ ++#define SN_id_pkix1_explicit_93 "id-pkix1-explicit-93" ++#define NID_id_pkix1_explicit_93 271 ++#define OBJ_id_pkix1_explicit_93 OBJ_id_pkix_mod,3L ++ ++#define SN_id_pkix1_implicit_93 "id-pkix1-implicit-93" ++#define NID_id_pkix1_implicit_93 272 ++#define OBJ_id_pkix1_implicit_93 OBJ_id_pkix_mod,4L ++ ++#define SN_id_mod_crmf "id-mod-crmf" ++#define NID_id_mod_crmf 273 ++#define OBJ_id_mod_crmf OBJ_id_pkix_mod,5L ++ ++#define SN_id_mod_cmc "id-mod-cmc" ++#define NID_id_mod_cmc 274 ++#define OBJ_id_mod_cmc OBJ_id_pkix_mod,6L ++ ++#define SN_id_mod_kea_profile_88 "id-mod-kea-profile-88" ++#define NID_id_mod_kea_profile_88 275 ++#define OBJ_id_mod_kea_profile_88 OBJ_id_pkix_mod,7L ++ ++#define SN_id_mod_kea_profile_93 "id-mod-kea-profile-93" ++#define NID_id_mod_kea_profile_93 276 ++#define OBJ_id_mod_kea_profile_93 OBJ_id_pkix_mod,8L ++ ++#define SN_id_mod_cmp "id-mod-cmp" ++#define NID_id_mod_cmp 277 ++#define OBJ_id_mod_cmp OBJ_id_pkix_mod,9L ++ ++#define SN_id_mod_qualified_cert_88 "id-mod-qualified-cert-88" ++#define NID_id_mod_qualified_cert_88 278 ++#define OBJ_id_mod_qualified_cert_88 OBJ_id_pkix_mod,10L ++ ++#define SN_id_mod_qualified_cert_93 "id-mod-qualified-cert-93" ++#define NID_id_mod_qualified_cert_93 279 ++#define OBJ_id_mod_qualified_cert_93 OBJ_id_pkix_mod,11L ++ ++#define SN_id_mod_attribute_cert "id-mod-attribute-cert" ++#define NID_id_mod_attribute_cert 280 ++#define OBJ_id_mod_attribute_cert OBJ_id_pkix_mod,12L ++ ++#define SN_id_mod_timestamp_protocol "id-mod-timestamp-protocol" ++#define NID_id_mod_timestamp_protocol 281 ++#define OBJ_id_mod_timestamp_protocol OBJ_id_pkix_mod,13L ++ ++#define SN_id_mod_ocsp "id-mod-ocsp" ++#define NID_id_mod_ocsp 282 ++#define OBJ_id_mod_ocsp OBJ_id_pkix_mod,14L ++ ++#define SN_id_mod_dvcs "id-mod-dvcs" ++#define NID_id_mod_dvcs 283 ++#define OBJ_id_mod_dvcs OBJ_id_pkix_mod,15L ++ ++#define SN_id_mod_cmp2000 "id-mod-cmp2000" ++#define NID_id_mod_cmp2000 284 ++#define OBJ_id_mod_cmp2000 OBJ_id_pkix_mod,16L ++ ++#define SN_info_access "authorityInfoAccess" ++#define LN_info_access "Authority Information Access" ++#define NID_info_access 177 ++#define OBJ_info_access OBJ_id_pe,1L ++ ++#define SN_biometricInfo "biometricInfo" ++#define LN_biometricInfo "Biometric Info" ++#define NID_biometricInfo 285 ++#define OBJ_biometricInfo OBJ_id_pe,2L ++ ++#define SN_qcStatements "qcStatements" ++#define NID_qcStatements 286 ++#define OBJ_qcStatements OBJ_id_pe,3L ++ ++#define SN_ac_auditEntity "ac-auditEntity" ++#define NID_ac_auditEntity 287 ++#define OBJ_ac_auditEntity OBJ_id_pe,4L ++ ++#define SN_ac_targeting "ac-targeting" ++#define NID_ac_targeting 288 ++#define OBJ_ac_targeting OBJ_id_pe,5L ++ ++#define SN_aaControls "aaControls" ++#define NID_aaControls 289 ++#define OBJ_aaControls OBJ_id_pe,6L ++ ++#define SN_sbgp_ipAddrBlock "sbgp-ipAddrBlock" ++#define NID_sbgp_ipAddrBlock 290 ++#define OBJ_sbgp_ipAddrBlock OBJ_id_pe,7L ++ ++#define SN_sbgp_autonomousSysNum "sbgp-autonomousSysNum" ++#define NID_sbgp_autonomousSysNum 291 ++#define OBJ_sbgp_autonomousSysNum OBJ_id_pe,8L ++ ++#define SN_sbgp_routerIdentifier "sbgp-routerIdentifier" ++#define NID_sbgp_routerIdentifier 292 ++#define OBJ_sbgp_routerIdentifier OBJ_id_pe,9L ++ ++#define SN_ac_proxying "ac-proxying" ++#define NID_ac_proxying 397 ++#define OBJ_ac_proxying OBJ_id_pe,10L ++ ++#define SN_sinfo_access "subjectInfoAccess" ++#define LN_sinfo_access "Subject Information Access" ++#define NID_sinfo_access 398 ++#define OBJ_sinfo_access OBJ_id_pe,11L ++ ++#define SN_proxyCertInfo "proxyCertInfo" ++#define LN_proxyCertInfo "Proxy Certificate Information" ++#define NID_proxyCertInfo 663 ++#define OBJ_proxyCertInfo OBJ_id_pe,14L ++ ++#define SN_id_qt_cps "id-qt-cps" ++#define LN_id_qt_cps "Policy Qualifier CPS" ++#define NID_id_qt_cps 164 ++#define OBJ_id_qt_cps OBJ_id_qt,1L ++ ++#define SN_id_qt_unotice "id-qt-unotice" ++#define LN_id_qt_unotice "Policy Qualifier User Notice" ++#define NID_id_qt_unotice 165 ++#define OBJ_id_qt_unotice OBJ_id_qt,2L ++ ++#define SN_textNotice "textNotice" ++#define NID_textNotice 293 ++#define OBJ_textNotice OBJ_id_qt,3L ++ ++#define SN_server_auth "serverAuth" ++#define LN_server_auth "TLS Web Server Authentication" ++#define NID_server_auth 129 ++#define OBJ_server_auth OBJ_id_kp,1L ++ ++#define SN_client_auth "clientAuth" ++#define LN_client_auth "TLS Web Client Authentication" ++#define NID_client_auth 130 ++#define OBJ_client_auth OBJ_id_kp,2L ++ ++#define SN_code_sign "codeSigning" ++#define LN_code_sign "Code Signing" ++#define NID_code_sign 131 ++#define OBJ_code_sign OBJ_id_kp,3L ++ ++#define SN_email_protect "emailProtection" ++#define LN_email_protect "E-mail Protection" ++#define NID_email_protect 132 ++#define OBJ_email_protect OBJ_id_kp,4L ++ ++#define SN_ipsecEndSystem "ipsecEndSystem" ++#define LN_ipsecEndSystem "IPSec End System" ++#define NID_ipsecEndSystem 294 ++#define OBJ_ipsecEndSystem OBJ_id_kp,5L ++ ++#define SN_ipsecTunnel "ipsecTunnel" ++#define LN_ipsecTunnel "IPSec Tunnel" ++#define NID_ipsecTunnel 295 ++#define OBJ_ipsecTunnel OBJ_id_kp,6L ++ ++#define SN_ipsecUser "ipsecUser" ++#define LN_ipsecUser "IPSec User" ++#define NID_ipsecUser 296 ++#define OBJ_ipsecUser OBJ_id_kp,7L ++ ++#define SN_time_stamp "timeStamping" ++#define LN_time_stamp "Time Stamping" ++#define NID_time_stamp 133 ++#define OBJ_time_stamp OBJ_id_kp,8L ++ ++#define SN_OCSP_sign "OCSPSigning" ++#define LN_OCSP_sign "OCSP Signing" ++#define NID_OCSP_sign 180 ++#define OBJ_OCSP_sign OBJ_id_kp,9L ++ ++#define SN_dvcs "DVCS" ++#define LN_dvcs "dvcs" ++#define NID_dvcs 297 ++#define OBJ_dvcs OBJ_id_kp,10L ++ ++#define SN_id_it_caProtEncCert "id-it-caProtEncCert" ++#define NID_id_it_caProtEncCert 298 ++#define OBJ_id_it_caProtEncCert OBJ_id_it,1L ++ ++#define SN_id_it_signKeyPairTypes "id-it-signKeyPairTypes" ++#define NID_id_it_signKeyPairTypes 299 ++#define OBJ_id_it_signKeyPairTypes OBJ_id_it,2L ++ ++#define SN_id_it_encKeyPairTypes "id-it-encKeyPairTypes" ++#define NID_id_it_encKeyPairTypes 300 ++#define OBJ_id_it_encKeyPairTypes OBJ_id_it,3L ++ ++#define SN_id_it_preferredSymmAlg "id-it-preferredSymmAlg" ++#define NID_id_it_preferredSymmAlg 301 ++#define OBJ_id_it_preferredSymmAlg OBJ_id_it,4L ++ ++#define SN_id_it_caKeyUpdateInfo "id-it-caKeyUpdateInfo" ++#define NID_id_it_caKeyUpdateInfo 302 ++#define OBJ_id_it_caKeyUpdateInfo OBJ_id_it,5L ++ ++#define SN_id_it_currentCRL "id-it-currentCRL" ++#define NID_id_it_currentCRL 303 ++#define OBJ_id_it_currentCRL OBJ_id_it,6L ++ ++#define SN_id_it_unsupportedOIDs "id-it-unsupportedOIDs" ++#define NID_id_it_unsupportedOIDs 304 ++#define OBJ_id_it_unsupportedOIDs OBJ_id_it,7L ++ ++#define SN_id_it_subscriptionRequest "id-it-subscriptionRequest" ++#define NID_id_it_subscriptionRequest 305 ++#define OBJ_id_it_subscriptionRequest OBJ_id_it,8L ++ ++#define SN_id_it_subscriptionResponse "id-it-subscriptionResponse" ++#define NID_id_it_subscriptionResponse 306 ++#define OBJ_id_it_subscriptionResponse OBJ_id_it,9L ++ ++#define SN_id_it_keyPairParamReq "id-it-keyPairParamReq" ++#define NID_id_it_keyPairParamReq 307 ++#define OBJ_id_it_keyPairParamReq OBJ_id_it,10L ++ ++#define SN_id_it_keyPairParamRep "id-it-keyPairParamRep" ++#define NID_id_it_keyPairParamRep 308 ++#define OBJ_id_it_keyPairParamRep OBJ_id_it,11L ++ ++#define SN_id_it_revPassphrase "id-it-revPassphrase" ++#define NID_id_it_revPassphrase 309 ++#define OBJ_id_it_revPassphrase OBJ_id_it,12L ++ ++#define SN_id_it_implicitConfirm "id-it-implicitConfirm" ++#define NID_id_it_implicitConfirm 310 ++#define OBJ_id_it_implicitConfirm OBJ_id_it,13L ++ ++#define SN_id_it_confirmWaitTime "id-it-confirmWaitTime" ++#define NID_id_it_confirmWaitTime 311 ++#define OBJ_id_it_confirmWaitTime OBJ_id_it,14L ++ ++#define SN_id_it_origPKIMessage "id-it-origPKIMessage" ++#define NID_id_it_origPKIMessage 312 ++#define OBJ_id_it_origPKIMessage OBJ_id_it,15L ++ ++#define SN_id_it_suppLangTags "id-it-suppLangTags" ++#define NID_id_it_suppLangTags 784 ++#define OBJ_id_it_suppLangTags OBJ_id_it,16L ++ ++#define SN_id_regCtrl "id-regCtrl" ++#define NID_id_regCtrl 313 ++#define OBJ_id_regCtrl OBJ_id_pkip,1L ++ ++#define SN_id_regInfo "id-regInfo" ++#define NID_id_regInfo 314 ++#define OBJ_id_regInfo OBJ_id_pkip,2L ++ ++#define SN_id_regCtrl_regToken "id-regCtrl-regToken" ++#define NID_id_regCtrl_regToken 315 ++#define OBJ_id_regCtrl_regToken OBJ_id_regCtrl,1L ++ ++#define SN_id_regCtrl_authenticator "id-regCtrl-authenticator" ++#define NID_id_regCtrl_authenticator 316 ++#define OBJ_id_regCtrl_authenticator OBJ_id_regCtrl,2L ++ ++#define SN_id_regCtrl_pkiPublicationInfo "id-regCtrl-pkiPublicationInfo" ++#define NID_id_regCtrl_pkiPublicationInfo 317 ++#define OBJ_id_regCtrl_pkiPublicationInfo OBJ_id_regCtrl,3L ++ ++#define SN_id_regCtrl_pkiArchiveOptions "id-regCtrl-pkiArchiveOptions" ++#define NID_id_regCtrl_pkiArchiveOptions 318 ++#define OBJ_id_regCtrl_pkiArchiveOptions OBJ_id_regCtrl,4L ++ ++#define SN_id_regCtrl_oldCertID "id-regCtrl-oldCertID" ++#define NID_id_regCtrl_oldCertID 319 ++#define OBJ_id_regCtrl_oldCertID OBJ_id_regCtrl,5L ++ ++#define SN_id_regCtrl_protocolEncrKey "id-regCtrl-protocolEncrKey" ++#define NID_id_regCtrl_protocolEncrKey 320 ++#define OBJ_id_regCtrl_protocolEncrKey OBJ_id_regCtrl,6L ++ ++#define SN_id_regInfo_utf8Pairs "id-regInfo-utf8Pairs" ++#define NID_id_regInfo_utf8Pairs 321 ++#define OBJ_id_regInfo_utf8Pairs OBJ_id_regInfo,1L ++ ++#define SN_id_regInfo_certReq "id-regInfo-certReq" ++#define NID_id_regInfo_certReq 322 ++#define OBJ_id_regInfo_certReq OBJ_id_regInfo,2L ++ ++#define SN_id_alg_des40 "id-alg-des40" ++#define NID_id_alg_des40 323 ++#define OBJ_id_alg_des40 OBJ_id_alg,1L ++ ++#define SN_id_alg_noSignature "id-alg-noSignature" ++#define NID_id_alg_noSignature 324 ++#define OBJ_id_alg_noSignature OBJ_id_alg,2L ++ ++#define SN_id_alg_dh_sig_hmac_sha1 "id-alg-dh-sig-hmac-sha1" ++#define NID_id_alg_dh_sig_hmac_sha1 325 ++#define OBJ_id_alg_dh_sig_hmac_sha1 OBJ_id_alg,3L ++ ++#define SN_id_alg_dh_pop "id-alg-dh-pop" ++#define NID_id_alg_dh_pop 326 ++#define OBJ_id_alg_dh_pop OBJ_id_alg,4L ++ ++#define SN_id_cmc_statusInfo "id-cmc-statusInfo" ++#define NID_id_cmc_statusInfo 327 ++#define OBJ_id_cmc_statusInfo OBJ_id_cmc,1L ++ ++#define SN_id_cmc_identification "id-cmc-identification" ++#define NID_id_cmc_identification 328 ++#define OBJ_id_cmc_identification OBJ_id_cmc,2L ++ ++#define SN_id_cmc_identityProof "id-cmc-identityProof" ++#define NID_id_cmc_identityProof 329 ++#define OBJ_id_cmc_identityProof OBJ_id_cmc,3L ++ ++#define SN_id_cmc_dataReturn "id-cmc-dataReturn" ++#define NID_id_cmc_dataReturn 330 ++#define OBJ_id_cmc_dataReturn OBJ_id_cmc,4L ++ ++#define SN_id_cmc_transactionId "id-cmc-transactionId" ++#define NID_id_cmc_transactionId 331 ++#define OBJ_id_cmc_transactionId OBJ_id_cmc,5L ++ ++#define SN_id_cmc_senderNonce "id-cmc-senderNonce" ++#define NID_id_cmc_senderNonce 332 ++#define OBJ_id_cmc_senderNonce OBJ_id_cmc,6L ++ ++#define SN_id_cmc_recipientNonce "id-cmc-recipientNonce" ++#define NID_id_cmc_recipientNonce 333 ++#define OBJ_id_cmc_recipientNonce OBJ_id_cmc,7L ++ ++#define SN_id_cmc_addExtensions "id-cmc-addExtensions" ++#define NID_id_cmc_addExtensions 334 ++#define OBJ_id_cmc_addExtensions OBJ_id_cmc,8L ++ ++#define SN_id_cmc_encryptedPOP "id-cmc-encryptedPOP" ++#define NID_id_cmc_encryptedPOP 335 ++#define OBJ_id_cmc_encryptedPOP OBJ_id_cmc,9L ++ ++#define SN_id_cmc_decryptedPOP "id-cmc-decryptedPOP" ++#define NID_id_cmc_decryptedPOP 336 ++#define OBJ_id_cmc_decryptedPOP OBJ_id_cmc,10L ++ ++#define SN_id_cmc_lraPOPWitness "id-cmc-lraPOPWitness" ++#define NID_id_cmc_lraPOPWitness 337 ++#define OBJ_id_cmc_lraPOPWitness OBJ_id_cmc,11L ++ ++#define SN_id_cmc_getCert "id-cmc-getCert" ++#define NID_id_cmc_getCert 338 ++#define OBJ_id_cmc_getCert OBJ_id_cmc,15L ++ ++#define SN_id_cmc_getCRL "id-cmc-getCRL" ++#define NID_id_cmc_getCRL 339 ++#define OBJ_id_cmc_getCRL OBJ_id_cmc,16L ++ ++#define SN_id_cmc_revokeRequest "id-cmc-revokeRequest" ++#define NID_id_cmc_revokeRequest 340 ++#define OBJ_id_cmc_revokeRequest OBJ_id_cmc,17L ++ ++#define SN_id_cmc_regInfo "id-cmc-regInfo" ++#define NID_id_cmc_regInfo 341 ++#define OBJ_id_cmc_regInfo OBJ_id_cmc,18L ++ ++#define SN_id_cmc_responseInfo "id-cmc-responseInfo" ++#define NID_id_cmc_responseInfo 342 ++#define OBJ_id_cmc_responseInfo OBJ_id_cmc,19L ++ ++#define SN_id_cmc_queryPending "id-cmc-queryPending" ++#define NID_id_cmc_queryPending 343 ++#define OBJ_id_cmc_queryPending OBJ_id_cmc,21L ++ ++#define SN_id_cmc_popLinkRandom "id-cmc-popLinkRandom" ++#define NID_id_cmc_popLinkRandom 344 ++#define OBJ_id_cmc_popLinkRandom OBJ_id_cmc,22L ++ ++#define SN_id_cmc_popLinkWitness "id-cmc-popLinkWitness" ++#define NID_id_cmc_popLinkWitness 345 ++#define OBJ_id_cmc_popLinkWitness OBJ_id_cmc,23L ++ ++#define SN_id_cmc_confirmCertAcceptance "id-cmc-confirmCertAcceptance" ++#define NID_id_cmc_confirmCertAcceptance 346 ++#define OBJ_id_cmc_confirmCertAcceptance OBJ_id_cmc,24L ++ ++#define SN_id_on_personalData "id-on-personalData" ++#define NID_id_on_personalData 347 ++#define OBJ_id_on_personalData OBJ_id_on,1L ++ ++#define SN_id_on_permanentIdentifier "id-on-permanentIdentifier" ++#define LN_id_on_permanentIdentifier "Permanent Identifier" ++#define NID_id_on_permanentIdentifier 858 ++#define OBJ_id_on_permanentIdentifier OBJ_id_on,3L ++ ++#define SN_id_pda_dateOfBirth "id-pda-dateOfBirth" ++#define NID_id_pda_dateOfBirth 348 ++#define OBJ_id_pda_dateOfBirth OBJ_id_pda,1L ++ ++#define SN_id_pda_placeOfBirth "id-pda-placeOfBirth" ++#define NID_id_pda_placeOfBirth 349 ++#define OBJ_id_pda_placeOfBirth OBJ_id_pda,2L ++ ++#define SN_id_pda_gender "id-pda-gender" ++#define NID_id_pda_gender 351 ++#define OBJ_id_pda_gender OBJ_id_pda,3L ++ ++#define SN_id_pda_countryOfCitizenship "id-pda-countryOfCitizenship" ++#define NID_id_pda_countryOfCitizenship 352 ++#define OBJ_id_pda_countryOfCitizenship OBJ_id_pda,4L ++ ++#define SN_id_pda_countryOfResidence "id-pda-countryOfResidence" ++#define NID_id_pda_countryOfResidence 353 ++#define OBJ_id_pda_countryOfResidence OBJ_id_pda,5L ++ ++#define SN_id_aca_authenticationInfo "id-aca-authenticationInfo" ++#define NID_id_aca_authenticationInfo 354 ++#define OBJ_id_aca_authenticationInfo OBJ_id_aca,1L ++ ++#define SN_id_aca_accessIdentity "id-aca-accessIdentity" ++#define NID_id_aca_accessIdentity 355 ++#define OBJ_id_aca_accessIdentity OBJ_id_aca,2L ++ ++#define SN_id_aca_chargingIdentity "id-aca-chargingIdentity" ++#define NID_id_aca_chargingIdentity 356 ++#define OBJ_id_aca_chargingIdentity OBJ_id_aca,3L ++ ++#define SN_id_aca_group "id-aca-group" ++#define NID_id_aca_group 357 ++#define OBJ_id_aca_group OBJ_id_aca,4L ++ ++#define SN_id_aca_role "id-aca-role" ++#define NID_id_aca_role 358 ++#define OBJ_id_aca_role OBJ_id_aca,5L ++ ++#define SN_id_aca_encAttrs "id-aca-encAttrs" ++#define NID_id_aca_encAttrs 399 ++#define OBJ_id_aca_encAttrs OBJ_id_aca,6L ++ ++#define SN_id_qcs_pkixQCSyntax_v1 "id-qcs-pkixQCSyntax-v1" ++#define NID_id_qcs_pkixQCSyntax_v1 359 ++#define OBJ_id_qcs_pkixQCSyntax_v1 OBJ_id_qcs,1L ++ ++#define SN_id_cct_crs "id-cct-crs" ++#define NID_id_cct_crs 360 ++#define OBJ_id_cct_crs OBJ_id_cct,1L ++ ++#define SN_id_cct_PKIData "id-cct-PKIData" ++#define NID_id_cct_PKIData 361 ++#define OBJ_id_cct_PKIData OBJ_id_cct,2L ++ ++#define SN_id_cct_PKIResponse "id-cct-PKIResponse" ++#define NID_id_cct_PKIResponse 362 ++#define OBJ_id_cct_PKIResponse OBJ_id_cct,3L ++ ++#define SN_id_ppl_anyLanguage "id-ppl-anyLanguage" ++#define LN_id_ppl_anyLanguage "Any language" ++#define NID_id_ppl_anyLanguage 664 ++#define OBJ_id_ppl_anyLanguage OBJ_id_ppl,0L ++ ++#define SN_id_ppl_inheritAll "id-ppl-inheritAll" ++#define LN_id_ppl_inheritAll "Inherit all" ++#define NID_id_ppl_inheritAll 665 ++#define OBJ_id_ppl_inheritAll OBJ_id_ppl,1L ++ ++#define SN_Independent "id-ppl-independent" ++#define LN_Independent "Independent" ++#define NID_Independent 667 ++#define OBJ_Independent OBJ_id_ppl,2L ++ ++#define SN_ad_OCSP "OCSP" ++#define LN_ad_OCSP "OCSP" ++#define NID_ad_OCSP 178 ++#define OBJ_ad_OCSP OBJ_id_ad,1L ++ ++#define SN_ad_ca_issuers "caIssuers" ++#define LN_ad_ca_issuers "CA Issuers" ++#define NID_ad_ca_issuers 179 ++#define OBJ_ad_ca_issuers OBJ_id_ad,2L ++ ++#define SN_ad_timeStamping "ad_timestamping" ++#define LN_ad_timeStamping "AD Time Stamping" ++#define NID_ad_timeStamping 363 ++#define OBJ_ad_timeStamping OBJ_id_ad,3L ++ ++#define SN_ad_dvcs "AD_DVCS" ++#define LN_ad_dvcs "ad dvcs" ++#define NID_ad_dvcs 364 ++#define OBJ_ad_dvcs OBJ_id_ad,4L ++ ++#define SN_caRepository "caRepository" ++#define LN_caRepository "CA Repository" ++#define NID_caRepository 785 ++#define OBJ_caRepository OBJ_id_ad,5L ++ ++#define OBJ_id_pkix_OCSP OBJ_ad_OCSP ++ ++#define SN_id_pkix_OCSP_basic "basicOCSPResponse" ++#define LN_id_pkix_OCSP_basic "Basic OCSP Response" ++#define NID_id_pkix_OCSP_basic 365 ++#define OBJ_id_pkix_OCSP_basic OBJ_id_pkix_OCSP,1L ++ ++#define SN_id_pkix_OCSP_Nonce "Nonce" ++#define LN_id_pkix_OCSP_Nonce "OCSP Nonce" ++#define NID_id_pkix_OCSP_Nonce 366 ++#define OBJ_id_pkix_OCSP_Nonce OBJ_id_pkix_OCSP,2L ++ ++#define SN_id_pkix_OCSP_CrlID "CrlID" ++#define LN_id_pkix_OCSP_CrlID "OCSP CRL ID" ++#define NID_id_pkix_OCSP_CrlID 367 ++#define OBJ_id_pkix_OCSP_CrlID OBJ_id_pkix_OCSP,3L ++ ++#define SN_id_pkix_OCSP_acceptableResponses "acceptableResponses" ++#define LN_id_pkix_OCSP_acceptableResponses "Acceptable OCSP Responses" ++#define NID_id_pkix_OCSP_acceptableResponses 368 ++#define OBJ_id_pkix_OCSP_acceptableResponses OBJ_id_pkix_OCSP,4L ++ ++#define SN_id_pkix_OCSP_noCheck "noCheck" ++#define LN_id_pkix_OCSP_noCheck "OCSP No Check" ++#define NID_id_pkix_OCSP_noCheck 369 ++#define OBJ_id_pkix_OCSP_noCheck OBJ_id_pkix_OCSP,5L ++ ++#define SN_id_pkix_OCSP_archiveCutoff "archiveCutoff" ++#define LN_id_pkix_OCSP_archiveCutoff "OCSP Archive Cutoff" ++#define NID_id_pkix_OCSP_archiveCutoff 370 ++#define OBJ_id_pkix_OCSP_archiveCutoff OBJ_id_pkix_OCSP,6L ++ ++#define SN_id_pkix_OCSP_serviceLocator "serviceLocator" ++#define LN_id_pkix_OCSP_serviceLocator "OCSP Service Locator" ++#define NID_id_pkix_OCSP_serviceLocator 371 ++#define OBJ_id_pkix_OCSP_serviceLocator OBJ_id_pkix_OCSP,7L ++ ++#define SN_id_pkix_OCSP_extendedStatus "extendedStatus" ++#define LN_id_pkix_OCSP_extendedStatus "Extended OCSP Status" ++#define NID_id_pkix_OCSP_extendedStatus 372 ++#define OBJ_id_pkix_OCSP_extendedStatus OBJ_id_pkix_OCSP,8L ++ ++#define SN_id_pkix_OCSP_valid "valid" ++#define NID_id_pkix_OCSP_valid 373 ++#define OBJ_id_pkix_OCSP_valid OBJ_id_pkix_OCSP,9L ++ ++#define SN_id_pkix_OCSP_path "path" ++#define NID_id_pkix_OCSP_path 374 ++#define OBJ_id_pkix_OCSP_path OBJ_id_pkix_OCSP,10L ++ ++#define SN_id_pkix_OCSP_trustRoot "trustRoot" ++#define LN_id_pkix_OCSP_trustRoot "Trust Root" ++#define NID_id_pkix_OCSP_trustRoot 375 ++#define OBJ_id_pkix_OCSP_trustRoot OBJ_id_pkix_OCSP,11L ++ ++#define SN_algorithm "algorithm" ++#define LN_algorithm "algorithm" ++#define NID_algorithm 376 ++#define OBJ_algorithm 1L,3L,14L,3L,2L ++ ++#define SN_md5WithRSA "RSA-NP-MD5" ++#define LN_md5WithRSA "md5WithRSA" ++#define NID_md5WithRSA 104 ++#define OBJ_md5WithRSA OBJ_algorithm,3L ++ ++#define SN_des_ecb "DES-ECB" ++#define LN_des_ecb "des-ecb" ++#define NID_des_ecb 29 ++#define OBJ_des_ecb OBJ_algorithm,6L ++ ++#define SN_des_cbc "DES-CBC" ++#define LN_des_cbc "des-cbc" ++#define NID_des_cbc 31 ++#define OBJ_des_cbc OBJ_algorithm,7L ++ ++#define SN_des_ofb64 "DES-OFB" ++#define LN_des_ofb64 "des-ofb" ++#define NID_des_ofb64 45 ++#define OBJ_des_ofb64 OBJ_algorithm,8L ++ ++#define SN_des_cfb64 "DES-CFB" ++#define LN_des_cfb64 "des-cfb" ++#define NID_des_cfb64 30 ++#define OBJ_des_cfb64 OBJ_algorithm,9L ++ ++#define SN_rsaSignature "rsaSignature" ++#define NID_rsaSignature 377 ++#define OBJ_rsaSignature OBJ_algorithm,11L ++ ++#define SN_dsa_2 "DSA-old" ++#define LN_dsa_2 "dsaEncryption-old" ++#define NID_dsa_2 67 ++#define OBJ_dsa_2 OBJ_algorithm,12L ++ ++#define SN_dsaWithSHA "DSA-SHA" ++#define LN_dsaWithSHA "dsaWithSHA" ++#define NID_dsaWithSHA 66 ++#define OBJ_dsaWithSHA OBJ_algorithm,13L ++ ++#define SN_shaWithRSAEncryption "RSA-SHA" ++#define LN_shaWithRSAEncryption "shaWithRSAEncryption" ++#define NID_shaWithRSAEncryption 42 ++#define OBJ_shaWithRSAEncryption OBJ_algorithm,15L ++ ++#define SN_des_ede_ecb "DES-EDE" ++#define LN_des_ede_ecb "des-ede" ++#define NID_des_ede_ecb 32 ++#define OBJ_des_ede_ecb OBJ_algorithm,17L ++ ++#define SN_des_ede3_ecb "DES-EDE3" ++#define LN_des_ede3_ecb "des-ede3" ++#define NID_des_ede3_ecb 33 ++ ++#define SN_des_ede_cbc "DES-EDE-CBC" ++#define LN_des_ede_cbc "des-ede-cbc" ++#define NID_des_ede_cbc 43 ++ ++#define SN_des_ede_cfb64 "DES-EDE-CFB" ++#define LN_des_ede_cfb64 "des-ede-cfb" ++#define NID_des_ede_cfb64 60 ++ ++#define SN_des_ede3_cfb64 "DES-EDE3-CFB" ++#define LN_des_ede3_cfb64 "des-ede3-cfb" ++#define NID_des_ede3_cfb64 61 ++ ++#define SN_des_ede_ofb64 "DES-EDE-OFB" ++#define LN_des_ede_ofb64 "des-ede-ofb" ++#define NID_des_ede_ofb64 62 ++ ++#define SN_des_ede3_ofb64 "DES-EDE3-OFB" ++#define LN_des_ede3_ofb64 "des-ede3-ofb" ++#define NID_des_ede3_ofb64 63 ++ ++#define SN_desx_cbc "DESX-CBC" ++#define LN_desx_cbc "desx-cbc" ++#define NID_desx_cbc 80 ++ ++#define SN_sha "SHA" ++#define LN_sha "sha" ++#define NID_sha 41 ++#define OBJ_sha OBJ_algorithm,18L ++ ++#define SN_sha1 "SHA1" ++#define LN_sha1 "sha1" ++#define NID_sha1 64 ++#define OBJ_sha1 OBJ_algorithm,26L ++ ++#define SN_dsaWithSHA1_2 "DSA-SHA1-old" ++#define LN_dsaWithSHA1_2 "dsaWithSHA1-old" ++#define NID_dsaWithSHA1_2 70 ++#define OBJ_dsaWithSHA1_2 OBJ_algorithm,27L ++ ++#define SN_sha1WithRSA "RSA-SHA1-2" ++#define LN_sha1WithRSA "sha1WithRSA" ++#define NID_sha1WithRSA 115 ++#define OBJ_sha1WithRSA OBJ_algorithm,29L ++ ++#define SN_ripemd160 "RIPEMD160" ++#define LN_ripemd160 "ripemd160" ++#define NID_ripemd160 117 ++#define OBJ_ripemd160 1L,3L,36L,3L,2L,1L ++ ++#define SN_ripemd160WithRSA "RSA-RIPEMD160" ++#define LN_ripemd160WithRSA "ripemd160WithRSA" ++#define NID_ripemd160WithRSA 119 ++#define OBJ_ripemd160WithRSA 1L,3L,36L,3L,3L,1L,2L ++ ++#define SN_sxnet "SXNetID" ++#define LN_sxnet "Strong Extranet ID" ++#define NID_sxnet 143 ++#define OBJ_sxnet 1L,3L,101L,1L,4L,1L ++ ++#define SN_X500 "X500" ++#define LN_X500 "directory services (X.500)" ++#define NID_X500 11 ++#define OBJ_X500 2L,5L ++ ++#define SN_X509 "X509" ++#define NID_X509 12 ++#define OBJ_X509 OBJ_X500,4L ++ ++#define SN_commonName "CN" ++#define LN_commonName "commonName" ++#define NID_commonName 13 ++#define OBJ_commonName OBJ_X509,3L ++ ++#define SN_surname "SN" ++#define LN_surname "surname" ++#define NID_surname 100 ++#define OBJ_surname OBJ_X509,4L ++ ++#define LN_serialNumber "serialNumber" ++#define NID_serialNumber 105 ++#define OBJ_serialNumber OBJ_X509,5L ++ ++#define SN_countryName "C" ++#define LN_countryName "countryName" ++#define NID_countryName 14 ++#define OBJ_countryName OBJ_X509,6L ++ ++#define SN_localityName "L" ++#define LN_localityName "localityName" ++#define NID_localityName 15 ++#define OBJ_localityName OBJ_X509,7L ++ ++#define SN_stateOrProvinceName "ST" ++#define LN_stateOrProvinceName "stateOrProvinceName" ++#define NID_stateOrProvinceName 16 ++#define OBJ_stateOrProvinceName OBJ_X509,8L ++ ++#define SN_streetAddress "street" ++#define LN_streetAddress "streetAddress" ++#define NID_streetAddress 660 ++#define OBJ_streetAddress OBJ_X509,9L ++ ++#define SN_organizationName "O" ++#define LN_organizationName "organizationName" ++#define NID_organizationName 17 ++#define OBJ_organizationName OBJ_X509,10L ++ ++#define SN_organizationalUnitName "OU" ++#define LN_organizationalUnitName "organizationalUnitName" ++#define NID_organizationalUnitName 18 ++#define OBJ_organizationalUnitName OBJ_X509,11L ++ ++#define SN_title "title" ++#define LN_title "title" ++#define NID_title 106 ++#define OBJ_title OBJ_X509,12L ++ ++#define LN_description "description" ++#define NID_description 107 ++#define OBJ_description OBJ_X509,13L ++ ++#define LN_searchGuide "searchGuide" ++#define NID_searchGuide 859 ++#define OBJ_searchGuide OBJ_X509,14L ++ ++#define LN_businessCategory "businessCategory" ++#define NID_businessCategory 860 ++#define OBJ_businessCategory OBJ_X509,15L ++ ++#define LN_postalAddress "postalAddress" ++#define NID_postalAddress 861 ++#define OBJ_postalAddress OBJ_X509,16L ++ ++#define LN_postalCode "postalCode" ++#define NID_postalCode 661 ++#define OBJ_postalCode OBJ_X509,17L ++ ++#define LN_postOfficeBox "postOfficeBox" ++#define NID_postOfficeBox 862 ++#define OBJ_postOfficeBox OBJ_X509,18L ++ ++#define LN_physicalDeliveryOfficeName "physicalDeliveryOfficeName" ++#define NID_physicalDeliveryOfficeName 863 ++#define OBJ_physicalDeliveryOfficeName OBJ_X509,19L ++ ++#define LN_telephoneNumber "telephoneNumber" ++#define NID_telephoneNumber 864 ++#define OBJ_telephoneNumber OBJ_X509,20L ++ ++#define LN_telexNumber "telexNumber" ++#define NID_telexNumber 865 ++#define OBJ_telexNumber OBJ_X509,21L ++ ++#define LN_teletexTerminalIdentifier "teletexTerminalIdentifier" ++#define NID_teletexTerminalIdentifier 866 ++#define OBJ_teletexTerminalIdentifier OBJ_X509,22L ++ ++#define LN_facsimileTelephoneNumber "facsimileTelephoneNumber" ++#define NID_facsimileTelephoneNumber 867 ++#define OBJ_facsimileTelephoneNumber OBJ_X509,23L ++ ++#define LN_x121Address "x121Address" ++#define NID_x121Address 868 ++#define OBJ_x121Address OBJ_X509,24L ++ ++#define LN_internationaliSDNNumber "internationaliSDNNumber" ++#define NID_internationaliSDNNumber 869 ++#define OBJ_internationaliSDNNumber OBJ_X509,25L ++ ++#define LN_registeredAddress "registeredAddress" ++#define NID_registeredAddress 870 ++#define OBJ_registeredAddress OBJ_X509,26L ++ ++#define LN_destinationIndicator "destinationIndicator" ++#define NID_destinationIndicator 871 ++#define OBJ_destinationIndicator OBJ_X509,27L ++ ++#define LN_preferredDeliveryMethod "preferredDeliveryMethod" ++#define NID_preferredDeliveryMethod 872 ++#define OBJ_preferredDeliveryMethod OBJ_X509,28L ++ ++#define LN_presentationAddress "presentationAddress" ++#define NID_presentationAddress 873 ++#define OBJ_presentationAddress OBJ_X509,29L ++ ++#define LN_supportedApplicationContext "supportedApplicationContext" ++#define NID_supportedApplicationContext 874 ++#define OBJ_supportedApplicationContext OBJ_X509,30L ++ ++#define SN_member "member" ++#define NID_member 875 ++#define OBJ_member OBJ_X509,31L ++ ++#define SN_owner "owner" ++#define NID_owner 876 ++#define OBJ_owner OBJ_X509,32L ++ ++#define LN_roleOccupant "roleOccupant" ++#define NID_roleOccupant 877 ++#define OBJ_roleOccupant OBJ_X509,33L ++ ++#define SN_seeAlso "seeAlso" ++#define NID_seeAlso 878 ++#define OBJ_seeAlso OBJ_X509,34L ++ ++#define LN_userPassword "userPassword" ++#define NID_userPassword 879 ++#define OBJ_userPassword OBJ_X509,35L ++ ++#define LN_userCertificate "userCertificate" ++#define NID_userCertificate 880 ++#define OBJ_userCertificate OBJ_X509,36L ++ ++#define LN_cACertificate "cACertificate" ++#define NID_cACertificate 881 ++#define OBJ_cACertificate OBJ_X509,37L ++ ++#define LN_authorityRevocationList "authorityRevocationList" ++#define NID_authorityRevocationList 882 ++#define OBJ_authorityRevocationList OBJ_X509,38L ++ ++#define LN_certificateRevocationList "certificateRevocationList" ++#define NID_certificateRevocationList 883 ++#define OBJ_certificateRevocationList OBJ_X509,39L ++ ++#define LN_crossCertificatePair "crossCertificatePair" ++#define NID_crossCertificatePair 884 ++#define OBJ_crossCertificatePair OBJ_X509,40L ++ ++#define SN_name "name" ++#define LN_name "name" ++#define NID_name 173 ++#define OBJ_name OBJ_X509,41L ++ ++#define SN_givenName "GN" ++#define LN_givenName "givenName" ++#define NID_givenName 99 ++#define OBJ_givenName OBJ_X509,42L ++ ++#define SN_initials "initials" ++#define LN_initials "initials" ++#define NID_initials 101 ++#define OBJ_initials OBJ_X509,43L ++ ++#define LN_generationQualifier "generationQualifier" ++#define NID_generationQualifier 509 ++#define OBJ_generationQualifier OBJ_X509,44L ++ ++#define LN_x500UniqueIdentifier "x500UniqueIdentifier" ++#define NID_x500UniqueIdentifier 503 ++#define OBJ_x500UniqueIdentifier OBJ_X509,45L ++ ++#define SN_dnQualifier "dnQualifier" ++#define LN_dnQualifier "dnQualifier" ++#define NID_dnQualifier 174 ++#define OBJ_dnQualifier OBJ_X509,46L ++ ++#define LN_enhancedSearchGuide "enhancedSearchGuide" ++#define NID_enhancedSearchGuide 885 ++#define OBJ_enhancedSearchGuide OBJ_X509,47L ++ ++#define LN_protocolInformation "protocolInformation" ++#define NID_protocolInformation 886 ++#define OBJ_protocolInformation OBJ_X509,48L ++ ++#define LN_distinguishedName "distinguishedName" ++#define NID_distinguishedName 887 ++#define OBJ_distinguishedName OBJ_X509,49L ++ ++#define LN_uniqueMember "uniqueMember" ++#define NID_uniqueMember 888 ++#define OBJ_uniqueMember OBJ_X509,50L ++ ++#define LN_houseIdentifier "houseIdentifier" ++#define NID_houseIdentifier 889 ++#define OBJ_houseIdentifier OBJ_X509,51L ++ ++#define LN_supportedAlgorithms "supportedAlgorithms" ++#define NID_supportedAlgorithms 890 ++#define OBJ_supportedAlgorithms OBJ_X509,52L ++ ++#define LN_deltaRevocationList "deltaRevocationList" ++#define NID_deltaRevocationList 891 ++#define OBJ_deltaRevocationList OBJ_X509,53L ++ ++#define SN_dmdName "dmdName" ++#define NID_dmdName 892 ++#define OBJ_dmdName OBJ_X509,54L ++ ++#define LN_pseudonym "pseudonym" ++#define NID_pseudonym 510 ++#define OBJ_pseudonym OBJ_X509,65L ++ ++#define SN_role "role" ++#define LN_role "role" ++#define NID_role 400 ++#define OBJ_role OBJ_X509,72L ++ ++#define SN_X500algorithms "X500algorithms" ++#define LN_X500algorithms "directory services - algorithms" ++#define NID_X500algorithms 378 ++#define OBJ_X500algorithms OBJ_X500,8L ++ ++#define SN_rsa "RSA" ++#define LN_rsa "rsa" ++#define NID_rsa 19 ++#define OBJ_rsa OBJ_X500algorithms,1L,1L ++ ++#define SN_mdc2WithRSA "RSA-MDC2" ++#define LN_mdc2WithRSA "mdc2WithRSA" ++#define NID_mdc2WithRSA 96 ++#define OBJ_mdc2WithRSA OBJ_X500algorithms,3L,100L ++ ++#define SN_mdc2 "MDC2" ++#define LN_mdc2 "mdc2" ++#define NID_mdc2 95 ++#define OBJ_mdc2 OBJ_X500algorithms,3L,101L ++ ++#define SN_id_ce "id-ce" ++#define NID_id_ce 81 ++#define OBJ_id_ce OBJ_X500,29L ++ ++#define SN_subject_directory_attributes "subjectDirectoryAttributes" ++#define LN_subject_directory_attributes "X509v3 Subject Directory Attributes" ++#define NID_subject_directory_attributes 769 ++#define OBJ_subject_directory_attributes OBJ_id_ce,9L ++ ++#define SN_subject_key_identifier "subjectKeyIdentifier" ++#define LN_subject_key_identifier "X509v3 Subject Key Identifier" ++#define NID_subject_key_identifier 82 ++#define OBJ_subject_key_identifier OBJ_id_ce,14L ++ ++#define SN_key_usage "keyUsage" ++#define LN_key_usage "X509v3 Key Usage" ++#define NID_key_usage 83 ++#define OBJ_key_usage OBJ_id_ce,15L ++ ++#define SN_private_key_usage_period "privateKeyUsagePeriod" ++#define LN_private_key_usage_period "X509v3 Private Key Usage Period" ++#define NID_private_key_usage_period 84 ++#define OBJ_private_key_usage_period OBJ_id_ce,16L ++ ++#define SN_subject_alt_name "subjectAltName" ++#define LN_subject_alt_name "X509v3 Subject Alternative Name" ++#define NID_subject_alt_name 85 ++#define OBJ_subject_alt_name OBJ_id_ce,17L ++ ++#define SN_issuer_alt_name "issuerAltName" ++#define LN_issuer_alt_name "X509v3 Issuer Alternative Name" ++#define NID_issuer_alt_name 86 ++#define OBJ_issuer_alt_name OBJ_id_ce,18L ++ ++#define SN_basic_constraints "basicConstraints" ++#define LN_basic_constraints "X509v3 Basic Constraints" ++#define NID_basic_constraints 87 ++#define OBJ_basic_constraints OBJ_id_ce,19L ++ ++#define SN_crl_number "crlNumber" ++#define LN_crl_number "X509v3 CRL Number" ++#define NID_crl_number 88 ++#define OBJ_crl_number OBJ_id_ce,20L ++ ++#define SN_crl_reason "CRLReason" ++#define LN_crl_reason "X509v3 CRL Reason Code" ++#define NID_crl_reason 141 ++#define OBJ_crl_reason OBJ_id_ce,21L ++ ++#define SN_invalidity_date "invalidityDate" ++#define LN_invalidity_date "Invalidity Date" ++#define NID_invalidity_date 142 ++#define OBJ_invalidity_date OBJ_id_ce,24L ++ ++#define SN_delta_crl "deltaCRL" ++#define LN_delta_crl "X509v3 Delta CRL Indicator" ++#define NID_delta_crl 140 ++#define OBJ_delta_crl OBJ_id_ce,27L ++ ++#define SN_issuing_distribution_point "issuingDistributionPoint" ++#define LN_issuing_distribution_point "X509v3 Issuing Distrubution Point" ++#define NID_issuing_distribution_point 770 ++#define OBJ_issuing_distribution_point OBJ_id_ce,28L ++ ++#define SN_certificate_issuer "certificateIssuer" ++#define LN_certificate_issuer "X509v3 Certificate Issuer" ++#define NID_certificate_issuer 771 ++#define OBJ_certificate_issuer OBJ_id_ce,29L ++ ++#define SN_name_constraints "nameConstraints" ++#define LN_name_constraints "X509v3 Name Constraints" ++#define NID_name_constraints 666 ++#define OBJ_name_constraints OBJ_id_ce,30L ++ ++#define SN_crl_distribution_points "crlDistributionPoints" ++#define LN_crl_distribution_points "X509v3 CRL Distribution Points" ++#define NID_crl_distribution_points 103 ++#define OBJ_crl_distribution_points OBJ_id_ce,31L ++ ++#define SN_certificate_policies "certificatePolicies" ++#define LN_certificate_policies "X509v3 Certificate Policies" ++#define NID_certificate_policies 89 ++#define OBJ_certificate_policies OBJ_id_ce,32L ++ ++#define SN_any_policy "anyPolicy" ++#define LN_any_policy "X509v3 Any Policy" ++#define NID_any_policy 746 ++#define OBJ_any_policy OBJ_certificate_policies,0L ++ ++#define SN_policy_mappings "policyMappings" ++#define LN_policy_mappings "X509v3 Policy Mappings" ++#define NID_policy_mappings 747 ++#define OBJ_policy_mappings OBJ_id_ce,33L ++ ++#define SN_authority_key_identifier "authorityKeyIdentifier" ++#define LN_authority_key_identifier "X509v3 Authority Key Identifier" ++#define NID_authority_key_identifier 90 ++#define OBJ_authority_key_identifier OBJ_id_ce,35L ++ ++#define SN_policy_constraints "policyConstraints" ++#define LN_policy_constraints "X509v3 Policy Constraints" ++#define NID_policy_constraints 401 ++#define OBJ_policy_constraints OBJ_id_ce,36L ++ ++#define SN_ext_key_usage "extendedKeyUsage" ++#define LN_ext_key_usage "X509v3 Extended Key Usage" ++#define NID_ext_key_usage 126 ++#define OBJ_ext_key_usage OBJ_id_ce,37L ++ ++#define SN_freshest_crl "freshestCRL" ++#define LN_freshest_crl "X509v3 Freshest CRL" ++#define NID_freshest_crl 857 ++#define OBJ_freshest_crl OBJ_id_ce,46L ++ ++#define SN_inhibit_any_policy "inhibitAnyPolicy" ++#define LN_inhibit_any_policy "X509v3 Inhibit Any Policy" ++#define NID_inhibit_any_policy 748 ++#define OBJ_inhibit_any_policy OBJ_id_ce,54L ++ ++#define SN_target_information "targetInformation" ++#define LN_target_information "X509v3 AC Targeting" ++#define NID_target_information 402 ++#define OBJ_target_information OBJ_id_ce,55L ++ ++#define SN_no_rev_avail "noRevAvail" ++#define LN_no_rev_avail "X509v3 No Revocation Available" ++#define NID_no_rev_avail 403 ++#define OBJ_no_rev_avail OBJ_id_ce,56L ++ ++#define SN_netscape "Netscape" ++#define LN_netscape "Netscape Communications Corp." ++#define NID_netscape 57 ++#define OBJ_netscape 2L,16L,840L,1L,113730L ++ ++#define SN_netscape_cert_extension "nsCertExt" ++#define LN_netscape_cert_extension "Netscape Certificate Extension" ++#define NID_netscape_cert_extension 58 ++#define OBJ_netscape_cert_extension OBJ_netscape,1L ++ ++#define SN_netscape_data_type "nsDataType" ++#define LN_netscape_data_type "Netscape Data Type" ++#define NID_netscape_data_type 59 ++#define OBJ_netscape_data_type OBJ_netscape,2L ++ ++#define SN_netscape_cert_type "nsCertType" ++#define LN_netscape_cert_type "Netscape Cert Type" ++#define NID_netscape_cert_type 71 ++#define OBJ_netscape_cert_type OBJ_netscape_cert_extension,1L ++ ++#define SN_netscape_base_url "nsBaseUrl" ++#define LN_netscape_base_url "Netscape Base Url" ++#define NID_netscape_base_url 72 ++#define OBJ_netscape_base_url OBJ_netscape_cert_extension,2L ++ ++#define SN_netscape_revocation_url "nsRevocationUrl" ++#define LN_netscape_revocation_url "Netscape Revocation Url" ++#define NID_netscape_revocation_url 73 ++#define OBJ_netscape_revocation_url OBJ_netscape_cert_extension,3L ++ ++#define SN_netscape_ca_revocation_url "nsCaRevocationUrl" ++#define LN_netscape_ca_revocation_url "Netscape CA Revocation Url" ++#define NID_netscape_ca_revocation_url 74 ++#define OBJ_netscape_ca_revocation_url OBJ_netscape_cert_extension,4L ++ ++#define SN_netscape_renewal_url "nsRenewalUrl" ++#define LN_netscape_renewal_url "Netscape Renewal Url" ++#define NID_netscape_renewal_url 75 ++#define OBJ_netscape_renewal_url OBJ_netscape_cert_extension,7L ++ ++#define SN_netscape_ca_policy_url "nsCaPolicyUrl" ++#define LN_netscape_ca_policy_url "Netscape CA Policy Url" ++#define NID_netscape_ca_policy_url 76 ++#define OBJ_netscape_ca_policy_url OBJ_netscape_cert_extension,8L ++ ++#define SN_netscape_ssl_server_name "nsSslServerName" ++#define LN_netscape_ssl_server_name "Netscape SSL Server Name" ++#define NID_netscape_ssl_server_name 77 ++#define OBJ_netscape_ssl_server_name OBJ_netscape_cert_extension,12L ++ ++#define SN_netscape_comment "nsComment" ++#define LN_netscape_comment "Netscape Comment" ++#define NID_netscape_comment 78 ++#define OBJ_netscape_comment OBJ_netscape_cert_extension,13L ++ ++#define SN_netscape_cert_sequence "nsCertSequence" ++#define LN_netscape_cert_sequence "Netscape Certificate Sequence" ++#define NID_netscape_cert_sequence 79 ++#define OBJ_netscape_cert_sequence OBJ_netscape_data_type,5L ++ ++#define SN_ns_sgc "nsSGC" ++#define LN_ns_sgc "Netscape Server Gated Crypto" ++#define NID_ns_sgc 139 ++#define OBJ_ns_sgc OBJ_netscape,4L,1L ++ ++#define SN_org "ORG" ++#define LN_org "org" ++#define NID_org 379 ++#define OBJ_org OBJ_iso,3L ++ ++#define SN_dod "DOD" ++#define LN_dod "dod" ++#define NID_dod 380 ++#define OBJ_dod OBJ_org,6L ++ ++#define SN_iana "IANA" ++#define LN_iana "iana" ++#define NID_iana 381 ++#define OBJ_iana OBJ_dod,1L ++ ++#define OBJ_internet OBJ_iana ++ ++#define SN_Directory "directory" ++#define LN_Directory "Directory" ++#define NID_Directory 382 ++#define OBJ_Directory OBJ_internet,1L ++ ++#define SN_Management "mgmt" ++#define LN_Management "Management" ++#define NID_Management 383 ++#define OBJ_Management OBJ_internet,2L ++ ++#define SN_Experimental "experimental" ++#define LN_Experimental "Experimental" ++#define NID_Experimental 384 ++#define OBJ_Experimental OBJ_internet,3L ++ ++#define SN_Private "private" ++#define LN_Private "Private" ++#define NID_Private 385 ++#define OBJ_Private OBJ_internet,4L ++ ++#define SN_Security "security" ++#define LN_Security "Security" ++#define NID_Security 386 ++#define OBJ_Security OBJ_internet,5L ++ ++#define SN_SNMPv2 "snmpv2" ++#define LN_SNMPv2 "SNMPv2" ++#define NID_SNMPv2 387 ++#define OBJ_SNMPv2 OBJ_internet,6L ++ ++#define LN_Mail "Mail" ++#define NID_Mail 388 ++#define OBJ_Mail OBJ_internet,7L ++ ++#define SN_Enterprises "enterprises" ++#define LN_Enterprises "Enterprises" ++#define NID_Enterprises 389 ++#define OBJ_Enterprises OBJ_Private,1L ++ ++#define SN_dcObject "dcobject" ++#define LN_dcObject "dcObject" ++#define NID_dcObject 390 ++#define OBJ_dcObject OBJ_Enterprises,1466L,344L ++ ++#define SN_mime_mhs "mime-mhs" ++#define LN_mime_mhs "MIME MHS" ++#define NID_mime_mhs 504 ++#define OBJ_mime_mhs OBJ_Mail,1L ++ ++#define SN_mime_mhs_headings "mime-mhs-headings" ++#define LN_mime_mhs_headings "mime-mhs-headings" ++#define NID_mime_mhs_headings 505 ++#define OBJ_mime_mhs_headings OBJ_mime_mhs,1L ++ ++#define SN_mime_mhs_bodies "mime-mhs-bodies" ++#define LN_mime_mhs_bodies "mime-mhs-bodies" ++#define NID_mime_mhs_bodies 506 ++#define OBJ_mime_mhs_bodies OBJ_mime_mhs,2L ++ ++#define SN_id_hex_partial_message "id-hex-partial-message" ++#define LN_id_hex_partial_message "id-hex-partial-message" ++#define NID_id_hex_partial_message 507 ++#define OBJ_id_hex_partial_message OBJ_mime_mhs_headings,1L ++ ++#define SN_id_hex_multipart_message "id-hex-multipart-message" ++#define LN_id_hex_multipart_message "id-hex-multipart-message" ++#define NID_id_hex_multipart_message 508 ++#define OBJ_id_hex_multipart_message OBJ_mime_mhs_headings,2L ++ ++#define SN_rle_compression "RLE" ++#define LN_rle_compression "run length compression" ++#define NID_rle_compression 124 ++#define OBJ_rle_compression 1L,1L,1L,1L,666L,1L ++ ++#define SN_zlib_compression "ZLIB" ++#define LN_zlib_compression "zlib compression" ++#define NID_zlib_compression 125 ++#define OBJ_zlib_compression OBJ_id_smime_alg,8L ++ ++#define OBJ_csor 2L,16L,840L,1L,101L,3L ++ ++#define OBJ_nistAlgorithms OBJ_csor,4L ++ ++#define OBJ_aes OBJ_nistAlgorithms,1L ++ ++#define SN_aes_128_ecb "AES-128-ECB" ++#define LN_aes_128_ecb "aes-128-ecb" ++#define NID_aes_128_ecb 418 ++#define OBJ_aes_128_ecb OBJ_aes,1L ++ ++#define SN_aes_128_cbc "AES-128-CBC" ++#define LN_aes_128_cbc "aes-128-cbc" ++#define NID_aes_128_cbc 419 ++#define OBJ_aes_128_cbc OBJ_aes,2L ++ ++#define SN_aes_128_ofb128 "AES-128-OFB" ++#define LN_aes_128_ofb128 "aes-128-ofb" ++#define NID_aes_128_ofb128 420 ++#define OBJ_aes_128_ofb128 OBJ_aes,3L ++ ++#define SN_aes_128_cfb128 "AES-128-CFB" ++#define LN_aes_128_cfb128 "aes-128-cfb" ++#define NID_aes_128_cfb128 421 ++#define OBJ_aes_128_cfb128 OBJ_aes,4L ++ ++#define SN_aes_192_ecb "AES-192-ECB" ++#define LN_aes_192_ecb "aes-192-ecb" ++#define NID_aes_192_ecb 422 ++#define OBJ_aes_192_ecb OBJ_aes,21L ++ ++#define SN_aes_192_cbc "AES-192-CBC" ++#define LN_aes_192_cbc "aes-192-cbc" ++#define NID_aes_192_cbc 423 ++#define OBJ_aes_192_cbc OBJ_aes,22L ++ ++#define SN_aes_192_ofb128 "AES-192-OFB" ++#define LN_aes_192_ofb128 "aes-192-ofb" ++#define NID_aes_192_ofb128 424 ++#define OBJ_aes_192_ofb128 OBJ_aes,23L ++ ++#define SN_aes_192_cfb128 "AES-192-CFB" ++#define LN_aes_192_cfb128 "aes-192-cfb" ++#define NID_aes_192_cfb128 425 ++#define OBJ_aes_192_cfb128 OBJ_aes,24L ++ ++#define SN_aes_256_ecb "AES-256-ECB" ++#define LN_aes_256_ecb "aes-256-ecb" ++#define NID_aes_256_ecb 426 ++#define OBJ_aes_256_ecb OBJ_aes,41L ++ ++#define SN_aes_256_cbc "AES-256-CBC" ++#define LN_aes_256_cbc "aes-256-cbc" ++#define NID_aes_256_cbc 427 ++#define OBJ_aes_256_cbc OBJ_aes,42L ++ ++#define SN_aes_256_ofb128 "AES-256-OFB" ++#define LN_aes_256_ofb128 "aes-256-ofb" ++#define NID_aes_256_ofb128 428 ++#define OBJ_aes_256_ofb128 OBJ_aes,43L ++ ++#define SN_aes_256_cfb128 "AES-256-CFB" ++#define LN_aes_256_cfb128 "aes-256-cfb" ++#define NID_aes_256_cfb128 429 ++#define OBJ_aes_256_cfb128 OBJ_aes,44L ++ ++#define SN_aes_128_cfb1 "AES-128-CFB1" ++#define LN_aes_128_cfb1 "aes-128-cfb1" ++#define NID_aes_128_cfb1 650 ++ ++#define SN_aes_192_cfb1 "AES-192-CFB1" ++#define LN_aes_192_cfb1 "aes-192-cfb1" ++#define NID_aes_192_cfb1 651 ++ ++#define SN_aes_256_cfb1 "AES-256-CFB1" ++#define LN_aes_256_cfb1 "aes-256-cfb1" ++#define NID_aes_256_cfb1 652 ++ ++#define SN_aes_128_cfb8 "AES-128-CFB8" ++#define LN_aes_128_cfb8 "aes-128-cfb8" ++#define NID_aes_128_cfb8 653 ++ ++#define SN_aes_192_cfb8 "AES-192-CFB8" ++#define LN_aes_192_cfb8 "aes-192-cfb8" ++#define NID_aes_192_cfb8 654 ++ ++#define SN_aes_256_cfb8 "AES-256-CFB8" ++#define LN_aes_256_cfb8 "aes-256-cfb8" ++#define NID_aes_256_cfb8 655 ++ ++#define SN_des_cfb1 "DES-CFB1" ++#define LN_des_cfb1 "des-cfb1" ++#define NID_des_cfb1 656 ++ ++#define SN_des_cfb8 "DES-CFB8" ++#define LN_des_cfb8 "des-cfb8" ++#define NID_des_cfb8 657 ++ ++#define SN_des_ede3_cfb1 "DES-EDE3-CFB1" ++#define LN_des_ede3_cfb1 "des-ede3-cfb1" ++#define NID_des_ede3_cfb1 658 ++ ++#define SN_des_ede3_cfb8 "DES-EDE3-CFB8" ++#define LN_des_ede3_cfb8 "des-ede3-cfb8" ++#define NID_des_ede3_cfb8 659 ++ ++#define SN_id_aes128_wrap "id-aes128-wrap" ++#define NID_id_aes128_wrap 788 ++#define OBJ_id_aes128_wrap OBJ_aes,5L ++ ++#define SN_id_aes192_wrap "id-aes192-wrap" ++#define NID_id_aes192_wrap 789 ++#define OBJ_id_aes192_wrap OBJ_aes,25L ++ ++#define SN_id_aes256_wrap "id-aes256-wrap" ++#define NID_id_aes256_wrap 790 ++#define OBJ_id_aes256_wrap OBJ_aes,45L ++ ++#define OBJ_nist_hashalgs OBJ_nistAlgorithms,2L ++ ++#define SN_sha256 "SHA256" ++#define LN_sha256 "sha256" ++#define NID_sha256 672 ++#define OBJ_sha256 OBJ_nist_hashalgs,1L ++ ++#define SN_sha384 "SHA384" ++#define LN_sha384 "sha384" ++#define NID_sha384 673 ++#define OBJ_sha384 OBJ_nist_hashalgs,2L ++ ++#define SN_sha512 "SHA512" ++#define LN_sha512 "sha512" ++#define NID_sha512 674 ++#define OBJ_sha512 OBJ_nist_hashalgs,3L ++ ++#define SN_sha224 "SHA224" ++#define LN_sha224 "sha224" ++#define NID_sha224 675 ++#define OBJ_sha224 OBJ_nist_hashalgs,4L ++ ++#define OBJ_dsa_with_sha2 OBJ_nistAlgorithms,3L ++ ++#define SN_dsa_with_SHA224 "dsa_with_SHA224" ++#define NID_dsa_with_SHA224 802 ++#define OBJ_dsa_with_SHA224 OBJ_dsa_with_sha2,1L ++ ++#define SN_dsa_with_SHA256 "dsa_with_SHA256" ++#define NID_dsa_with_SHA256 803 ++#define OBJ_dsa_with_SHA256 OBJ_dsa_with_sha2,2L ++ ++#define SN_hold_instruction_code "holdInstructionCode" ++#define LN_hold_instruction_code "Hold Instruction Code" ++#define NID_hold_instruction_code 430 ++#define OBJ_hold_instruction_code OBJ_id_ce,23L ++ ++#define OBJ_holdInstruction OBJ_X9_57,2L ++ ++#define SN_hold_instruction_none "holdInstructionNone" ++#define LN_hold_instruction_none "Hold Instruction None" ++#define NID_hold_instruction_none 431 ++#define OBJ_hold_instruction_none OBJ_holdInstruction,1L ++ ++#define SN_hold_instruction_call_issuer "holdInstructionCallIssuer" ++#define LN_hold_instruction_call_issuer "Hold Instruction Call Issuer" ++#define NID_hold_instruction_call_issuer 432 ++#define OBJ_hold_instruction_call_issuer OBJ_holdInstruction,2L ++ ++#define SN_hold_instruction_reject "holdInstructionReject" ++#define LN_hold_instruction_reject "Hold Instruction Reject" ++#define NID_hold_instruction_reject 433 ++#define OBJ_hold_instruction_reject OBJ_holdInstruction,3L ++ ++#define SN_data "data" ++#define NID_data 434 ++#define OBJ_data OBJ_itu_t,9L ++ ++#define SN_pss "pss" ++#define NID_pss 435 ++#define OBJ_pss OBJ_data,2342L ++ ++#define SN_ucl "ucl" ++#define NID_ucl 436 ++#define OBJ_ucl OBJ_pss,19200300L ++ ++#define SN_pilot "pilot" ++#define NID_pilot 437 ++#define OBJ_pilot OBJ_ucl,100L ++ ++#define LN_pilotAttributeType "pilotAttributeType" ++#define NID_pilotAttributeType 438 ++#define OBJ_pilotAttributeType OBJ_pilot,1L ++ ++#define LN_pilotAttributeSyntax "pilotAttributeSyntax" ++#define NID_pilotAttributeSyntax 439 ++#define OBJ_pilotAttributeSyntax OBJ_pilot,3L ++ ++#define LN_pilotObjectClass "pilotObjectClass" ++#define NID_pilotObjectClass 440 ++#define OBJ_pilotObjectClass OBJ_pilot,4L ++ ++#define LN_pilotGroups "pilotGroups" ++#define NID_pilotGroups 441 ++#define OBJ_pilotGroups OBJ_pilot,10L ++ ++#define LN_iA5StringSyntax "iA5StringSyntax" ++#define NID_iA5StringSyntax 442 ++#define OBJ_iA5StringSyntax OBJ_pilotAttributeSyntax,4L ++ ++#define LN_caseIgnoreIA5StringSyntax "caseIgnoreIA5StringSyntax" ++#define NID_caseIgnoreIA5StringSyntax 443 ++#define OBJ_caseIgnoreIA5StringSyntax OBJ_pilotAttributeSyntax,5L ++ ++#define LN_pilotObject "pilotObject" ++#define NID_pilotObject 444 ++#define OBJ_pilotObject OBJ_pilotObjectClass,3L ++ ++#define LN_pilotPerson "pilotPerson" ++#define NID_pilotPerson 445 ++#define OBJ_pilotPerson OBJ_pilotObjectClass,4L ++ ++#define SN_account "account" ++#define NID_account 446 ++#define OBJ_account OBJ_pilotObjectClass,5L ++ ++#define SN_document "document" ++#define NID_document 447 ++#define OBJ_document OBJ_pilotObjectClass,6L ++ ++#define SN_room "room" ++#define NID_room 448 ++#define OBJ_room OBJ_pilotObjectClass,7L ++ ++#define LN_documentSeries "documentSeries" ++#define NID_documentSeries 449 ++#define OBJ_documentSeries OBJ_pilotObjectClass,9L ++ ++#define SN_Domain "domain" ++#define LN_Domain "Domain" ++#define NID_Domain 392 ++#define OBJ_Domain OBJ_pilotObjectClass,13L ++ ++#define LN_rFC822localPart "rFC822localPart" ++#define NID_rFC822localPart 450 ++#define OBJ_rFC822localPart OBJ_pilotObjectClass,14L ++ ++#define LN_dNSDomain "dNSDomain" ++#define NID_dNSDomain 451 ++#define OBJ_dNSDomain OBJ_pilotObjectClass,15L ++ ++#define LN_domainRelatedObject "domainRelatedObject" ++#define NID_domainRelatedObject 452 ++#define OBJ_domainRelatedObject OBJ_pilotObjectClass,17L ++ ++#define LN_friendlyCountry "friendlyCountry" ++#define NID_friendlyCountry 453 ++#define OBJ_friendlyCountry OBJ_pilotObjectClass,18L ++ ++#define LN_simpleSecurityObject "simpleSecurityObject" ++#define NID_simpleSecurityObject 454 ++#define OBJ_simpleSecurityObject OBJ_pilotObjectClass,19L ++ ++#define LN_pilotOrganization "pilotOrganization" ++#define NID_pilotOrganization 455 ++#define OBJ_pilotOrganization OBJ_pilotObjectClass,20L ++ ++#define LN_pilotDSA "pilotDSA" ++#define NID_pilotDSA 456 ++#define OBJ_pilotDSA OBJ_pilotObjectClass,21L ++ ++#define LN_qualityLabelledData "qualityLabelledData" ++#define NID_qualityLabelledData 457 ++#define OBJ_qualityLabelledData OBJ_pilotObjectClass,22L ++ ++#define SN_userId "UID" ++#define LN_userId "userId" ++#define NID_userId 458 ++#define OBJ_userId OBJ_pilotAttributeType,1L ++ ++#define LN_textEncodedORAddress "textEncodedORAddress" ++#define NID_textEncodedORAddress 459 ++#define OBJ_textEncodedORAddress OBJ_pilotAttributeType,2L ++ ++#define SN_rfc822Mailbox "mail" ++#define LN_rfc822Mailbox "rfc822Mailbox" ++#define NID_rfc822Mailbox 460 ++#define OBJ_rfc822Mailbox OBJ_pilotAttributeType,3L ++ ++#define SN_info "info" ++#define NID_info 461 ++#define OBJ_info OBJ_pilotAttributeType,4L ++ ++#define LN_favouriteDrink "favouriteDrink" ++#define NID_favouriteDrink 462 ++#define OBJ_favouriteDrink OBJ_pilotAttributeType,5L ++ ++#define LN_roomNumber "roomNumber" ++#define NID_roomNumber 463 ++#define OBJ_roomNumber OBJ_pilotAttributeType,6L ++ ++#define SN_photo "photo" ++#define NID_photo 464 ++#define OBJ_photo OBJ_pilotAttributeType,7L ++ ++#define LN_userClass "userClass" ++#define NID_userClass 465 ++#define OBJ_userClass OBJ_pilotAttributeType,8L ++ ++#define SN_host "host" ++#define NID_host 466 ++#define OBJ_host OBJ_pilotAttributeType,9L ++ ++#define SN_manager "manager" ++#define NID_manager 467 ++#define OBJ_manager OBJ_pilotAttributeType,10L ++ ++#define LN_documentIdentifier "documentIdentifier" ++#define NID_documentIdentifier 468 ++#define OBJ_documentIdentifier OBJ_pilotAttributeType,11L ++ ++#define LN_documentTitle "documentTitle" ++#define NID_documentTitle 469 ++#define OBJ_documentTitle OBJ_pilotAttributeType,12L ++ ++#define LN_documentVersion "documentVersion" ++#define NID_documentVersion 470 ++#define OBJ_documentVersion OBJ_pilotAttributeType,13L ++ ++#define LN_documentAuthor "documentAuthor" ++#define NID_documentAuthor 471 ++#define OBJ_documentAuthor OBJ_pilotAttributeType,14L ++ ++#define LN_documentLocation "documentLocation" ++#define NID_documentLocation 472 ++#define OBJ_documentLocation OBJ_pilotAttributeType,15L ++ ++#define LN_homeTelephoneNumber "homeTelephoneNumber" ++#define NID_homeTelephoneNumber 473 ++#define OBJ_homeTelephoneNumber OBJ_pilotAttributeType,20L ++ ++#define SN_secretary "secretary" ++#define NID_secretary 474 ++#define OBJ_secretary OBJ_pilotAttributeType,21L ++ ++#define LN_otherMailbox "otherMailbox" ++#define NID_otherMailbox 475 ++#define OBJ_otherMailbox OBJ_pilotAttributeType,22L ++ ++#define LN_lastModifiedTime "lastModifiedTime" ++#define NID_lastModifiedTime 476 ++#define OBJ_lastModifiedTime OBJ_pilotAttributeType,23L ++ ++#define LN_lastModifiedBy "lastModifiedBy" ++#define NID_lastModifiedBy 477 ++#define OBJ_lastModifiedBy OBJ_pilotAttributeType,24L ++ ++#define SN_domainComponent "DC" ++#define LN_domainComponent "domainComponent" ++#define NID_domainComponent 391 ++#define OBJ_domainComponent OBJ_pilotAttributeType,25L ++ ++#define LN_aRecord "aRecord" ++#define NID_aRecord 478 ++#define OBJ_aRecord OBJ_pilotAttributeType,26L ++ ++#define LN_pilotAttributeType27 "pilotAttributeType27" ++#define NID_pilotAttributeType27 479 ++#define OBJ_pilotAttributeType27 OBJ_pilotAttributeType,27L ++ ++#define LN_mXRecord "mXRecord" ++#define NID_mXRecord 480 ++#define OBJ_mXRecord OBJ_pilotAttributeType,28L ++ ++#define LN_nSRecord "nSRecord" ++#define NID_nSRecord 481 ++#define OBJ_nSRecord OBJ_pilotAttributeType,29L ++ ++#define LN_sOARecord "sOARecord" ++#define NID_sOARecord 482 ++#define OBJ_sOARecord OBJ_pilotAttributeType,30L ++ ++#define LN_cNAMERecord "cNAMERecord" ++#define NID_cNAMERecord 483 ++#define OBJ_cNAMERecord OBJ_pilotAttributeType,31L ++ ++#define LN_associatedDomain "associatedDomain" ++#define NID_associatedDomain 484 ++#define OBJ_associatedDomain OBJ_pilotAttributeType,37L ++ ++#define LN_associatedName "associatedName" ++#define NID_associatedName 485 ++#define OBJ_associatedName OBJ_pilotAttributeType,38L ++ ++#define LN_homePostalAddress "homePostalAddress" ++#define NID_homePostalAddress 486 ++#define OBJ_homePostalAddress OBJ_pilotAttributeType,39L ++ ++#define LN_personalTitle "personalTitle" ++#define NID_personalTitle 487 ++#define OBJ_personalTitle OBJ_pilotAttributeType,40L ++ ++#define LN_mobileTelephoneNumber "mobileTelephoneNumber" ++#define NID_mobileTelephoneNumber 488 ++#define OBJ_mobileTelephoneNumber OBJ_pilotAttributeType,41L ++ ++#define LN_pagerTelephoneNumber "pagerTelephoneNumber" ++#define NID_pagerTelephoneNumber 489 ++#define OBJ_pagerTelephoneNumber OBJ_pilotAttributeType,42L ++ ++#define LN_friendlyCountryName "friendlyCountryName" ++#define NID_friendlyCountryName 490 ++#define OBJ_friendlyCountryName OBJ_pilotAttributeType,43L ++ ++#define LN_organizationalStatus "organizationalStatus" ++#define NID_organizationalStatus 491 ++#define OBJ_organizationalStatus OBJ_pilotAttributeType,45L ++ ++#define LN_janetMailbox "janetMailbox" ++#define NID_janetMailbox 492 ++#define OBJ_janetMailbox OBJ_pilotAttributeType,46L ++ ++#define LN_mailPreferenceOption "mailPreferenceOption" ++#define NID_mailPreferenceOption 493 ++#define OBJ_mailPreferenceOption OBJ_pilotAttributeType,47L ++ ++#define LN_buildingName "buildingName" ++#define NID_buildingName 494 ++#define OBJ_buildingName OBJ_pilotAttributeType,48L ++ ++#define LN_dSAQuality "dSAQuality" ++#define NID_dSAQuality 495 ++#define OBJ_dSAQuality OBJ_pilotAttributeType,49L ++ ++#define LN_singleLevelQuality "singleLevelQuality" ++#define NID_singleLevelQuality 496 ++#define OBJ_singleLevelQuality OBJ_pilotAttributeType,50L ++ ++#define LN_subtreeMinimumQuality "subtreeMinimumQuality" ++#define NID_subtreeMinimumQuality 497 ++#define OBJ_subtreeMinimumQuality OBJ_pilotAttributeType,51L ++ ++#define LN_subtreeMaximumQuality "subtreeMaximumQuality" ++#define NID_subtreeMaximumQuality 498 ++#define OBJ_subtreeMaximumQuality OBJ_pilotAttributeType,52L ++ ++#define LN_personalSignature "personalSignature" ++#define NID_personalSignature 499 ++#define OBJ_personalSignature OBJ_pilotAttributeType,53L ++ ++#define LN_dITRedirect "dITRedirect" ++#define NID_dITRedirect 500 ++#define OBJ_dITRedirect OBJ_pilotAttributeType,54L ++ ++#define SN_audio "audio" ++#define NID_audio 501 ++#define OBJ_audio OBJ_pilotAttributeType,55L ++ ++#define LN_documentPublisher "documentPublisher" ++#define NID_documentPublisher 502 ++#define OBJ_documentPublisher OBJ_pilotAttributeType,56L ++ ++#define SN_id_set "id-set" ++#define LN_id_set "Secure Electronic Transactions" ++#define NID_id_set 512 ++#define OBJ_id_set OBJ_international_organizations,42L ++ ++#define SN_set_ctype "set-ctype" ++#define LN_set_ctype "content types" ++#define NID_set_ctype 513 ++#define OBJ_set_ctype OBJ_id_set,0L ++ ++#define SN_set_msgExt "set-msgExt" ++#define LN_set_msgExt "message extensions" ++#define NID_set_msgExt 514 ++#define OBJ_set_msgExt OBJ_id_set,1L ++ ++#define SN_set_attr "set-attr" ++#define NID_set_attr 515 ++#define OBJ_set_attr OBJ_id_set,3L ++ ++#define SN_set_policy "set-policy" ++#define NID_set_policy 516 ++#define OBJ_set_policy OBJ_id_set,5L ++ ++#define SN_set_certExt "set-certExt" ++#define LN_set_certExt "certificate extensions" ++#define NID_set_certExt 517 ++#define OBJ_set_certExt OBJ_id_set,7L ++ ++#define SN_set_brand "set-brand" ++#define NID_set_brand 518 ++#define OBJ_set_brand OBJ_id_set,8L ++ ++#define SN_setct_PANData "setct-PANData" ++#define NID_setct_PANData 519 ++#define OBJ_setct_PANData OBJ_set_ctype,0L ++ ++#define SN_setct_PANToken "setct-PANToken" ++#define NID_setct_PANToken 520 ++#define OBJ_setct_PANToken OBJ_set_ctype,1L ++ ++#define SN_setct_PANOnly "setct-PANOnly" ++#define NID_setct_PANOnly 521 ++#define OBJ_setct_PANOnly OBJ_set_ctype,2L ++ ++#define SN_setct_OIData "setct-OIData" ++#define NID_setct_OIData 522 ++#define OBJ_setct_OIData OBJ_set_ctype,3L ++ ++#define SN_setct_PI "setct-PI" ++#define NID_setct_PI 523 ++#define OBJ_setct_PI OBJ_set_ctype,4L ++ ++#define SN_setct_PIData "setct-PIData" ++#define NID_setct_PIData 524 ++#define OBJ_setct_PIData OBJ_set_ctype,5L ++ ++#define SN_setct_PIDataUnsigned "setct-PIDataUnsigned" ++#define NID_setct_PIDataUnsigned 525 ++#define OBJ_setct_PIDataUnsigned OBJ_set_ctype,6L ++ ++#define SN_setct_HODInput "setct-HODInput" ++#define NID_setct_HODInput 526 ++#define OBJ_setct_HODInput OBJ_set_ctype,7L ++ ++#define SN_setct_AuthResBaggage "setct-AuthResBaggage" ++#define NID_setct_AuthResBaggage 527 ++#define OBJ_setct_AuthResBaggage OBJ_set_ctype,8L ++ ++#define SN_setct_AuthRevReqBaggage "setct-AuthRevReqBaggage" ++#define NID_setct_AuthRevReqBaggage 528 ++#define OBJ_setct_AuthRevReqBaggage OBJ_set_ctype,9L ++ ++#define SN_setct_AuthRevResBaggage "setct-AuthRevResBaggage" ++#define NID_setct_AuthRevResBaggage 529 ++#define OBJ_setct_AuthRevResBaggage OBJ_set_ctype,10L ++ ++#define SN_setct_CapTokenSeq "setct-CapTokenSeq" ++#define NID_setct_CapTokenSeq 530 ++#define OBJ_setct_CapTokenSeq OBJ_set_ctype,11L ++ ++#define SN_setct_PInitResData "setct-PInitResData" ++#define NID_setct_PInitResData 531 ++#define OBJ_setct_PInitResData OBJ_set_ctype,12L ++ ++#define SN_setct_PI_TBS "setct-PI-TBS" ++#define NID_setct_PI_TBS 532 ++#define OBJ_setct_PI_TBS OBJ_set_ctype,13L ++ ++#define SN_setct_PResData "setct-PResData" ++#define NID_setct_PResData 533 ++#define OBJ_setct_PResData OBJ_set_ctype,14L ++ ++#define SN_setct_AuthReqTBS "setct-AuthReqTBS" ++#define NID_setct_AuthReqTBS 534 ++#define OBJ_setct_AuthReqTBS OBJ_set_ctype,16L ++ ++#define SN_setct_AuthResTBS "setct-AuthResTBS" ++#define NID_setct_AuthResTBS 535 ++#define OBJ_setct_AuthResTBS OBJ_set_ctype,17L ++ ++#define SN_setct_AuthResTBSX "setct-AuthResTBSX" ++#define NID_setct_AuthResTBSX 536 ++#define OBJ_setct_AuthResTBSX OBJ_set_ctype,18L ++ ++#define SN_setct_AuthTokenTBS "setct-AuthTokenTBS" ++#define NID_setct_AuthTokenTBS 537 ++#define OBJ_setct_AuthTokenTBS OBJ_set_ctype,19L ++ ++#define SN_setct_CapTokenData "setct-CapTokenData" ++#define NID_setct_CapTokenData 538 ++#define OBJ_setct_CapTokenData OBJ_set_ctype,20L ++ ++#define SN_setct_CapTokenTBS "setct-CapTokenTBS" ++#define NID_setct_CapTokenTBS 539 ++#define OBJ_setct_CapTokenTBS OBJ_set_ctype,21L ++ ++#define SN_setct_AcqCardCodeMsg "setct-AcqCardCodeMsg" ++#define NID_setct_AcqCardCodeMsg 540 ++#define OBJ_setct_AcqCardCodeMsg OBJ_set_ctype,22L ++ ++#define SN_setct_AuthRevReqTBS "setct-AuthRevReqTBS" ++#define NID_setct_AuthRevReqTBS 541 ++#define OBJ_setct_AuthRevReqTBS OBJ_set_ctype,23L ++ ++#define SN_setct_AuthRevResData "setct-AuthRevResData" ++#define NID_setct_AuthRevResData 542 ++#define OBJ_setct_AuthRevResData OBJ_set_ctype,24L ++ ++#define SN_setct_AuthRevResTBS "setct-AuthRevResTBS" ++#define NID_setct_AuthRevResTBS 543 ++#define OBJ_setct_AuthRevResTBS OBJ_set_ctype,25L ++ ++#define SN_setct_CapReqTBS "setct-CapReqTBS" ++#define NID_setct_CapReqTBS 544 ++#define OBJ_setct_CapReqTBS OBJ_set_ctype,26L ++ ++#define SN_setct_CapReqTBSX "setct-CapReqTBSX" ++#define NID_setct_CapReqTBSX 545 ++#define OBJ_setct_CapReqTBSX OBJ_set_ctype,27L ++ ++#define SN_setct_CapResData "setct-CapResData" ++#define NID_setct_CapResData 546 ++#define OBJ_setct_CapResData OBJ_set_ctype,28L ++ ++#define SN_setct_CapRevReqTBS "setct-CapRevReqTBS" ++#define NID_setct_CapRevReqTBS 547 ++#define OBJ_setct_CapRevReqTBS OBJ_set_ctype,29L ++ ++#define SN_setct_CapRevReqTBSX "setct-CapRevReqTBSX" ++#define NID_setct_CapRevReqTBSX 548 ++#define OBJ_setct_CapRevReqTBSX OBJ_set_ctype,30L ++ ++#define SN_setct_CapRevResData "setct-CapRevResData" ++#define NID_setct_CapRevResData 549 ++#define OBJ_setct_CapRevResData OBJ_set_ctype,31L ++ ++#define SN_setct_CredReqTBS "setct-CredReqTBS" ++#define NID_setct_CredReqTBS 550 ++#define OBJ_setct_CredReqTBS OBJ_set_ctype,32L ++ ++#define SN_setct_CredReqTBSX "setct-CredReqTBSX" ++#define NID_setct_CredReqTBSX 551 ++#define OBJ_setct_CredReqTBSX OBJ_set_ctype,33L ++ ++#define SN_setct_CredResData "setct-CredResData" ++#define NID_setct_CredResData 552 ++#define OBJ_setct_CredResData OBJ_set_ctype,34L ++ ++#define SN_setct_CredRevReqTBS "setct-CredRevReqTBS" ++#define NID_setct_CredRevReqTBS 553 ++#define OBJ_setct_CredRevReqTBS OBJ_set_ctype,35L ++ ++#define SN_setct_CredRevReqTBSX "setct-CredRevReqTBSX" ++#define NID_setct_CredRevReqTBSX 554 ++#define OBJ_setct_CredRevReqTBSX OBJ_set_ctype,36L ++ ++#define SN_setct_CredRevResData "setct-CredRevResData" ++#define NID_setct_CredRevResData 555 ++#define OBJ_setct_CredRevResData OBJ_set_ctype,37L ++ ++#define SN_setct_PCertReqData "setct-PCertReqData" ++#define NID_setct_PCertReqData 556 ++#define OBJ_setct_PCertReqData OBJ_set_ctype,38L ++ ++#define SN_setct_PCertResTBS "setct-PCertResTBS" ++#define NID_setct_PCertResTBS 557 ++#define OBJ_setct_PCertResTBS OBJ_set_ctype,39L ++ ++#define SN_setct_BatchAdminReqData "setct-BatchAdminReqData" ++#define NID_setct_BatchAdminReqData 558 ++#define OBJ_setct_BatchAdminReqData OBJ_set_ctype,40L ++ ++#define SN_setct_BatchAdminResData "setct-BatchAdminResData" ++#define NID_setct_BatchAdminResData 559 ++#define OBJ_setct_BatchAdminResData OBJ_set_ctype,41L ++ ++#define SN_setct_CardCInitResTBS "setct-CardCInitResTBS" ++#define NID_setct_CardCInitResTBS 560 ++#define OBJ_setct_CardCInitResTBS OBJ_set_ctype,42L ++ ++#define SN_setct_MeAqCInitResTBS "setct-MeAqCInitResTBS" ++#define NID_setct_MeAqCInitResTBS 561 ++#define OBJ_setct_MeAqCInitResTBS OBJ_set_ctype,43L ++ ++#define SN_setct_RegFormResTBS "setct-RegFormResTBS" ++#define NID_setct_RegFormResTBS 562 ++#define OBJ_setct_RegFormResTBS OBJ_set_ctype,44L ++ ++#define SN_setct_CertReqData "setct-CertReqData" ++#define NID_setct_CertReqData 563 ++#define OBJ_setct_CertReqData OBJ_set_ctype,45L ++ ++#define SN_setct_CertReqTBS "setct-CertReqTBS" ++#define NID_setct_CertReqTBS 564 ++#define OBJ_setct_CertReqTBS OBJ_set_ctype,46L ++ ++#define SN_setct_CertResData "setct-CertResData" ++#define NID_setct_CertResData 565 ++#define OBJ_setct_CertResData OBJ_set_ctype,47L ++ ++#define SN_setct_CertInqReqTBS "setct-CertInqReqTBS" ++#define NID_setct_CertInqReqTBS 566 ++#define OBJ_setct_CertInqReqTBS OBJ_set_ctype,48L ++ ++#define SN_setct_ErrorTBS "setct-ErrorTBS" ++#define NID_setct_ErrorTBS 567 ++#define OBJ_setct_ErrorTBS OBJ_set_ctype,49L ++ ++#define SN_setct_PIDualSignedTBE "setct-PIDualSignedTBE" ++#define NID_setct_PIDualSignedTBE 568 ++#define OBJ_setct_PIDualSignedTBE OBJ_set_ctype,50L ++ ++#define SN_setct_PIUnsignedTBE "setct-PIUnsignedTBE" ++#define NID_setct_PIUnsignedTBE 569 ++#define OBJ_setct_PIUnsignedTBE OBJ_set_ctype,51L ++ ++#define SN_setct_AuthReqTBE "setct-AuthReqTBE" ++#define NID_setct_AuthReqTBE 570 ++#define OBJ_setct_AuthReqTBE OBJ_set_ctype,52L ++ ++#define SN_setct_AuthResTBE "setct-AuthResTBE" ++#define NID_setct_AuthResTBE 571 ++#define OBJ_setct_AuthResTBE OBJ_set_ctype,53L ++ ++#define SN_setct_AuthResTBEX "setct-AuthResTBEX" ++#define NID_setct_AuthResTBEX 572 ++#define OBJ_setct_AuthResTBEX OBJ_set_ctype,54L ++ ++#define SN_setct_AuthTokenTBE "setct-AuthTokenTBE" ++#define NID_setct_AuthTokenTBE 573 ++#define OBJ_setct_AuthTokenTBE OBJ_set_ctype,55L ++ ++#define SN_setct_CapTokenTBE "setct-CapTokenTBE" ++#define NID_setct_CapTokenTBE 574 ++#define OBJ_setct_CapTokenTBE OBJ_set_ctype,56L ++ ++#define SN_setct_CapTokenTBEX "setct-CapTokenTBEX" ++#define NID_setct_CapTokenTBEX 575 ++#define OBJ_setct_CapTokenTBEX OBJ_set_ctype,57L ++ ++#define SN_setct_AcqCardCodeMsgTBE "setct-AcqCardCodeMsgTBE" ++#define NID_setct_AcqCardCodeMsgTBE 576 ++#define OBJ_setct_AcqCardCodeMsgTBE OBJ_set_ctype,58L ++ ++#define SN_setct_AuthRevReqTBE "setct-AuthRevReqTBE" ++#define NID_setct_AuthRevReqTBE 577 ++#define OBJ_setct_AuthRevReqTBE OBJ_set_ctype,59L ++ ++#define SN_setct_AuthRevResTBE "setct-AuthRevResTBE" ++#define NID_setct_AuthRevResTBE 578 ++#define OBJ_setct_AuthRevResTBE OBJ_set_ctype,60L ++ ++#define SN_setct_AuthRevResTBEB "setct-AuthRevResTBEB" ++#define NID_setct_AuthRevResTBEB 579 ++#define OBJ_setct_AuthRevResTBEB OBJ_set_ctype,61L ++ ++#define SN_setct_CapReqTBE "setct-CapReqTBE" ++#define NID_setct_CapReqTBE 580 ++#define OBJ_setct_CapReqTBE OBJ_set_ctype,62L ++ ++#define SN_setct_CapReqTBEX "setct-CapReqTBEX" ++#define NID_setct_CapReqTBEX 581 ++#define OBJ_setct_CapReqTBEX OBJ_set_ctype,63L ++ ++#define SN_setct_CapResTBE "setct-CapResTBE" ++#define NID_setct_CapResTBE 582 ++#define OBJ_setct_CapResTBE OBJ_set_ctype,64L ++ ++#define SN_setct_CapRevReqTBE "setct-CapRevReqTBE" ++#define NID_setct_CapRevReqTBE 583 ++#define OBJ_setct_CapRevReqTBE OBJ_set_ctype,65L ++ ++#define SN_setct_CapRevReqTBEX "setct-CapRevReqTBEX" ++#define NID_setct_CapRevReqTBEX 584 ++#define OBJ_setct_CapRevReqTBEX OBJ_set_ctype,66L ++ ++#define SN_setct_CapRevResTBE "setct-CapRevResTBE" ++#define NID_setct_CapRevResTBE 585 ++#define OBJ_setct_CapRevResTBE OBJ_set_ctype,67L ++ ++#define SN_setct_CredReqTBE "setct-CredReqTBE" ++#define NID_setct_CredReqTBE 586 ++#define OBJ_setct_CredReqTBE OBJ_set_ctype,68L ++ ++#define SN_setct_CredReqTBEX "setct-CredReqTBEX" ++#define NID_setct_CredReqTBEX 587 ++#define OBJ_setct_CredReqTBEX OBJ_set_ctype,69L ++ ++#define SN_setct_CredResTBE "setct-CredResTBE" ++#define NID_setct_CredResTBE 588 ++#define OBJ_setct_CredResTBE OBJ_set_ctype,70L ++ ++#define SN_setct_CredRevReqTBE "setct-CredRevReqTBE" ++#define NID_setct_CredRevReqTBE 589 ++#define OBJ_setct_CredRevReqTBE OBJ_set_ctype,71L ++ ++#define SN_setct_CredRevReqTBEX "setct-CredRevReqTBEX" ++#define NID_setct_CredRevReqTBEX 590 ++#define OBJ_setct_CredRevReqTBEX OBJ_set_ctype,72L ++ ++#define SN_setct_CredRevResTBE "setct-CredRevResTBE" ++#define NID_setct_CredRevResTBE 591 ++#define OBJ_setct_CredRevResTBE OBJ_set_ctype,73L ++ ++#define SN_setct_BatchAdminReqTBE "setct-BatchAdminReqTBE" ++#define NID_setct_BatchAdminReqTBE 592 ++#define OBJ_setct_BatchAdminReqTBE OBJ_set_ctype,74L ++ ++#define SN_setct_BatchAdminResTBE "setct-BatchAdminResTBE" ++#define NID_setct_BatchAdminResTBE 593 ++#define OBJ_setct_BatchAdminResTBE OBJ_set_ctype,75L ++ ++#define SN_setct_RegFormReqTBE "setct-RegFormReqTBE" ++#define NID_setct_RegFormReqTBE 594 ++#define OBJ_setct_RegFormReqTBE OBJ_set_ctype,76L ++ ++#define SN_setct_CertReqTBE "setct-CertReqTBE" ++#define NID_setct_CertReqTBE 595 ++#define OBJ_setct_CertReqTBE OBJ_set_ctype,77L ++ ++#define SN_setct_CertReqTBEX "setct-CertReqTBEX" ++#define NID_setct_CertReqTBEX 596 ++#define OBJ_setct_CertReqTBEX OBJ_set_ctype,78L ++ ++#define SN_setct_CertResTBE "setct-CertResTBE" ++#define NID_setct_CertResTBE 597 ++#define OBJ_setct_CertResTBE OBJ_set_ctype,79L ++ ++#define SN_setct_CRLNotificationTBS "setct-CRLNotificationTBS" ++#define NID_setct_CRLNotificationTBS 598 ++#define OBJ_setct_CRLNotificationTBS OBJ_set_ctype,80L ++ ++#define SN_setct_CRLNotificationResTBS "setct-CRLNotificationResTBS" ++#define NID_setct_CRLNotificationResTBS 599 ++#define OBJ_setct_CRLNotificationResTBS OBJ_set_ctype,81L ++ ++#define SN_setct_BCIDistributionTBS "setct-BCIDistributionTBS" ++#define NID_setct_BCIDistributionTBS 600 ++#define OBJ_setct_BCIDistributionTBS OBJ_set_ctype,82L ++ ++#define SN_setext_genCrypt "setext-genCrypt" ++#define LN_setext_genCrypt "generic cryptogram" ++#define NID_setext_genCrypt 601 ++#define OBJ_setext_genCrypt OBJ_set_msgExt,1L ++ ++#define SN_setext_miAuth "setext-miAuth" ++#define LN_setext_miAuth "merchant initiated auth" ++#define NID_setext_miAuth 602 ++#define OBJ_setext_miAuth OBJ_set_msgExt,3L ++ ++#define SN_setext_pinSecure "setext-pinSecure" ++#define NID_setext_pinSecure 603 ++#define OBJ_setext_pinSecure OBJ_set_msgExt,4L ++ ++#define SN_setext_pinAny "setext-pinAny" ++#define NID_setext_pinAny 604 ++#define OBJ_setext_pinAny OBJ_set_msgExt,5L ++ ++#define SN_setext_track2 "setext-track2" ++#define NID_setext_track2 605 ++#define OBJ_setext_track2 OBJ_set_msgExt,7L ++ ++#define SN_setext_cv "setext-cv" ++#define LN_setext_cv "additional verification" ++#define NID_setext_cv 606 ++#define OBJ_setext_cv OBJ_set_msgExt,8L ++ ++#define SN_set_policy_root "set-policy-root" ++#define NID_set_policy_root 607 ++#define OBJ_set_policy_root OBJ_set_policy,0L ++ ++#define SN_setCext_hashedRoot "setCext-hashedRoot" ++#define NID_setCext_hashedRoot 608 ++#define OBJ_setCext_hashedRoot OBJ_set_certExt,0L ++ ++#define SN_setCext_certType "setCext-certType" ++#define NID_setCext_certType 609 ++#define OBJ_setCext_certType OBJ_set_certExt,1L ++ ++#define SN_setCext_merchData "setCext-merchData" ++#define NID_setCext_merchData 610 ++#define OBJ_setCext_merchData OBJ_set_certExt,2L ++ ++#define SN_setCext_cCertRequired "setCext-cCertRequired" ++#define NID_setCext_cCertRequired 611 ++#define OBJ_setCext_cCertRequired OBJ_set_certExt,3L ++ ++#define SN_setCext_tunneling "setCext-tunneling" ++#define NID_setCext_tunneling 612 ++#define OBJ_setCext_tunneling OBJ_set_certExt,4L ++ ++#define SN_setCext_setExt "setCext-setExt" ++#define NID_setCext_setExt 613 ++#define OBJ_setCext_setExt OBJ_set_certExt,5L ++ ++#define SN_setCext_setQualf "setCext-setQualf" ++#define NID_setCext_setQualf 614 ++#define OBJ_setCext_setQualf OBJ_set_certExt,6L ++ ++#define SN_setCext_PGWYcapabilities "setCext-PGWYcapabilities" ++#define NID_setCext_PGWYcapabilities 615 ++#define OBJ_setCext_PGWYcapabilities OBJ_set_certExt,7L ++ ++#define SN_setCext_TokenIdentifier "setCext-TokenIdentifier" ++#define NID_setCext_TokenIdentifier 616 ++#define OBJ_setCext_TokenIdentifier OBJ_set_certExt,8L ++ ++#define SN_setCext_Track2Data "setCext-Track2Data" ++#define NID_setCext_Track2Data 617 ++#define OBJ_setCext_Track2Data OBJ_set_certExt,9L ++ ++#define SN_setCext_TokenType "setCext-TokenType" ++#define NID_setCext_TokenType 618 ++#define OBJ_setCext_TokenType OBJ_set_certExt,10L ++ ++#define SN_setCext_IssuerCapabilities "setCext-IssuerCapabilities" ++#define NID_setCext_IssuerCapabilities 619 ++#define OBJ_setCext_IssuerCapabilities OBJ_set_certExt,11L ++ ++#define SN_setAttr_Cert "setAttr-Cert" ++#define NID_setAttr_Cert 620 ++#define OBJ_setAttr_Cert OBJ_set_attr,0L ++ ++#define SN_setAttr_PGWYcap "setAttr-PGWYcap" ++#define LN_setAttr_PGWYcap "payment gateway capabilities" ++#define NID_setAttr_PGWYcap 621 ++#define OBJ_setAttr_PGWYcap OBJ_set_attr,1L ++ ++#define SN_setAttr_TokenType "setAttr-TokenType" ++#define NID_setAttr_TokenType 622 ++#define OBJ_setAttr_TokenType OBJ_set_attr,2L ++ ++#define SN_setAttr_IssCap "setAttr-IssCap" ++#define LN_setAttr_IssCap "issuer capabilities" ++#define NID_setAttr_IssCap 623 ++#define OBJ_setAttr_IssCap OBJ_set_attr,3L ++ ++#define SN_set_rootKeyThumb "set-rootKeyThumb" ++#define NID_set_rootKeyThumb 624 ++#define OBJ_set_rootKeyThumb OBJ_setAttr_Cert,0L ++ ++#define SN_set_addPolicy "set-addPolicy" ++#define NID_set_addPolicy 625 ++#define OBJ_set_addPolicy OBJ_setAttr_Cert,1L ++ ++#define SN_setAttr_Token_EMV "setAttr-Token-EMV" ++#define NID_setAttr_Token_EMV 626 ++#define OBJ_setAttr_Token_EMV OBJ_setAttr_TokenType,1L ++ ++#define SN_setAttr_Token_B0Prime "setAttr-Token-B0Prime" ++#define NID_setAttr_Token_B0Prime 627 ++#define OBJ_setAttr_Token_B0Prime OBJ_setAttr_TokenType,2L ++ ++#define SN_setAttr_IssCap_CVM "setAttr-IssCap-CVM" ++#define NID_setAttr_IssCap_CVM 628 ++#define OBJ_setAttr_IssCap_CVM OBJ_setAttr_IssCap,3L ++ ++#define SN_setAttr_IssCap_T2 "setAttr-IssCap-T2" ++#define NID_setAttr_IssCap_T2 629 ++#define OBJ_setAttr_IssCap_T2 OBJ_setAttr_IssCap,4L ++ ++#define SN_setAttr_IssCap_Sig "setAttr-IssCap-Sig" ++#define NID_setAttr_IssCap_Sig 630 ++#define OBJ_setAttr_IssCap_Sig OBJ_setAttr_IssCap,5L ++ ++#define SN_setAttr_GenCryptgrm "setAttr-GenCryptgrm" ++#define LN_setAttr_GenCryptgrm "generate cryptogram" ++#define NID_setAttr_GenCryptgrm 631 ++#define OBJ_setAttr_GenCryptgrm OBJ_setAttr_IssCap_CVM,1L ++ ++#define SN_setAttr_T2Enc "setAttr-T2Enc" ++#define LN_setAttr_T2Enc "encrypted track 2" ++#define NID_setAttr_T2Enc 632 ++#define OBJ_setAttr_T2Enc OBJ_setAttr_IssCap_T2,1L ++ ++#define SN_setAttr_T2cleartxt "setAttr-T2cleartxt" ++#define LN_setAttr_T2cleartxt "cleartext track 2" ++#define NID_setAttr_T2cleartxt 633 ++#define OBJ_setAttr_T2cleartxt OBJ_setAttr_IssCap_T2,2L ++ ++#define SN_setAttr_TokICCsig "setAttr-TokICCsig" ++#define LN_setAttr_TokICCsig "ICC or token signature" ++#define NID_setAttr_TokICCsig 634 ++#define OBJ_setAttr_TokICCsig OBJ_setAttr_IssCap_Sig,1L ++ ++#define SN_setAttr_SecDevSig "setAttr-SecDevSig" ++#define LN_setAttr_SecDevSig "secure device signature" ++#define NID_setAttr_SecDevSig 635 ++#define OBJ_setAttr_SecDevSig OBJ_setAttr_IssCap_Sig,2L ++ ++#define SN_set_brand_IATA_ATA "set-brand-IATA-ATA" ++#define NID_set_brand_IATA_ATA 636 ++#define OBJ_set_brand_IATA_ATA OBJ_set_brand,1L ++ ++#define SN_set_brand_Diners "set-brand-Diners" ++#define NID_set_brand_Diners 637 ++#define OBJ_set_brand_Diners OBJ_set_brand,30L ++ ++#define SN_set_brand_AmericanExpress "set-brand-AmericanExpress" ++#define NID_set_brand_AmericanExpress 638 ++#define OBJ_set_brand_AmericanExpress OBJ_set_brand,34L ++ ++#define SN_set_brand_JCB "set-brand-JCB" ++#define NID_set_brand_JCB 639 ++#define OBJ_set_brand_JCB OBJ_set_brand,35L ++ ++#define SN_set_brand_Visa "set-brand-Visa" ++#define NID_set_brand_Visa 640 ++#define OBJ_set_brand_Visa OBJ_set_brand,4L ++ ++#define SN_set_brand_MasterCard "set-brand-MasterCard" ++#define NID_set_brand_MasterCard 641 ++#define OBJ_set_brand_MasterCard OBJ_set_brand,5L ++ ++#define SN_set_brand_Novus "set-brand-Novus" ++#define NID_set_brand_Novus 642 ++#define OBJ_set_brand_Novus OBJ_set_brand,6011L ++ ++#define SN_des_cdmf "DES-CDMF" ++#define LN_des_cdmf "des-cdmf" ++#define NID_des_cdmf 643 ++#define OBJ_des_cdmf OBJ_rsadsi,3L,10L ++ ++#define SN_rsaOAEPEncryptionSET "rsaOAEPEncryptionSET" ++#define NID_rsaOAEPEncryptionSET 644 ++#define OBJ_rsaOAEPEncryptionSET OBJ_rsadsi,1L,1L,6L ++ ++#define SN_ipsec3 "Oakley-EC2N-3" ++#define LN_ipsec3 "ipsec3" ++#define NID_ipsec3 749 ++ ++#define SN_ipsec4 "Oakley-EC2N-4" ++#define LN_ipsec4 "ipsec4" ++#define NID_ipsec4 750 ++ ++#define SN_whirlpool "whirlpool" ++#define NID_whirlpool 804 ++#define OBJ_whirlpool OBJ_iso,0L,10118L,3L,0L,55L ++ ++#define SN_cryptopro "cryptopro" ++#define NID_cryptopro 805 ++#define OBJ_cryptopro OBJ_member_body,643L,2L,2L ++ ++#define SN_cryptocom "cryptocom" ++#define NID_cryptocom 806 ++#define OBJ_cryptocom OBJ_member_body,643L,2L,9L ++ ++#define SN_id_GostR3411_94_with_GostR3410_2001 "id-GostR3411-94-with-GostR3410-2001" ++#define LN_id_GostR3411_94_with_GostR3410_2001 "GOST R 34.11-94 with GOST R 34.10-2001" ++#define NID_id_GostR3411_94_with_GostR3410_2001 807 ++#define OBJ_id_GostR3411_94_with_GostR3410_2001 OBJ_cryptopro,3L ++ ++#define SN_id_GostR3411_94_with_GostR3410_94 "id-GostR3411-94-with-GostR3410-94" ++#define LN_id_GostR3411_94_with_GostR3410_94 "GOST R 34.11-94 with GOST R 34.10-94" ++#define NID_id_GostR3411_94_with_GostR3410_94 808 ++#define OBJ_id_GostR3411_94_with_GostR3410_94 OBJ_cryptopro,4L ++ ++#define SN_id_GostR3411_94 "md_gost94" ++#define LN_id_GostR3411_94 "GOST R 34.11-94" ++#define NID_id_GostR3411_94 809 ++#define OBJ_id_GostR3411_94 OBJ_cryptopro,9L ++ ++#define SN_id_HMACGostR3411_94 "id-HMACGostR3411-94" ++#define LN_id_HMACGostR3411_94 "HMAC GOST 34.11-94" ++#define NID_id_HMACGostR3411_94 810 ++#define OBJ_id_HMACGostR3411_94 OBJ_cryptopro,10L ++ ++#define SN_id_GostR3410_2001 "gost2001" ++#define LN_id_GostR3410_2001 "GOST R 34.10-2001" ++#define NID_id_GostR3410_2001 811 ++#define OBJ_id_GostR3410_2001 OBJ_cryptopro,19L ++ ++#define SN_id_GostR3410_94 "gost94" ++#define LN_id_GostR3410_94 "GOST R 34.10-94" ++#define NID_id_GostR3410_94 812 ++#define OBJ_id_GostR3410_94 OBJ_cryptopro,20L ++ ++#define SN_id_Gost28147_89 "gost89" ++#define LN_id_Gost28147_89 "GOST 28147-89" ++#define NID_id_Gost28147_89 813 ++#define OBJ_id_Gost28147_89 OBJ_cryptopro,21L ++ ++#define SN_gost89_cnt "gost89-cnt" ++#define NID_gost89_cnt 814 ++ ++#define SN_id_Gost28147_89_MAC "gost-mac" ++#define LN_id_Gost28147_89_MAC "GOST 28147-89 MAC" ++#define NID_id_Gost28147_89_MAC 815 ++#define OBJ_id_Gost28147_89_MAC OBJ_cryptopro,22L ++ ++#define SN_id_GostR3411_94_prf "prf-gostr3411-94" ++#define LN_id_GostR3411_94_prf "GOST R 34.11-94 PRF" ++#define NID_id_GostR3411_94_prf 816 ++#define OBJ_id_GostR3411_94_prf OBJ_cryptopro,23L ++ ++#define SN_id_GostR3410_2001DH "id-GostR3410-2001DH" ++#define LN_id_GostR3410_2001DH "GOST R 34.10-2001 DH" ++#define NID_id_GostR3410_2001DH 817 ++#define OBJ_id_GostR3410_2001DH OBJ_cryptopro,98L ++ ++#define SN_id_GostR3410_94DH "id-GostR3410-94DH" ++#define LN_id_GostR3410_94DH "GOST R 34.10-94 DH" ++#define NID_id_GostR3410_94DH 818 ++#define OBJ_id_GostR3410_94DH OBJ_cryptopro,99L ++ ++#define SN_id_Gost28147_89_CryptoPro_KeyMeshing "id-Gost28147-89-CryptoPro-KeyMeshing" ++#define NID_id_Gost28147_89_CryptoPro_KeyMeshing 819 ++#define OBJ_id_Gost28147_89_CryptoPro_KeyMeshing OBJ_cryptopro,14L,1L ++ ++#define SN_id_Gost28147_89_None_KeyMeshing "id-Gost28147-89-None-KeyMeshing" ++#define NID_id_Gost28147_89_None_KeyMeshing 820 ++#define OBJ_id_Gost28147_89_None_KeyMeshing OBJ_cryptopro,14L,0L ++ ++#define SN_id_GostR3411_94_TestParamSet "id-GostR3411-94-TestParamSet" ++#define NID_id_GostR3411_94_TestParamSet 821 ++#define OBJ_id_GostR3411_94_TestParamSet OBJ_cryptopro,30L,0L ++ ++#define SN_id_GostR3411_94_CryptoProParamSet "id-GostR3411-94-CryptoProParamSet" ++#define NID_id_GostR3411_94_CryptoProParamSet 822 ++#define OBJ_id_GostR3411_94_CryptoProParamSet OBJ_cryptopro,30L,1L ++ ++#define SN_id_Gost28147_89_TestParamSet "id-Gost28147-89-TestParamSet" ++#define NID_id_Gost28147_89_TestParamSet 823 ++#define OBJ_id_Gost28147_89_TestParamSet OBJ_cryptopro,31L,0L ++ ++#define SN_id_Gost28147_89_CryptoPro_A_ParamSet "id-Gost28147-89-CryptoPro-A-ParamSet" ++#define NID_id_Gost28147_89_CryptoPro_A_ParamSet 824 ++#define OBJ_id_Gost28147_89_CryptoPro_A_ParamSet OBJ_cryptopro,31L,1L ++ ++#define SN_id_Gost28147_89_CryptoPro_B_ParamSet "id-Gost28147-89-CryptoPro-B-ParamSet" ++#define NID_id_Gost28147_89_CryptoPro_B_ParamSet 825 ++#define OBJ_id_Gost28147_89_CryptoPro_B_ParamSet OBJ_cryptopro,31L,2L ++ ++#define SN_id_Gost28147_89_CryptoPro_C_ParamSet "id-Gost28147-89-CryptoPro-C-ParamSet" ++#define NID_id_Gost28147_89_CryptoPro_C_ParamSet 826 ++#define OBJ_id_Gost28147_89_CryptoPro_C_ParamSet OBJ_cryptopro,31L,3L ++ ++#define SN_id_Gost28147_89_CryptoPro_D_ParamSet "id-Gost28147-89-CryptoPro-D-ParamSet" ++#define NID_id_Gost28147_89_CryptoPro_D_ParamSet 827 ++#define OBJ_id_Gost28147_89_CryptoPro_D_ParamSet OBJ_cryptopro,31L,4L ++ ++#define SN_id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet "id-Gost28147-89-CryptoPro-Oscar-1-1-ParamSet" ++#define NID_id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet 828 ++#define OBJ_id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet OBJ_cryptopro,31L,5L ++ ++#define SN_id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet "id-Gost28147-89-CryptoPro-Oscar-1-0-ParamSet" ++#define NID_id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet 829 ++#define OBJ_id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet OBJ_cryptopro,31L,6L ++ ++#define SN_id_Gost28147_89_CryptoPro_RIC_1_ParamSet "id-Gost28147-89-CryptoPro-RIC-1-ParamSet" ++#define NID_id_Gost28147_89_CryptoPro_RIC_1_ParamSet 830 ++#define OBJ_id_Gost28147_89_CryptoPro_RIC_1_ParamSet OBJ_cryptopro,31L,7L ++ ++#define SN_id_GostR3410_94_TestParamSet "id-GostR3410-94-TestParamSet" ++#define NID_id_GostR3410_94_TestParamSet 831 ++#define OBJ_id_GostR3410_94_TestParamSet OBJ_cryptopro,32L,0L ++ ++#define SN_id_GostR3410_94_CryptoPro_A_ParamSet "id-GostR3410-94-CryptoPro-A-ParamSet" ++#define NID_id_GostR3410_94_CryptoPro_A_ParamSet 832 ++#define OBJ_id_GostR3410_94_CryptoPro_A_ParamSet OBJ_cryptopro,32L,2L ++ ++#define SN_id_GostR3410_94_CryptoPro_B_ParamSet "id-GostR3410-94-CryptoPro-B-ParamSet" ++#define NID_id_GostR3410_94_CryptoPro_B_ParamSet 833 ++#define OBJ_id_GostR3410_94_CryptoPro_B_ParamSet OBJ_cryptopro,32L,3L ++ ++#define SN_id_GostR3410_94_CryptoPro_C_ParamSet "id-GostR3410-94-CryptoPro-C-ParamSet" ++#define NID_id_GostR3410_94_CryptoPro_C_ParamSet 834 ++#define OBJ_id_GostR3410_94_CryptoPro_C_ParamSet OBJ_cryptopro,32L,4L ++ ++#define SN_id_GostR3410_94_CryptoPro_D_ParamSet "id-GostR3410-94-CryptoPro-D-ParamSet" ++#define NID_id_GostR3410_94_CryptoPro_D_ParamSet 835 ++#define OBJ_id_GostR3410_94_CryptoPro_D_ParamSet OBJ_cryptopro,32L,5L ++ ++#define SN_id_GostR3410_94_CryptoPro_XchA_ParamSet "id-GostR3410-94-CryptoPro-XchA-ParamSet" ++#define NID_id_GostR3410_94_CryptoPro_XchA_ParamSet 836 ++#define OBJ_id_GostR3410_94_CryptoPro_XchA_ParamSet OBJ_cryptopro,33L,1L ++ ++#define SN_id_GostR3410_94_CryptoPro_XchB_ParamSet "id-GostR3410-94-CryptoPro-XchB-ParamSet" ++#define NID_id_GostR3410_94_CryptoPro_XchB_ParamSet 837 ++#define OBJ_id_GostR3410_94_CryptoPro_XchB_ParamSet OBJ_cryptopro,33L,2L ++ ++#define SN_id_GostR3410_94_CryptoPro_XchC_ParamSet "id-GostR3410-94-CryptoPro-XchC-ParamSet" ++#define NID_id_GostR3410_94_CryptoPro_XchC_ParamSet 838 ++#define OBJ_id_GostR3410_94_CryptoPro_XchC_ParamSet OBJ_cryptopro,33L,3L ++ ++#define SN_id_GostR3410_2001_TestParamSet "id-GostR3410-2001-TestParamSet" ++#define NID_id_GostR3410_2001_TestParamSet 839 ++#define OBJ_id_GostR3410_2001_TestParamSet OBJ_cryptopro,35L,0L ++ ++#define SN_id_GostR3410_2001_CryptoPro_A_ParamSet "id-GostR3410-2001-CryptoPro-A-ParamSet" ++#define NID_id_GostR3410_2001_CryptoPro_A_ParamSet 840 ++#define OBJ_id_GostR3410_2001_CryptoPro_A_ParamSet OBJ_cryptopro,35L,1L ++ ++#define SN_id_GostR3410_2001_CryptoPro_B_ParamSet "id-GostR3410-2001-CryptoPro-B-ParamSet" ++#define NID_id_GostR3410_2001_CryptoPro_B_ParamSet 841 ++#define OBJ_id_GostR3410_2001_CryptoPro_B_ParamSet OBJ_cryptopro,35L,2L ++ ++#define SN_id_GostR3410_2001_CryptoPro_C_ParamSet "id-GostR3410-2001-CryptoPro-C-ParamSet" ++#define NID_id_GostR3410_2001_CryptoPro_C_ParamSet 842 ++#define OBJ_id_GostR3410_2001_CryptoPro_C_ParamSet OBJ_cryptopro,35L,3L ++ ++#define SN_id_GostR3410_2001_CryptoPro_XchA_ParamSet "id-GostR3410-2001-CryptoPro-XchA-ParamSet" ++#define NID_id_GostR3410_2001_CryptoPro_XchA_ParamSet 843 ++#define OBJ_id_GostR3410_2001_CryptoPro_XchA_ParamSet OBJ_cryptopro,36L,0L ++ ++#define SN_id_GostR3410_2001_CryptoPro_XchB_ParamSet "id-GostR3410-2001-CryptoPro-XchB-ParamSet" ++#define NID_id_GostR3410_2001_CryptoPro_XchB_ParamSet 844 ++#define OBJ_id_GostR3410_2001_CryptoPro_XchB_ParamSet OBJ_cryptopro,36L,1L ++ ++#define SN_id_GostR3410_94_a "id-GostR3410-94-a" ++#define NID_id_GostR3410_94_a 845 ++#define OBJ_id_GostR3410_94_a OBJ_id_GostR3410_94,1L ++ ++#define SN_id_GostR3410_94_aBis "id-GostR3410-94-aBis" ++#define NID_id_GostR3410_94_aBis 846 ++#define OBJ_id_GostR3410_94_aBis OBJ_id_GostR3410_94,2L ++ ++#define SN_id_GostR3410_94_b "id-GostR3410-94-b" ++#define NID_id_GostR3410_94_b 847 ++#define OBJ_id_GostR3410_94_b OBJ_id_GostR3410_94,3L ++ ++#define SN_id_GostR3410_94_bBis "id-GostR3410-94-bBis" ++#define NID_id_GostR3410_94_bBis 848 ++#define OBJ_id_GostR3410_94_bBis OBJ_id_GostR3410_94,4L ++ ++#define SN_id_Gost28147_89_cc "id-Gost28147-89-cc" ++#define LN_id_Gost28147_89_cc "GOST 28147-89 Cryptocom ParamSet" ++#define NID_id_Gost28147_89_cc 849 ++#define OBJ_id_Gost28147_89_cc OBJ_cryptocom,1L,6L,1L ++ ++#define SN_id_GostR3410_94_cc "gost94cc" ++#define LN_id_GostR3410_94_cc "GOST 34.10-94 Cryptocom" ++#define NID_id_GostR3410_94_cc 850 ++#define OBJ_id_GostR3410_94_cc OBJ_cryptocom,1L,5L,3L ++ ++#define SN_id_GostR3410_2001_cc "gost2001cc" ++#define LN_id_GostR3410_2001_cc "GOST 34.10-2001 Cryptocom" ++#define NID_id_GostR3410_2001_cc 851 ++#define OBJ_id_GostR3410_2001_cc OBJ_cryptocom,1L,5L,4L ++ ++#define SN_id_GostR3411_94_with_GostR3410_94_cc "id-GostR3411-94-with-GostR3410-94-cc" ++#define LN_id_GostR3411_94_with_GostR3410_94_cc "GOST R 34.11-94 with GOST R 34.10-94 Cryptocom" ++#define NID_id_GostR3411_94_with_GostR3410_94_cc 852 ++#define OBJ_id_GostR3411_94_with_GostR3410_94_cc OBJ_cryptocom,1L,3L,3L ++ ++#define SN_id_GostR3411_94_with_GostR3410_2001_cc "id-GostR3411-94-with-GostR3410-2001-cc" ++#define LN_id_GostR3411_94_with_GostR3410_2001_cc "GOST R 34.11-94 with GOST R 34.10-2001 Cryptocom" ++#define NID_id_GostR3411_94_with_GostR3410_2001_cc 853 ++#define OBJ_id_GostR3411_94_with_GostR3410_2001_cc OBJ_cryptocom,1L,3L,4L ++ ++#define SN_id_GostR3410_2001_ParamSet_cc "id-GostR3410-2001-ParamSet-cc" ++#define LN_id_GostR3410_2001_ParamSet_cc "GOST R 3410-2001 Parameter Set Cryptocom" ++#define NID_id_GostR3410_2001_ParamSet_cc 854 ++#define OBJ_id_GostR3410_2001_ParamSet_cc OBJ_cryptocom,1L,8L,1L ++ ++#define SN_camellia_128_cbc "CAMELLIA-128-CBC" ++#define LN_camellia_128_cbc "camellia-128-cbc" ++#define NID_camellia_128_cbc 751 ++#define OBJ_camellia_128_cbc 1L,2L,392L,200011L,61L,1L,1L,1L,2L ++ ++#define SN_camellia_192_cbc "CAMELLIA-192-CBC" ++#define LN_camellia_192_cbc "camellia-192-cbc" ++#define NID_camellia_192_cbc 752 ++#define OBJ_camellia_192_cbc 1L,2L,392L,200011L,61L,1L,1L,1L,3L ++ ++#define SN_camellia_256_cbc "CAMELLIA-256-CBC" ++#define LN_camellia_256_cbc "camellia-256-cbc" ++#define NID_camellia_256_cbc 753 ++#define OBJ_camellia_256_cbc 1L,2L,392L,200011L,61L,1L,1L,1L,4L ++ ++#define OBJ_ntt_ds 0L,3L,4401L,5L ++ ++#define OBJ_camellia OBJ_ntt_ds,3L,1L,9L ++ ++#define SN_camellia_128_ecb "CAMELLIA-128-ECB" ++#define LN_camellia_128_ecb "camellia-128-ecb" ++#define NID_camellia_128_ecb 754 ++#define OBJ_camellia_128_ecb OBJ_camellia,1L ++ ++#define SN_camellia_128_ofb128 "CAMELLIA-128-OFB" ++#define LN_camellia_128_ofb128 "camellia-128-ofb" ++#define NID_camellia_128_ofb128 766 ++#define OBJ_camellia_128_ofb128 OBJ_camellia,3L ++ ++#define SN_camellia_128_cfb128 "CAMELLIA-128-CFB" ++#define LN_camellia_128_cfb128 "camellia-128-cfb" ++#define NID_camellia_128_cfb128 757 ++#define OBJ_camellia_128_cfb128 OBJ_camellia,4L ++ ++#define SN_camellia_192_ecb "CAMELLIA-192-ECB" ++#define LN_camellia_192_ecb "camellia-192-ecb" ++#define NID_camellia_192_ecb 755 ++#define OBJ_camellia_192_ecb OBJ_camellia,21L ++ ++#define SN_camellia_192_ofb128 "CAMELLIA-192-OFB" ++#define LN_camellia_192_ofb128 "camellia-192-ofb" ++#define NID_camellia_192_ofb128 767 ++#define OBJ_camellia_192_ofb128 OBJ_camellia,23L ++ ++#define SN_camellia_192_cfb128 "CAMELLIA-192-CFB" ++#define LN_camellia_192_cfb128 "camellia-192-cfb" ++#define NID_camellia_192_cfb128 758 ++#define OBJ_camellia_192_cfb128 OBJ_camellia,24L ++ ++#define SN_camellia_256_ecb "CAMELLIA-256-ECB" ++#define LN_camellia_256_ecb "camellia-256-ecb" ++#define NID_camellia_256_ecb 756 ++#define OBJ_camellia_256_ecb OBJ_camellia,41L ++ ++#define SN_camellia_256_ofb128 "CAMELLIA-256-OFB" ++#define LN_camellia_256_ofb128 "camellia-256-ofb" ++#define NID_camellia_256_ofb128 768 ++#define OBJ_camellia_256_ofb128 OBJ_camellia,43L ++ ++#define SN_camellia_256_cfb128 "CAMELLIA-256-CFB" ++#define LN_camellia_256_cfb128 "camellia-256-cfb" ++#define NID_camellia_256_cfb128 759 ++#define OBJ_camellia_256_cfb128 OBJ_camellia,44L ++ ++#define SN_camellia_128_cfb1 "CAMELLIA-128-CFB1" ++#define LN_camellia_128_cfb1 "camellia-128-cfb1" ++#define NID_camellia_128_cfb1 760 ++ ++#define SN_camellia_192_cfb1 "CAMELLIA-192-CFB1" ++#define LN_camellia_192_cfb1 "camellia-192-cfb1" ++#define NID_camellia_192_cfb1 761 ++ ++#define SN_camellia_256_cfb1 "CAMELLIA-256-CFB1" ++#define LN_camellia_256_cfb1 "camellia-256-cfb1" ++#define NID_camellia_256_cfb1 762 ++ ++#define SN_camellia_128_cfb8 "CAMELLIA-128-CFB8" ++#define LN_camellia_128_cfb8 "camellia-128-cfb8" ++#define NID_camellia_128_cfb8 763 ++ ++#define SN_camellia_192_cfb8 "CAMELLIA-192-CFB8" ++#define LN_camellia_192_cfb8 "camellia-192-cfb8" ++#define NID_camellia_192_cfb8 764 ++ ++#define SN_camellia_256_cfb8 "CAMELLIA-256-CFB8" ++#define LN_camellia_256_cfb8 "camellia-256-cfb8" ++#define NID_camellia_256_cfb8 765 ++ ++#define SN_kisa "KISA" ++#define LN_kisa "kisa" ++#define NID_kisa 773 ++#define OBJ_kisa OBJ_member_body,410L,200004L ++ ++#define SN_seed_ecb "SEED-ECB" ++#define LN_seed_ecb "seed-ecb" ++#define NID_seed_ecb 776 ++#define OBJ_seed_ecb OBJ_kisa,1L,3L ++ ++#define SN_seed_cbc "SEED-CBC" ++#define LN_seed_cbc "seed-cbc" ++#define NID_seed_cbc 777 ++#define OBJ_seed_cbc OBJ_kisa,1L,4L ++ ++#define SN_seed_cfb128 "SEED-CFB" ++#define LN_seed_cfb128 "seed-cfb" ++#define NID_seed_cfb128 779 ++#define OBJ_seed_cfb128 OBJ_kisa,1L,5L ++ ++#define SN_seed_ofb128 "SEED-OFB" ++#define LN_seed_ofb128 "seed-ofb" ++#define NID_seed_ofb128 778 ++#define OBJ_seed_ofb128 OBJ_kisa,1L,6L ++ ++#define SN_hmac "HMAC" ++#define LN_hmac "hmac" ++#define NID_hmac 855 ++ +diff -urN qt.orig/include/openssl/objects.h qt.patched/include/openssl/objects.h +--- qt.orig/include/openssl/objects.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/objects.h 2010-08-27 12:01:45.415153100 +0200 +@@ -0,0 +1,1138 @@ ++/* crypto/objects/objects.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_OBJECTS_H ++#define HEADER_OBJECTS_H ++ ++#define USE_OBJ_MAC ++ ++#ifdef USE_OBJ_MAC ++#include ++#else ++#define SN_undef "UNDEF" ++#define LN_undef "undefined" ++#define NID_undef 0 ++#define OBJ_undef 0L ++ ++#define SN_Algorithm "Algorithm" ++#define LN_algorithm "algorithm" ++#define NID_algorithm 38 ++#define OBJ_algorithm 1L,3L,14L,3L,2L ++ ++#define LN_rsadsi "rsadsi" ++#define NID_rsadsi 1 ++#define OBJ_rsadsi 1L,2L,840L,113549L ++ ++#define LN_pkcs "pkcs" ++#define NID_pkcs 2 ++#define OBJ_pkcs OBJ_rsadsi,1L ++ ++#define SN_md2 "MD2" ++#define LN_md2 "md2" ++#define NID_md2 3 ++#define OBJ_md2 OBJ_rsadsi,2L,2L ++ ++#define SN_md5 "MD5" ++#define LN_md5 "md5" ++#define NID_md5 4 ++#define OBJ_md5 OBJ_rsadsi,2L,5L ++ ++#define SN_rc4 "RC4" ++#define LN_rc4 "rc4" ++#define NID_rc4 5 ++#define OBJ_rc4 OBJ_rsadsi,3L,4L ++ ++#define LN_rsaEncryption "rsaEncryption" ++#define NID_rsaEncryption 6 ++#define OBJ_rsaEncryption OBJ_pkcs,1L,1L ++ ++#define SN_md2WithRSAEncryption "RSA-MD2" ++#define LN_md2WithRSAEncryption "md2WithRSAEncryption" ++#define NID_md2WithRSAEncryption 7 ++#define OBJ_md2WithRSAEncryption OBJ_pkcs,1L,2L ++ ++#define SN_md5WithRSAEncryption "RSA-MD5" ++#define LN_md5WithRSAEncryption "md5WithRSAEncryption" ++#define NID_md5WithRSAEncryption 8 ++#define OBJ_md5WithRSAEncryption OBJ_pkcs,1L,4L ++ ++#define SN_pbeWithMD2AndDES_CBC "PBE-MD2-DES" ++#define LN_pbeWithMD2AndDES_CBC "pbeWithMD2AndDES-CBC" ++#define NID_pbeWithMD2AndDES_CBC 9 ++#define OBJ_pbeWithMD2AndDES_CBC OBJ_pkcs,5L,1L ++ ++#define SN_pbeWithMD5AndDES_CBC "PBE-MD5-DES" ++#define LN_pbeWithMD5AndDES_CBC "pbeWithMD5AndDES-CBC" ++#define NID_pbeWithMD5AndDES_CBC 10 ++#define OBJ_pbeWithMD5AndDES_CBC OBJ_pkcs,5L,3L ++ ++#define LN_X500 "X500" ++#define NID_X500 11 ++#define OBJ_X500 2L,5L ++ ++#define LN_X509 "X509" ++#define NID_X509 12 ++#define OBJ_X509 OBJ_X500,4L ++ ++#define SN_commonName "CN" ++#define LN_commonName "commonName" ++#define NID_commonName 13 ++#define OBJ_commonName OBJ_X509,3L ++ ++#define SN_countryName "C" ++#define LN_countryName "countryName" ++#define NID_countryName 14 ++#define OBJ_countryName OBJ_X509,6L ++ ++#define SN_localityName "L" ++#define LN_localityName "localityName" ++#define NID_localityName 15 ++#define OBJ_localityName OBJ_X509,7L ++ ++/* Postal Address? PA */ ++ ++/* should be "ST" (rfc1327) but MS uses 'S' */ ++#define SN_stateOrProvinceName "ST" ++#define LN_stateOrProvinceName "stateOrProvinceName" ++#define NID_stateOrProvinceName 16 ++#define OBJ_stateOrProvinceName OBJ_X509,8L ++ ++#define SN_organizationName "O" ++#define LN_organizationName "organizationName" ++#define NID_organizationName 17 ++#define OBJ_organizationName OBJ_X509,10L ++ ++#define SN_organizationalUnitName "OU" ++#define LN_organizationalUnitName "organizationalUnitName" ++#define NID_organizationalUnitName 18 ++#define OBJ_organizationalUnitName OBJ_X509,11L ++ ++#define SN_rsa "RSA" ++#define LN_rsa "rsa" ++#define NID_rsa 19 ++#define OBJ_rsa OBJ_X500,8L,1L,1L ++ ++#define LN_pkcs7 "pkcs7" ++#define NID_pkcs7 20 ++#define OBJ_pkcs7 OBJ_pkcs,7L ++ ++#define LN_pkcs7_data "pkcs7-data" ++#define NID_pkcs7_data 21 ++#define OBJ_pkcs7_data OBJ_pkcs7,1L ++ ++#define LN_pkcs7_signed "pkcs7-signedData" ++#define NID_pkcs7_signed 22 ++#define OBJ_pkcs7_signed OBJ_pkcs7,2L ++ ++#define LN_pkcs7_enveloped "pkcs7-envelopedData" ++#define NID_pkcs7_enveloped 23 ++#define OBJ_pkcs7_enveloped OBJ_pkcs7,3L ++ ++#define LN_pkcs7_signedAndEnveloped "pkcs7-signedAndEnvelopedData" ++#define NID_pkcs7_signedAndEnveloped 24 ++#define OBJ_pkcs7_signedAndEnveloped OBJ_pkcs7,4L ++ ++#define LN_pkcs7_digest "pkcs7-digestData" ++#define NID_pkcs7_digest 25 ++#define OBJ_pkcs7_digest OBJ_pkcs7,5L ++ ++#define LN_pkcs7_encrypted "pkcs7-encryptedData" ++#define NID_pkcs7_encrypted 26 ++#define OBJ_pkcs7_encrypted OBJ_pkcs7,6L ++ ++#define LN_pkcs3 "pkcs3" ++#define NID_pkcs3 27 ++#define OBJ_pkcs3 OBJ_pkcs,3L ++ ++#define LN_dhKeyAgreement "dhKeyAgreement" ++#define NID_dhKeyAgreement 28 ++#define OBJ_dhKeyAgreement OBJ_pkcs3,1L ++ ++#define SN_des_ecb "DES-ECB" ++#define LN_des_ecb "des-ecb" ++#define NID_des_ecb 29 ++#define OBJ_des_ecb OBJ_algorithm,6L ++ ++#define SN_des_cfb64 "DES-CFB" ++#define LN_des_cfb64 "des-cfb" ++#define NID_des_cfb64 30 ++/* IV + num */ ++#define OBJ_des_cfb64 OBJ_algorithm,9L ++ ++#define SN_des_cbc "DES-CBC" ++#define LN_des_cbc "des-cbc" ++#define NID_des_cbc 31 ++/* IV */ ++#define OBJ_des_cbc OBJ_algorithm,7L ++ ++#define SN_des_ede "DES-EDE" ++#define LN_des_ede "des-ede" ++#define NID_des_ede 32 ++/* ?? */ ++#define OBJ_des_ede OBJ_algorithm,17L ++ ++#define SN_des_ede3 "DES-EDE3" ++#define LN_des_ede3 "des-ede3" ++#define NID_des_ede3 33 ++ ++#define SN_idea_cbc "IDEA-CBC" ++#define LN_idea_cbc "idea-cbc" ++#define NID_idea_cbc 34 ++#define OBJ_idea_cbc 1L,3L,6L,1L,4L,1L,188L,7L,1L,1L,2L ++ ++#define SN_idea_cfb64 "IDEA-CFB" ++#define LN_idea_cfb64 "idea-cfb" ++#define NID_idea_cfb64 35 ++ ++#define SN_idea_ecb "IDEA-ECB" ++#define LN_idea_ecb "idea-ecb" ++#define NID_idea_ecb 36 ++ ++#define SN_rc2_cbc "RC2-CBC" ++#define LN_rc2_cbc "rc2-cbc" ++#define NID_rc2_cbc 37 ++#define OBJ_rc2_cbc OBJ_rsadsi,3L,2L ++ ++#define SN_rc2_ecb "RC2-ECB" ++#define LN_rc2_ecb "rc2-ecb" ++#define NID_rc2_ecb 38 ++ ++#define SN_rc2_cfb64 "RC2-CFB" ++#define LN_rc2_cfb64 "rc2-cfb" ++#define NID_rc2_cfb64 39 ++ ++#define SN_rc2_ofb64 "RC2-OFB" ++#define LN_rc2_ofb64 "rc2-ofb" ++#define NID_rc2_ofb64 40 ++ ++#define SN_sha "SHA" ++#define LN_sha "sha" ++#define NID_sha 41 ++#define OBJ_sha OBJ_algorithm,18L ++ ++#define SN_shaWithRSAEncryption "RSA-SHA" ++#define LN_shaWithRSAEncryption "shaWithRSAEncryption" ++#define NID_shaWithRSAEncryption 42 ++#define OBJ_shaWithRSAEncryption OBJ_algorithm,15L ++ ++#define SN_des_ede_cbc "DES-EDE-CBC" ++#define LN_des_ede_cbc "des-ede-cbc" ++#define NID_des_ede_cbc 43 ++ ++#define SN_des_ede3_cbc "DES-EDE3-CBC" ++#define LN_des_ede3_cbc "des-ede3-cbc" ++#define NID_des_ede3_cbc 44 ++#define OBJ_des_ede3_cbc OBJ_rsadsi,3L,7L ++ ++#define SN_des_ofb64 "DES-OFB" ++#define LN_des_ofb64 "des-ofb" ++#define NID_des_ofb64 45 ++#define OBJ_des_ofb64 OBJ_algorithm,8L ++ ++#define SN_idea_ofb64 "IDEA-OFB" ++#define LN_idea_ofb64 "idea-ofb" ++#define NID_idea_ofb64 46 ++ ++#define LN_pkcs9 "pkcs9" ++#define NID_pkcs9 47 ++#define OBJ_pkcs9 OBJ_pkcs,9L ++ ++#define SN_pkcs9_emailAddress "Email" ++#define LN_pkcs9_emailAddress "emailAddress" ++#define NID_pkcs9_emailAddress 48 ++#define OBJ_pkcs9_emailAddress OBJ_pkcs9,1L ++ ++#define LN_pkcs9_unstructuredName "unstructuredName" ++#define NID_pkcs9_unstructuredName 49 ++#define OBJ_pkcs9_unstructuredName OBJ_pkcs9,2L ++ ++#define LN_pkcs9_contentType "contentType" ++#define NID_pkcs9_contentType 50 ++#define OBJ_pkcs9_contentType OBJ_pkcs9,3L ++ ++#define LN_pkcs9_messageDigest "messageDigest" ++#define NID_pkcs9_messageDigest 51 ++#define OBJ_pkcs9_messageDigest OBJ_pkcs9,4L ++ ++#define LN_pkcs9_signingTime "signingTime" ++#define NID_pkcs9_signingTime 52 ++#define OBJ_pkcs9_signingTime OBJ_pkcs9,5L ++ ++#define LN_pkcs9_countersignature "countersignature" ++#define NID_pkcs9_countersignature 53 ++#define OBJ_pkcs9_countersignature OBJ_pkcs9,6L ++ ++#define LN_pkcs9_challengePassword "challengePassword" ++#define NID_pkcs9_challengePassword 54 ++#define OBJ_pkcs9_challengePassword OBJ_pkcs9,7L ++ ++#define LN_pkcs9_unstructuredAddress "unstructuredAddress" ++#define NID_pkcs9_unstructuredAddress 55 ++#define OBJ_pkcs9_unstructuredAddress OBJ_pkcs9,8L ++ ++#define LN_pkcs9_extCertAttributes "extendedCertificateAttributes" ++#define NID_pkcs9_extCertAttributes 56 ++#define OBJ_pkcs9_extCertAttributes OBJ_pkcs9,9L ++ ++#define SN_netscape "Netscape" ++#define LN_netscape "Netscape Communications Corp." ++#define NID_netscape 57 ++#define OBJ_netscape 2L,16L,840L,1L,113730L ++ ++#define SN_netscape_cert_extension "nsCertExt" ++#define LN_netscape_cert_extension "Netscape Certificate Extension" ++#define NID_netscape_cert_extension 58 ++#define OBJ_netscape_cert_extension OBJ_netscape,1L ++ ++#define SN_netscape_data_type "nsDataType" ++#define LN_netscape_data_type "Netscape Data Type" ++#define NID_netscape_data_type 59 ++#define OBJ_netscape_data_type OBJ_netscape,2L ++ ++#define SN_des_ede_cfb64 "DES-EDE-CFB" ++#define LN_des_ede_cfb64 "des-ede-cfb" ++#define NID_des_ede_cfb64 60 ++ ++#define SN_des_ede3_cfb64 "DES-EDE3-CFB" ++#define LN_des_ede3_cfb64 "des-ede3-cfb" ++#define NID_des_ede3_cfb64 61 ++ ++#define SN_des_ede_ofb64 "DES-EDE-OFB" ++#define LN_des_ede_ofb64 "des-ede-ofb" ++#define NID_des_ede_ofb64 62 ++ ++#define SN_des_ede3_ofb64 "DES-EDE3-OFB" ++#define LN_des_ede3_ofb64 "des-ede3-ofb" ++#define NID_des_ede3_ofb64 63 ++ ++/* I'm not sure about the object ID */ ++#define SN_sha1 "SHA1" ++#define LN_sha1 "sha1" ++#define NID_sha1 64 ++#define OBJ_sha1 OBJ_algorithm,26L ++/* 28 Jun 1996 - eay */ ++/* #define OBJ_sha1 1L,3L,14L,2L,26L,05L <- wrong */ ++ ++#define SN_sha1WithRSAEncryption "RSA-SHA1" ++#define LN_sha1WithRSAEncryption "sha1WithRSAEncryption" ++#define NID_sha1WithRSAEncryption 65 ++#define OBJ_sha1WithRSAEncryption OBJ_pkcs,1L,5L ++ ++#define SN_dsaWithSHA "DSA-SHA" ++#define LN_dsaWithSHA "dsaWithSHA" ++#define NID_dsaWithSHA 66 ++#define OBJ_dsaWithSHA OBJ_algorithm,13L ++ ++#define SN_dsa_2 "DSA-old" ++#define LN_dsa_2 "dsaEncryption-old" ++#define NID_dsa_2 67 ++#define OBJ_dsa_2 OBJ_algorithm,12L ++ ++/* proposed by microsoft to RSA */ ++#define SN_pbeWithSHA1AndRC2_CBC "PBE-SHA1-RC2-64" ++#define LN_pbeWithSHA1AndRC2_CBC "pbeWithSHA1AndRC2-CBC" ++#define NID_pbeWithSHA1AndRC2_CBC 68 ++#define OBJ_pbeWithSHA1AndRC2_CBC OBJ_pkcs,5L,11L ++ ++/* proposed by microsoft to RSA as pbeWithSHA1AndRC4: it is now ++ * defined explicitly in PKCS#5 v2.0 as id-PBKDF2 which is something ++ * completely different. ++ */ ++#define LN_id_pbkdf2 "PBKDF2" ++#define NID_id_pbkdf2 69 ++#define OBJ_id_pbkdf2 OBJ_pkcs,5L,12L ++ ++#define SN_dsaWithSHA1_2 "DSA-SHA1-old" ++#define LN_dsaWithSHA1_2 "dsaWithSHA1-old" ++#define NID_dsaWithSHA1_2 70 ++/* Got this one from 'sdn706r20.pdf' which is actually an NSA document :-) */ ++#define OBJ_dsaWithSHA1_2 OBJ_algorithm,27L ++ ++#define SN_netscape_cert_type "nsCertType" ++#define LN_netscape_cert_type "Netscape Cert Type" ++#define NID_netscape_cert_type 71 ++#define OBJ_netscape_cert_type OBJ_netscape_cert_extension,1L ++ ++#define SN_netscape_base_url "nsBaseUrl" ++#define LN_netscape_base_url "Netscape Base Url" ++#define NID_netscape_base_url 72 ++#define OBJ_netscape_base_url OBJ_netscape_cert_extension,2L ++ ++#define SN_netscape_revocation_url "nsRevocationUrl" ++#define LN_netscape_revocation_url "Netscape Revocation Url" ++#define NID_netscape_revocation_url 73 ++#define OBJ_netscape_revocation_url OBJ_netscape_cert_extension,3L ++ ++#define SN_netscape_ca_revocation_url "nsCaRevocationUrl" ++#define LN_netscape_ca_revocation_url "Netscape CA Revocation Url" ++#define NID_netscape_ca_revocation_url 74 ++#define OBJ_netscape_ca_revocation_url OBJ_netscape_cert_extension,4L ++ ++#define SN_netscape_renewal_url "nsRenewalUrl" ++#define LN_netscape_renewal_url "Netscape Renewal Url" ++#define NID_netscape_renewal_url 75 ++#define OBJ_netscape_renewal_url OBJ_netscape_cert_extension,7L ++ ++#define SN_netscape_ca_policy_url "nsCaPolicyUrl" ++#define LN_netscape_ca_policy_url "Netscape CA Policy Url" ++#define NID_netscape_ca_policy_url 76 ++#define OBJ_netscape_ca_policy_url OBJ_netscape_cert_extension,8L ++ ++#define SN_netscape_ssl_server_name "nsSslServerName" ++#define LN_netscape_ssl_server_name "Netscape SSL Server Name" ++#define NID_netscape_ssl_server_name 77 ++#define OBJ_netscape_ssl_server_name OBJ_netscape_cert_extension,12L ++ ++#define SN_netscape_comment "nsComment" ++#define LN_netscape_comment "Netscape Comment" ++#define NID_netscape_comment 78 ++#define OBJ_netscape_comment OBJ_netscape_cert_extension,13L ++ ++#define SN_netscape_cert_sequence "nsCertSequence" ++#define LN_netscape_cert_sequence "Netscape Certificate Sequence" ++#define NID_netscape_cert_sequence 79 ++#define OBJ_netscape_cert_sequence OBJ_netscape_data_type,5L ++ ++#define SN_desx_cbc "DESX-CBC" ++#define LN_desx_cbc "desx-cbc" ++#define NID_desx_cbc 80 ++ ++#define SN_id_ce "id-ce" ++#define NID_id_ce 81 ++#define OBJ_id_ce 2L,5L,29L ++ ++#define SN_subject_key_identifier "subjectKeyIdentifier" ++#define LN_subject_key_identifier "X509v3 Subject Key Identifier" ++#define NID_subject_key_identifier 82 ++#define OBJ_subject_key_identifier OBJ_id_ce,14L ++ ++#define SN_key_usage "keyUsage" ++#define LN_key_usage "X509v3 Key Usage" ++#define NID_key_usage 83 ++#define OBJ_key_usage OBJ_id_ce,15L ++ ++#define SN_private_key_usage_period "privateKeyUsagePeriod" ++#define LN_private_key_usage_period "X509v3 Private Key Usage Period" ++#define NID_private_key_usage_period 84 ++#define OBJ_private_key_usage_period OBJ_id_ce,16L ++ ++#define SN_subject_alt_name "subjectAltName" ++#define LN_subject_alt_name "X509v3 Subject Alternative Name" ++#define NID_subject_alt_name 85 ++#define OBJ_subject_alt_name OBJ_id_ce,17L ++ ++#define SN_issuer_alt_name "issuerAltName" ++#define LN_issuer_alt_name "X509v3 Issuer Alternative Name" ++#define NID_issuer_alt_name 86 ++#define OBJ_issuer_alt_name OBJ_id_ce,18L ++ ++#define SN_basic_constraints "basicConstraints" ++#define LN_basic_constraints "X509v3 Basic Constraints" ++#define NID_basic_constraints 87 ++#define OBJ_basic_constraints OBJ_id_ce,19L ++ ++#define SN_crl_number "crlNumber" ++#define LN_crl_number "X509v3 CRL Number" ++#define NID_crl_number 88 ++#define OBJ_crl_number OBJ_id_ce,20L ++ ++#define SN_certificate_policies "certificatePolicies" ++#define LN_certificate_policies "X509v3 Certificate Policies" ++#define NID_certificate_policies 89 ++#define OBJ_certificate_policies OBJ_id_ce,32L ++ ++#define SN_authority_key_identifier "authorityKeyIdentifier" ++#define LN_authority_key_identifier "X509v3 Authority Key Identifier" ++#define NID_authority_key_identifier 90 ++#define OBJ_authority_key_identifier OBJ_id_ce,35L ++ ++#define SN_bf_cbc "BF-CBC" ++#define LN_bf_cbc "bf-cbc" ++#define NID_bf_cbc 91 ++#define OBJ_bf_cbc 1L,3L,6L,1L,4L,1L,3029L,1L,2L ++ ++#define SN_bf_ecb "BF-ECB" ++#define LN_bf_ecb "bf-ecb" ++#define NID_bf_ecb 92 ++ ++#define SN_bf_cfb64 "BF-CFB" ++#define LN_bf_cfb64 "bf-cfb" ++#define NID_bf_cfb64 93 ++ ++#define SN_bf_ofb64 "BF-OFB" ++#define LN_bf_ofb64 "bf-ofb" ++#define NID_bf_ofb64 94 ++ ++#define SN_mdc2 "MDC2" ++#define LN_mdc2 "mdc2" ++#define NID_mdc2 95 ++#define OBJ_mdc2 2L,5L,8L,3L,101L ++/* An alternative? 1L,3L,14L,3L,2L,19L */ ++ ++#define SN_mdc2WithRSA "RSA-MDC2" ++#define LN_mdc2WithRSA "mdc2withRSA" ++#define NID_mdc2WithRSA 96 ++#define OBJ_mdc2WithRSA 2L,5L,8L,3L,100L ++ ++#define SN_rc4_40 "RC4-40" ++#define LN_rc4_40 "rc4-40" ++#define NID_rc4_40 97 ++ ++#define SN_rc2_40_cbc "RC2-40-CBC" ++#define LN_rc2_40_cbc "rc2-40-cbc" ++#define NID_rc2_40_cbc 98 ++ ++#define SN_givenName "G" ++#define LN_givenName "givenName" ++#define NID_givenName 99 ++#define OBJ_givenName OBJ_X509,42L ++ ++#define SN_surname "S" ++#define LN_surname "surname" ++#define NID_surname 100 ++#define OBJ_surname OBJ_X509,4L ++ ++#define SN_initials "I" ++#define LN_initials "initials" ++#define NID_initials 101 ++#define OBJ_initials OBJ_X509,43L ++ ++#define SN_uniqueIdentifier "UID" ++#define LN_uniqueIdentifier "uniqueIdentifier" ++#define NID_uniqueIdentifier 102 ++#define OBJ_uniqueIdentifier OBJ_X509,45L ++ ++#define SN_crl_distribution_points "crlDistributionPoints" ++#define LN_crl_distribution_points "X509v3 CRL Distribution Points" ++#define NID_crl_distribution_points 103 ++#define OBJ_crl_distribution_points OBJ_id_ce,31L ++ ++#define SN_md5WithRSA "RSA-NP-MD5" ++#define LN_md5WithRSA "md5WithRSA" ++#define NID_md5WithRSA 104 ++#define OBJ_md5WithRSA OBJ_algorithm,3L ++ ++#define SN_serialNumber "SN" ++#define LN_serialNumber "serialNumber" ++#define NID_serialNumber 105 ++#define OBJ_serialNumber OBJ_X509,5L ++ ++#define SN_title "T" ++#define LN_title "title" ++#define NID_title 106 ++#define OBJ_title OBJ_X509,12L ++ ++#define SN_description "D" ++#define LN_description "description" ++#define NID_description 107 ++#define OBJ_description OBJ_X509,13L ++ ++/* CAST5 is CAST-128, I'm just sticking with the documentation */ ++#define SN_cast5_cbc "CAST5-CBC" ++#define LN_cast5_cbc "cast5-cbc" ++#define NID_cast5_cbc 108 ++#define OBJ_cast5_cbc 1L,2L,840L,113533L,7L,66L,10L ++ ++#define SN_cast5_ecb "CAST5-ECB" ++#define LN_cast5_ecb "cast5-ecb" ++#define NID_cast5_ecb 109 ++ ++#define SN_cast5_cfb64 "CAST5-CFB" ++#define LN_cast5_cfb64 "cast5-cfb" ++#define NID_cast5_cfb64 110 ++ ++#define SN_cast5_ofb64 "CAST5-OFB" ++#define LN_cast5_ofb64 "cast5-ofb" ++#define NID_cast5_ofb64 111 ++ ++#define LN_pbeWithMD5AndCast5_CBC "pbeWithMD5AndCast5CBC" ++#define NID_pbeWithMD5AndCast5_CBC 112 ++#define OBJ_pbeWithMD5AndCast5_CBC 1L,2L,840L,113533L,7L,66L,12L ++ ++/* This is one sun will soon be using :-( ++ * id-dsa-with-sha1 ID ::= { ++ * iso(1) member-body(2) us(840) x9-57 (10040) x9cm(4) 3 } ++ */ ++#define SN_dsaWithSHA1 "DSA-SHA1" ++#define LN_dsaWithSHA1 "dsaWithSHA1" ++#define NID_dsaWithSHA1 113 ++#define OBJ_dsaWithSHA1 1L,2L,840L,10040L,4L,3L ++ ++#define NID_md5_sha1 114 ++#define SN_md5_sha1 "MD5-SHA1" ++#define LN_md5_sha1 "md5-sha1" ++ ++#define SN_sha1WithRSA "RSA-SHA1-2" ++#define LN_sha1WithRSA "sha1WithRSA" ++#define NID_sha1WithRSA 115 ++#define OBJ_sha1WithRSA OBJ_algorithm,29L ++ ++#define SN_dsa "DSA" ++#define LN_dsa "dsaEncryption" ++#define NID_dsa 116 ++#define OBJ_dsa 1L,2L,840L,10040L,4L,1L ++ ++#define SN_ripemd160 "RIPEMD160" ++#define LN_ripemd160 "ripemd160" ++#define NID_ripemd160 117 ++#define OBJ_ripemd160 1L,3L,36L,3L,2L,1L ++ ++/* The name should actually be rsaSignatureWithripemd160, but I'm going ++ * to continue using the convention I'm using with the other ciphers */ ++#define SN_ripemd160WithRSA "RSA-RIPEMD160" ++#define LN_ripemd160WithRSA "ripemd160WithRSA" ++#define NID_ripemd160WithRSA 119 ++#define OBJ_ripemd160WithRSA 1L,3L,36L,3L,3L,1L,2L ++ ++/* Taken from rfc2040 ++ * RC5_CBC_Parameters ::= SEQUENCE { ++ * version INTEGER (v1_0(16)), ++ * rounds INTEGER (8..127), ++ * blockSizeInBits INTEGER (64, 128), ++ * iv OCTET STRING OPTIONAL ++ * } ++ */ ++#define SN_rc5_cbc "RC5-CBC" ++#define LN_rc5_cbc "rc5-cbc" ++#define NID_rc5_cbc 120 ++#define OBJ_rc5_cbc OBJ_rsadsi,3L,8L ++ ++#define SN_rc5_ecb "RC5-ECB" ++#define LN_rc5_ecb "rc5-ecb" ++#define NID_rc5_ecb 121 ++ ++#define SN_rc5_cfb64 "RC5-CFB" ++#define LN_rc5_cfb64 "rc5-cfb" ++#define NID_rc5_cfb64 122 ++ ++#define SN_rc5_ofb64 "RC5-OFB" ++#define LN_rc5_ofb64 "rc5-ofb" ++#define NID_rc5_ofb64 123 ++ ++#define SN_rle_compression "RLE" ++#define LN_rle_compression "run length compression" ++#define NID_rle_compression 124 ++#define OBJ_rle_compression 1L,1L,1L,1L,666L,1L ++ ++#define SN_zlib_compression "ZLIB" ++#define LN_zlib_compression "zlib compression" ++#define NID_zlib_compression 125 ++#define OBJ_zlib_compression 1L,1L,1L,1L,666L,2L ++ ++#define SN_ext_key_usage "extendedKeyUsage" ++#define LN_ext_key_usage "X509v3 Extended Key Usage" ++#define NID_ext_key_usage 126 ++#define OBJ_ext_key_usage OBJ_id_ce,37 ++ ++#define SN_id_pkix "PKIX" ++#define NID_id_pkix 127 ++#define OBJ_id_pkix 1L,3L,6L,1L,5L,5L,7L ++ ++#define SN_id_kp "id-kp" ++#define NID_id_kp 128 ++#define OBJ_id_kp OBJ_id_pkix,3L ++ ++/* PKIX extended key usage OIDs */ ++ ++#define SN_server_auth "serverAuth" ++#define LN_server_auth "TLS Web Server Authentication" ++#define NID_server_auth 129 ++#define OBJ_server_auth OBJ_id_kp,1L ++ ++#define SN_client_auth "clientAuth" ++#define LN_client_auth "TLS Web Client Authentication" ++#define NID_client_auth 130 ++#define OBJ_client_auth OBJ_id_kp,2L ++ ++#define SN_code_sign "codeSigning" ++#define LN_code_sign "Code Signing" ++#define NID_code_sign 131 ++#define OBJ_code_sign OBJ_id_kp,3L ++ ++#define SN_email_protect "emailProtection" ++#define LN_email_protect "E-mail Protection" ++#define NID_email_protect 132 ++#define OBJ_email_protect OBJ_id_kp,4L ++ ++#define SN_time_stamp "timeStamping" ++#define LN_time_stamp "Time Stamping" ++#define NID_time_stamp 133 ++#define OBJ_time_stamp OBJ_id_kp,8L ++ ++/* Additional extended key usage OIDs: Microsoft */ ++ ++#define SN_ms_code_ind "msCodeInd" ++#define LN_ms_code_ind "Microsoft Individual Code Signing" ++#define NID_ms_code_ind 134 ++#define OBJ_ms_code_ind 1L,3L,6L,1L,4L,1L,311L,2L,1L,21L ++ ++#define SN_ms_code_com "msCodeCom" ++#define LN_ms_code_com "Microsoft Commercial Code Signing" ++#define NID_ms_code_com 135 ++#define OBJ_ms_code_com 1L,3L,6L,1L,4L,1L,311L,2L,1L,22L ++ ++#define SN_ms_ctl_sign "msCTLSign" ++#define LN_ms_ctl_sign "Microsoft Trust List Signing" ++#define NID_ms_ctl_sign 136 ++#define OBJ_ms_ctl_sign 1L,3L,6L,1L,4L,1L,311L,10L,3L,1L ++ ++#define SN_ms_sgc "msSGC" ++#define LN_ms_sgc "Microsoft Server Gated Crypto" ++#define NID_ms_sgc 137 ++#define OBJ_ms_sgc 1L,3L,6L,1L,4L,1L,311L,10L,3L,3L ++ ++#define SN_ms_efs "msEFS" ++#define LN_ms_efs "Microsoft Encrypted File System" ++#define NID_ms_efs 138 ++#define OBJ_ms_efs 1L,3L,6L,1L,4L,1L,311L,10L,3L,4L ++ ++/* Additional usage: Netscape */ ++ ++#define SN_ns_sgc "nsSGC" ++#define LN_ns_sgc "Netscape Server Gated Crypto" ++#define NID_ns_sgc 139 ++#define OBJ_ns_sgc OBJ_netscape,4L,1L ++ ++#define SN_delta_crl "deltaCRL" ++#define LN_delta_crl "X509v3 Delta CRL Indicator" ++#define NID_delta_crl 140 ++#define OBJ_delta_crl OBJ_id_ce,27L ++ ++#define SN_crl_reason "CRLReason" ++#define LN_crl_reason "CRL Reason Code" ++#define NID_crl_reason 141 ++#define OBJ_crl_reason OBJ_id_ce,21L ++ ++#define SN_invalidity_date "invalidityDate" ++#define LN_invalidity_date "Invalidity Date" ++#define NID_invalidity_date 142 ++#define OBJ_invalidity_date OBJ_id_ce,24L ++ ++#define SN_sxnet "SXNetID" ++#define LN_sxnet "Strong Extranet ID" ++#define NID_sxnet 143 ++#define OBJ_sxnet 1L,3L,101L,1L,4L,1L ++ ++/* PKCS12 and related OBJECT IDENTIFIERS */ ++ ++#define OBJ_pkcs12 OBJ_pkcs,12L ++#define OBJ_pkcs12_pbeids OBJ_pkcs12, 1 ++ ++#define SN_pbe_WithSHA1And128BitRC4 "PBE-SHA1-RC4-128" ++#define LN_pbe_WithSHA1And128BitRC4 "pbeWithSHA1And128BitRC4" ++#define NID_pbe_WithSHA1And128BitRC4 144 ++#define OBJ_pbe_WithSHA1And128BitRC4 OBJ_pkcs12_pbeids, 1L ++ ++#define SN_pbe_WithSHA1And40BitRC4 "PBE-SHA1-RC4-40" ++#define LN_pbe_WithSHA1And40BitRC4 "pbeWithSHA1And40BitRC4" ++#define NID_pbe_WithSHA1And40BitRC4 145 ++#define OBJ_pbe_WithSHA1And40BitRC4 OBJ_pkcs12_pbeids, 2L ++ ++#define SN_pbe_WithSHA1And3_Key_TripleDES_CBC "PBE-SHA1-3DES" ++#define LN_pbe_WithSHA1And3_Key_TripleDES_CBC "pbeWithSHA1And3-KeyTripleDES-CBC" ++#define NID_pbe_WithSHA1And3_Key_TripleDES_CBC 146 ++#define OBJ_pbe_WithSHA1And3_Key_TripleDES_CBC OBJ_pkcs12_pbeids, 3L ++ ++#define SN_pbe_WithSHA1And2_Key_TripleDES_CBC "PBE-SHA1-2DES" ++#define LN_pbe_WithSHA1And2_Key_TripleDES_CBC "pbeWithSHA1And2-KeyTripleDES-CBC" ++#define NID_pbe_WithSHA1And2_Key_TripleDES_CBC 147 ++#define OBJ_pbe_WithSHA1And2_Key_TripleDES_CBC OBJ_pkcs12_pbeids, 4L ++ ++#define SN_pbe_WithSHA1And128BitRC2_CBC "PBE-SHA1-RC2-128" ++#define LN_pbe_WithSHA1And128BitRC2_CBC "pbeWithSHA1And128BitRC2-CBC" ++#define NID_pbe_WithSHA1And128BitRC2_CBC 148 ++#define OBJ_pbe_WithSHA1And128BitRC2_CBC OBJ_pkcs12_pbeids, 5L ++ ++#define SN_pbe_WithSHA1And40BitRC2_CBC "PBE-SHA1-RC2-40" ++#define LN_pbe_WithSHA1And40BitRC2_CBC "pbeWithSHA1And40BitRC2-CBC" ++#define NID_pbe_WithSHA1And40BitRC2_CBC 149 ++#define OBJ_pbe_WithSHA1And40BitRC2_CBC OBJ_pkcs12_pbeids, 6L ++ ++#define OBJ_pkcs12_Version1 OBJ_pkcs12, 10L ++ ++#define OBJ_pkcs12_BagIds OBJ_pkcs12_Version1, 1L ++ ++#define LN_keyBag "keyBag" ++#define NID_keyBag 150 ++#define OBJ_keyBag OBJ_pkcs12_BagIds, 1L ++ ++#define LN_pkcs8ShroudedKeyBag "pkcs8ShroudedKeyBag" ++#define NID_pkcs8ShroudedKeyBag 151 ++#define OBJ_pkcs8ShroudedKeyBag OBJ_pkcs12_BagIds, 2L ++ ++#define LN_certBag "certBag" ++#define NID_certBag 152 ++#define OBJ_certBag OBJ_pkcs12_BagIds, 3L ++ ++#define LN_crlBag "crlBag" ++#define NID_crlBag 153 ++#define OBJ_crlBag OBJ_pkcs12_BagIds, 4L ++ ++#define LN_secretBag "secretBag" ++#define NID_secretBag 154 ++#define OBJ_secretBag OBJ_pkcs12_BagIds, 5L ++ ++#define LN_safeContentsBag "safeContentsBag" ++#define NID_safeContentsBag 155 ++#define OBJ_safeContentsBag OBJ_pkcs12_BagIds, 6L ++ ++#define LN_friendlyName "friendlyName" ++#define NID_friendlyName 156 ++#define OBJ_friendlyName OBJ_pkcs9, 20L ++ ++#define LN_localKeyID "localKeyID" ++#define NID_localKeyID 157 ++#define OBJ_localKeyID OBJ_pkcs9, 21L ++ ++#define OBJ_certTypes OBJ_pkcs9, 22L ++ ++#define LN_x509Certificate "x509Certificate" ++#define NID_x509Certificate 158 ++#define OBJ_x509Certificate OBJ_certTypes, 1L ++ ++#define LN_sdsiCertificate "sdsiCertificate" ++#define NID_sdsiCertificate 159 ++#define OBJ_sdsiCertificate OBJ_certTypes, 2L ++ ++#define OBJ_crlTypes OBJ_pkcs9, 23L ++ ++#define LN_x509Crl "x509Crl" ++#define NID_x509Crl 160 ++#define OBJ_x509Crl OBJ_crlTypes, 1L ++ ++/* PKCS#5 v2 OIDs */ ++ ++#define LN_pbes2 "PBES2" ++#define NID_pbes2 161 ++#define OBJ_pbes2 OBJ_pkcs,5L,13L ++ ++#define LN_pbmac1 "PBMAC1" ++#define NID_pbmac1 162 ++#define OBJ_pbmac1 OBJ_pkcs,5L,14L ++ ++#define LN_hmacWithSHA1 "hmacWithSHA1" ++#define NID_hmacWithSHA1 163 ++#define OBJ_hmacWithSHA1 OBJ_rsadsi,2L,7L ++ ++/* Policy Qualifier Ids */ ++ ++#define LN_id_qt_cps "Policy Qualifier CPS" ++#define SN_id_qt_cps "id-qt-cps" ++#define NID_id_qt_cps 164 ++#define OBJ_id_qt_cps OBJ_id_pkix,2L,1L ++ ++#define LN_id_qt_unotice "Policy Qualifier User Notice" ++#define SN_id_qt_unotice "id-qt-unotice" ++#define NID_id_qt_unotice 165 ++#define OBJ_id_qt_unotice OBJ_id_pkix,2L,2L ++ ++#define SN_rc2_64_cbc "RC2-64-CBC" ++#define LN_rc2_64_cbc "rc2-64-cbc" ++#define NID_rc2_64_cbc 166 ++ ++#define SN_SMIMECapabilities "SMIME-CAPS" ++#define LN_SMIMECapabilities "S/MIME Capabilities" ++#define NID_SMIMECapabilities 167 ++#define OBJ_SMIMECapabilities OBJ_pkcs9,15L ++ ++#define SN_pbeWithMD2AndRC2_CBC "PBE-MD2-RC2-64" ++#define LN_pbeWithMD2AndRC2_CBC "pbeWithMD2AndRC2-CBC" ++#define NID_pbeWithMD2AndRC2_CBC 168 ++#define OBJ_pbeWithMD2AndRC2_CBC OBJ_pkcs,5L,4L ++ ++#define SN_pbeWithMD5AndRC2_CBC "PBE-MD5-RC2-64" ++#define LN_pbeWithMD5AndRC2_CBC "pbeWithMD5AndRC2-CBC" ++#define NID_pbeWithMD5AndRC2_CBC 169 ++#define OBJ_pbeWithMD5AndRC2_CBC OBJ_pkcs,5L,6L ++ ++#define SN_pbeWithSHA1AndDES_CBC "PBE-SHA1-DES" ++#define LN_pbeWithSHA1AndDES_CBC "pbeWithSHA1AndDES-CBC" ++#define NID_pbeWithSHA1AndDES_CBC 170 ++#define OBJ_pbeWithSHA1AndDES_CBC OBJ_pkcs,5L,10L ++ ++/* Extension request OIDs */ ++ ++#define LN_ms_ext_req "Microsoft Extension Request" ++#define SN_ms_ext_req "msExtReq" ++#define NID_ms_ext_req 171 ++#define OBJ_ms_ext_req 1L,3L,6L,1L,4L,1L,311L,2L,1L,14L ++ ++#define LN_ext_req "Extension Request" ++#define SN_ext_req "extReq" ++#define NID_ext_req 172 ++#define OBJ_ext_req OBJ_pkcs9,14L ++ ++#define SN_name "name" ++#define LN_name "name" ++#define NID_name 173 ++#define OBJ_name OBJ_X509,41L ++ ++#define SN_dnQualifier "dnQualifier" ++#define LN_dnQualifier "dnQualifier" ++#define NID_dnQualifier 174 ++#define OBJ_dnQualifier OBJ_X509,46L ++ ++#define SN_id_pe "id-pe" ++#define NID_id_pe 175 ++#define OBJ_id_pe OBJ_id_pkix,1L ++ ++#define SN_id_ad "id-ad" ++#define NID_id_ad 176 ++#define OBJ_id_ad OBJ_id_pkix,48L ++ ++#define SN_info_access "authorityInfoAccess" ++#define LN_info_access "Authority Information Access" ++#define NID_info_access 177 ++#define OBJ_info_access OBJ_id_pe,1L ++ ++#define SN_ad_OCSP "OCSP" ++#define LN_ad_OCSP "OCSP" ++#define NID_ad_OCSP 178 ++#define OBJ_ad_OCSP OBJ_id_ad,1L ++ ++#define SN_ad_ca_issuers "caIssuers" ++#define LN_ad_ca_issuers "CA Issuers" ++#define NID_ad_ca_issuers 179 ++#define OBJ_ad_ca_issuers OBJ_id_ad,2L ++ ++#define SN_OCSP_sign "OCSPSigning" ++#define LN_OCSP_sign "OCSP Signing" ++#define NID_OCSP_sign 180 ++#define OBJ_OCSP_sign OBJ_id_kp,9L ++#endif /* USE_OBJ_MAC */ ++ ++#include ++#include ++ ++#define OBJ_NAME_TYPE_UNDEF 0x00 ++#define OBJ_NAME_TYPE_MD_METH 0x01 ++#define OBJ_NAME_TYPE_CIPHER_METH 0x02 ++#define OBJ_NAME_TYPE_PKEY_METH 0x03 ++#define OBJ_NAME_TYPE_COMP_METH 0x04 ++#define OBJ_NAME_TYPE_NUM 0x05 ++ ++#define OBJ_NAME_ALIAS 0x8000 ++ ++#define OBJ_BSEARCH_VALUE_ON_NOMATCH 0x01 ++#define OBJ_BSEARCH_FIRST_VALUE_ON_MATCH 0x02 ++ ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++typedef struct obj_name_st ++ { ++ int type; ++ int alias; ++ const char *name; ++ const char *data; ++ } OBJ_NAME; ++ ++#define OBJ_create_and_add_object(a,b,c) OBJ_create(a,b,c) ++ ++ ++int OBJ_NAME_init(void); ++int OBJ_NAME_new_index(unsigned long (*hash_func)(const char *), ++ int (*cmp_func)(const char *, const char *), ++ void (*free_func)(const char *, int, const char *)); ++const char *OBJ_NAME_get(const char *name,int type); ++int OBJ_NAME_add(const char *name,int type,const char *data); ++int OBJ_NAME_remove(const char *name,int type); ++void OBJ_NAME_cleanup(int type); /* -1 for everything */ ++void OBJ_NAME_do_all(int type,void (*fn)(const OBJ_NAME *,void *arg), ++ void *arg); ++void OBJ_NAME_do_all_sorted(int type,void (*fn)(const OBJ_NAME *,void *arg), ++ void *arg); ++ ++ASN1_OBJECT * OBJ_dup(const ASN1_OBJECT *o); ++ASN1_OBJECT * OBJ_nid2obj(int n); ++const char * OBJ_nid2ln(int n); ++const char * OBJ_nid2sn(int n); ++int OBJ_obj2nid(const ASN1_OBJECT *o); ++ASN1_OBJECT * OBJ_txt2obj(const char *s, int no_name); ++int OBJ_obj2txt(char *buf, int buf_len, const ASN1_OBJECT *a, int no_name); ++int OBJ_txt2nid(const char *s); ++int OBJ_ln2nid(const char *s); ++int OBJ_sn2nid(const char *s); ++int OBJ_cmp(const ASN1_OBJECT *a,const ASN1_OBJECT *b); ++const void * OBJ_bsearch_(const void *key,const void *base,int num,int size, ++ int (*cmp)(const void *, const void *)); ++const void * OBJ_bsearch_ex_(const void *key,const void *base,int num, ++ int size, ++ int (*cmp)(const void *, const void *), ++ int flags); ++ ++#define _DECLARE_OBJ_BSEARCH_CMP_FN(scope, type1, type2, nm) \ ++ static int nm##_cmp_BSEARCH_CMP_FN(const void *, const void *); \ ++ static int nm##_cmp(type1 const *, type2 const *); \ ++ scope type2 * OBJ_bsearch_##nm(type1 *key, type2 const *base, int num) ++ ++#define DECLARE_OBJ_BSEARCH_CMP_FN(type1, type2, cmp) \ ++ _DECLARE_OBJ_BSEARCH_CMP_FN(static, type1, type2, cmp) ++#define DECLARE_OBJ_BSEARCH_GLOBAL_CMP_FN(type1, type2, nm) \ ++ type2 * OBJ_bsearch_##nm(type1 *key, type2 const *base, int num) ++ ++/* ++ * Unsolved problem: if a type is actually a pointer type, like ++ * nid_triple is, then its impossible to get a const where you need ++ * it. Consider: ++ * ++ * typedef int nid_triple[3]; ++ * const void *a_; ++ * const nid_triple const *a = a_; ++ * ++ * The assignement discards a const because what you really want is: ++ * ++ * const int const * const *a = a_; ++ * ++ * But if you do that, you lose the fact that a is an array of 3 ints, ++ * which breaks comparison functions. ++ * ++ * Thus we end up having to cast, sadly, or unpack the ++ * declarations. Or, as I finally did in this case, delcare nid_triple ++ * to be a struct, which it should have been in the first place. ++ * ++ * Ben, August 2008. ++ * ++ * Also, strictly speaking not all types need be const, but handling ++ * the non-constness means a lot of complication, and in practice ++ * comparison routines do always not touch their arguments. ++ */ ++ ++#define IMPLEMENT_OBJ_BSEARCH_CMP_FN(type1, type2, nm) \ ++ static int nm##_cmp_BSEARCH_CMP_FN(const void *a_, const void *b_) \ ++ { \ ++ type1 const *a = a_; \ ++ type2 const *b = b_; \ ++ return nm##_cmp(a,b); \ ++ } \ ++ static type2 *OBJ_bsearch_##nm(type1 *key, type2 const *base, int num) \ ++ { \ ++ return (type2 *)OBJ_bsearch_(key, base, num, sizeof(type2), \ ++ nm##_cmp_BSEARCH_CMP_FN); \ ++ } \ ++ extern void dummy_prototype(void) ++ ++#define IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(type1, type2, nm) \ ++ static int nm##_cmp_BSEARCH_CMP_FN(const void *a_, const void *b_) \ ++ { \ ++ type1 const *a = a_; \ ++ type2 const *b = b_; \ ++ return nm##_cmp(a,b); \ ++ } \ ++ type2 *OBJ_bsearch_##nm(type1 *key, type2 const *base, int num) \ ++ { \ ++ return (type2 *)OBJ_bsearch_(key, base, num, sizeof(type2), \ ++ nm##_cmp_BSEARCH_CMP_FN); \ ++ } \ ++ extern void dummy_prototype(void) ++ ++#define OBJ_bsearch(type1,key,type2,base,num,cmp) \ ++ ((type2 *)OBJ_bsearch_(CHECKED_PTR_OF(type1,key),CHECKED_PTR_OF(type2,base), \ ++ num,sizeof(type2), \ ++ ((void)CHECKED_PTR_OF(type1,cmp##_type_1), \ ++ (void)CHECKED_PTR_OF(type2,cmp##_type_2), \ ++ cmp##_BSEARCH_CMP_FN))) ++ ++#define OBJ_bsearch_ex(type1,key,type2,base,num,cmp,flags) \ ++ ((type2 *)OBJ_bsearch_ex_(CHECKED_PTR_OF(type1,key),CHECKED_PTR_OF(type2,base), \ ++ num,sizeof(type2), \ ++ ((void)CHECKED_PTR_OF(type1,cmp##_type_1), \ ++ (void)type_2=CHECKED_PTR_OF(type2,cmp##_type_2), \ ++ cmp##_BSEARCH_CMP_FN)),flags) ++ ++int OBJ_new_nid(int num); ++int OBJ_add_object(const ASN1_OBJECT *obj); ++int OBJ_create(const char *oid,const char *sn,const char *ln); ++void OBJ_cleanup(void ); ++int OBJ_create_objects(BIO *in); ++ ++int OBJ_find_sigid_algs(int signid, int *pdig_nid, int *ppkey_nid); ++int OBJ_find_sigid_by_algs(int *psignid, int dig_nid, int pkey_nid); ++int OBJ_add_sigid(int signid, int dig_id, int pkey_id); ++void OBJ_sigid_free(void); ++ ++extern int obj_cleanup_defer; ++void check_defer(int nid); ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_OBJ_strings(void); ++ ++/* Error codes for the OBJ functions. */ ++ ++/* Function codes. */ ++#define OBJ_F_OBJ_ADD_OBJECT 105 ++#define OBJ_F_OBJ_CREATE 100 ++#define OBJ_F_OBJ_DUP 101 ++#define OBJ_F_OBJ_NAME_NEW_INDEX 106 ++#define OBJ_F_OBJ_NID2LN 102 ++#define OBJ_F_OBJ_NID2OBJ 103 ++#define OBJ_F_OBJ_NID2SN 104 ++ ++/* Reason codes. */ ++#define OBJ_R_MALLOC_FAILURE 100 ++#define OBJ_R_UNKNOWN_NID 101 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/ocsp.h qt.patched/include/openssl/ocsp.h +--- qt.orig/include/openssl/ocsp.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/ocsp.h 2010-08-27 12:01:45.430777500 +0200 +@@ -0,0 +1,623 @@ ++/* ocsp.h */ ++/* Written by Tom Titchener for the OpenSSL ++ * project. */ ++ ++/* History: ++ This file was transfered to Richard Levitte from CertCo by Kathy ++ Weinhold in mid-spring 2000 to be included in OpenSSL or released ++ as a patch kit. */ ++ ++/* ==================================================================== ++ * Copyright (c) 1998-2000 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * openssl-core@openssl.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.openssl.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++ ++#ifndef HEADER_OCSP_H ++#define HEADER_OCSP_H ++ ++#include ++#include ++#include ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* Various flags and values */ ++ ++#define OCSP_DEFAULT_NONCE_LENGTH 16 ++ ++#define OCSP_NOCERTS 0x1 ++#define OCSP_NOINTERN 0x2 ++#define OCSP_NOSIGS 0x4 ++#define OCSP_NOCHAIN 0x8 ++#define OCSP_NOVERIFY 0x10 ++#define OCSP_NOEXPLICIT 0x20 ++#define OCSP_NOCASIGN 0x40 ++#define OCSP_NODELEGATED 0x80 ++#define OCSP_NOCHECKS 0x100 ++#define OCSP_TRUSTOTHER 0x200 ++#define OCSP_RESPID_KEY 0x400 ++#define OCSP_NOTIME 0x800 ++ ++/* CertID ::= SEQUENCE { ++ * hashAlgorithm AlgorithmIdentifier, ++ * issuerNameHash OCTET STRING, -- Hash of Issuer's DN ++ * issuerKeyHash OCTET STRING, -- Hash of Issuers public key (excluding the tag & length fields) ++ * serialNumber CertificateSerialNumber } ++ */ ++typedef struct ocsp_cert_id_st ++ { ++ X509_ALGOR *hashAlgorithm; ++ ASN1_OCTET_STRING *issuerNameHash; ++ ASN1_OCTET_STRING *issuerKeyHash; ++ ASN1_INTEGER *serialNumber; ++ } OCSP_CERTID; ++ ++DECLARE_STACK_OF(OCSP_CERTID) ++ ++/* Request ::= SEQUENCE { ++ * reqCert CertID, ++ * singleRequestExtensions [0] EXPLICIT Extensions OPTIONAL } ++ */ ++typedef struct ocsp_one_request_st ++ { ++ OCSP_CERTID *reqCert; ++ STACK_OF(X509_EXTENSION) *singleRequestExtensions; ++ } OCSP_ONEREQ; ++ ++DECLARE_STACK_OF(OCSP_ONEREQ) ++DECLARE_ASN1_SET_OF(OCSP_ONEREQ) ++ ++ ++/* TBSRequest ::= SEQUENCE { ++ * version [0] EXPLICIT Version DEFAULT v1, ++ * requestorName [1] EXPLICIT GeneralName OPTIONAL, ++ * requestList SEQUENCE OF Request, ++ * requestExtensions [2] EXPLICIT Extensions OPTIONAL } ++ */ ++typedef struct ocsp_req_info_st ++ { ++ ASN1_INTEGER *version; ++ GENERAL_NAME *requestorName; ++ STACK_OF(OCSP_ONEREQ) *requestList; ++ STACK_OF(X509_EXTENSION) *requestExtensions; ++ } OCSP_REQINFO; ++ ++/* Signature ::= SEQUENCE { ++ * signatureAlgorithm AlgorithmIdentifier, ++ * signature BIT STRING, ++ * certs [0] EXPLICIT SEQUENCE OF Certificate OPTIONAL } ++ */ ++typedef struct ocsp_signature_st ++ { ++ X509_ALGOR *signatureAlgorithm; ++ ASN1_BIT_STRING *signature; ++ STACK_OF(X509) *certs; ++ } OCSP_SIGNATURE; ++ ++/* OCSPRequest ::= SEQUENCE { ++ * tbsRequest TBSRequest, ++ * optionalSignature [0] EXPLICIT Signature OPTIONAL } ++ */ ++typedef struct ocsp_request_st ++ { ++ OCSP_REQINFO *tbsRequest; ++ OCSP_SIGNATURE *optionalSignature; /* OPTIONAL */ ++ } OCSP_REQUEST; ++ ++/* OCSPResponseStatus ::= ENUMERATED { ++ * successful (0), --Response has valid confirmations ++ * malformedRequest (1), --Illegal confirmation request ++ * internalError (2), --Internal error in issuer ++ * tryLater (3), --Try again later ++ * --(4) is not used ++ * sigRequired (5), --Must sign the request ++ * unauthorized (6) --Request unauthorized ++ * } ++ */ ++#define OCSP_RESPONSE_STATUS_SUCCESSFUL 0 ++#define OCSP_RESPONSE_STATUS_MALFORMEDREQUEST 1 ++#define OCSP_RESPONSE_STATUS_INTERNALERROR 2 ++#define OCSP_RESPONSE_STATUS_TRYLATER 3 ++#define OCSP_RESPONSE_STATUS_SIGREQUIRED 5 ++#define OCSP_RESPONSE_STATUS_UNAUTHORIZED 6 ++ ++/* ResponseBytes ::= SEQUENCE { ++ * responseType OBJECT IDENTIFIER, ++ * response OCTET STRING } ++ */ ++typedef struct ocsp_resp_bytes_st ++ { ++ ASN1_OBJECT *responseType; ++ ASN1_OCTET_STRING *response; ++ } OCSP_RESPBYTES; ++ ++/* OCSPResponse ::= SEQUENCE { ++ * responseStatus OCSPResponseStatus, ++ * responseBytes [0] EXPLICIT ResponseBytes OPTIONAL } ++ */ ++struct ocsp_response_st ++ { ++ ASN1_ENUMERATED *responseStatus; ++ OCSP_RESPBYTES *responseBytes; ++ }; ++ ++/* ResponderID ::= CHOICE { ++ * byName [1] Name, ++ * byKey [2] KeyHash } ++ */ ++#define V_OCSP_RESPID_NAME 0 ++#define V_OCSP_RESPID_KEY 1 ++struct ocsp_responder_id_st ++ { ++ int type; ++ union { ++ X509_NAME* byName; ++ ASN1_OCTET_STRING *byKey; ++ } value; ++ }; ++ ++DECLARE_STACK_OF(OCSP_RESPID) ++DECLARE_ASN1_FUNCTIONS(OCSP_RESPID) ++ ++/* KeyHash ::= OCTET STRING --SHA-1 hash of responder's public key ++ * --(excluding the tag and length fields) ++ */ ++ ++/* RevokedInfo ::= SEQUENCE { ++ * revocationTime GeneralizedTime, ++ * revocationReason [0] EXPLICIT CRLReason OPTIONAL } ++ */ ++typedef struct ocsp_revoked_info_st ++ { ++ ASN1_GENERALIZEDTIME *revocationTime; ++ ASN1_ENUMERATED *revocationReason; ++ } OCSP_REVOKEDINFO; ++ ++/* CertStatus ::= CHOICE { ++ * good [0] IMPLICIT NULL, ++ * revoked [1] IMPLICIT RevokedInfo, ++ * unknown [2] IMPLICIT UnknownInfo } ++ */ ++#define V_OCSP_CERTSTATUS_GOOD 0 ++#define V_OCSP_CERTSTATUS_REVOKED 1 ++#define V_OCSP_CERTSTATUS_UNKNOWN 2 ++typedef struct ocsp_cert_status_st ++ { ++ int type; ++ union { ++ ASN1_NULL *good; ++ OCSP_REVOKEDINFO *revoked; ++ ASN1_NULL *unknown; ++ } value; ++ } OCSP_CERTSTATUS; ++ ++/* SingleResponse ::= SEQUENCE { ++ * certID CertID, ++ * certStatus CertStatus, ++ * thisUpdate GeneralizedTime, ++ * nextUpdate [0] EXPLICIT GeneralizedTime OPTIONAL, ++ * singleExtensions [1] EXPLICIT Extensions OPTIONAL } ++ */ ++typedef struct ocsp_single_response_st ++ { ++ OCSP_CERTID *certId; ++ OCSP_CERTSTATUS *certStatus; ++ ASN1_GENERALIZEDTIME *thisUpdate; ++ ASN1_GENERALIZEDTIME *nextUpdate; ++ STACK_OF(X509_EXTENSION) *singleExtensions; ++ } OCSP_SINGLERESP; ++ ++DECLARE_STACK_OF(OCSP_SINGLERESP) ++DECLARE_ASN1_SET_OF(OCSP_SINGLERESP) ++ ++/* ResponseData ::= SEQUENCE { ++ * version [0] EXPLICIT Version DEFAULT v1, ++ * responderID ResponderID, ++ * producedAt GeneralizedTime, ++ * responses SEQUENCE OF SingleResponse, ++ * responseExtensions [1] EXPLICIT Extensions OPTIONAL } ++ */ ++typedef struct ocsp_response_data_st ++ { ++ ASN1_INTEGER *version; ++ OCSP_RESPID *responderId; ++ ASN1_GENERALIZEDTIME *producedAt; ++ STACK_OF(OCSP_SINGLERESP) *responses; ++ STACK_OF(X509_EXTENSION) *responseExtensions; ++ } OCSP_RESPDATA; ++ ++/* BasicOCSPResponse ::= SEQUENCE { ++ * tbsResponseData ResponseData, ++ * signatureAlgorithm AlgorithmIdentifier, ++ * signature BIT STRING, ++ * certs [0] EXPLICIT SEQUENCE OF Certificate OPTIONAL } ++ */ ++ /* Note 1: ++ The value for "signature" is specified in the OCSP rfc2560 as follows: ++ "The value for the signature SHALL be computed on the hash of the DER ++ encoding ResponseData." This means that you must hash the DER-encoded ++ tbsResponseData, and then run it through a crypto-signing function, which ++ will (at least w/RSA) do a hash-'n'-private-encrypt operation. This seems ++ a bit odd, but that's the spec. Also note that the data structures do not ++ leave anywhere to independently specify the algorithm used for the initial ++ hash. So, we look at the signature-specification algorithm, and try to do ++ something intelligent. -- Kathy Weinhold, CertCo */ ++ /* Note 2: ++ It seems that the mentioned passage from RFC 2560 (section 4.2.1) is open ++ for interpretation. I've done tests against another responder, and found ++ that it doesn't do the double hashing that the RFC seems to say one ++ should. Therefore, all relevant functions take a flag saying which ++ variant should be used. -- Richard Levitte, OpenSSL team and CeloCom */ ++typedef struct ocsp_basic_response_st ++ { ++ OCSP_RESPDATA *tbsResponseData; ++ X509_ALGOR *signatureAlgorithm; ++ ASN1_BIT_STRING *signature; ++ STACK_OF(X509) *certs; ++ } OCSP_BASICRESP; ++ ++/* ++ * CRLReason ::= ENUMERATED { ++ * unspecified (0), ++ * keyCompromise (1), ++ * cACompromise (2), ++ * affiliationChanged (3), ++ * superseded (4), ++ * cessationOfOperation (5), ++ * certificateHold (6), ++ * removeFromCRL (8) } ++ */ ++#define OCSP_REVOKED_STATUS_NOSTATUS -1 ++#define OCSP_REVOKED_STATUS_UNSPECIFIED 0 ++#define OCSP_REVOKED_STATUS_KEYCOMPROMISE 1 ++#define OCSP_REVOKED_STATUS_CACOMPROMISE 2 ++#define OCSP_REVOKED_STATUS_AFFILIATIONCHANGED 3 ++#define OCSP_REVOKED_STATUS_SUPERSEDED 4 ++#define OCSP_REVOKED_STATUS_CESSATIONOFOPERATION 5 ++#define OCSP_REVOKED_STATUS_CERTIFICATEHOLD 6 ++#define OCSP_REVOKED_STATUS_REMOVEFROMCRL 8 ++ ++/* CrlID ::= SEQUENCE { ++ * crlUrl [0] EXPLICIT IA5String OPTIONAL, ++ * crlNum [1] EXPLICIT INTEGER OPTIONAL, ++ * crlTime [2] EXPLICIT GeneralizedTime OPTIONAL } ++ */ ++typedef struct ocsp_crl_id_st ++ { ++ ASN1_IA5STRING *crlUrl; ++ ASN1_INTEGER *crlNum; ++ ASN1_GENERALIZEDTIME *crlTime; ++ } OCSP_CRLID; ++ ++/* ServiceLocator ::= SEQUENCE { ++ * issuer Name, ++ * locator AuthorityInfoAccessSyntax OPTIONAL } ++ */ ++typedef struct ocsp_service_locator_st ++ { ++ X509_NAME* issuer; ++ STACK_OF(ACCESS_DESCRIPTION) *locator; ++ } OCSP_SERVICELOC; ++ ++#define PEM_STRING_OCSP_REQUEST "OCSP REQUEST" ++#define PEM_STRING_OCSP_RESPONSE "OCSP RESPONSE" ++ ++#define d2i_OCSP_REQUEST_bio(bp,p) ASN1_d2i_bio_of(OCSP_REQUEST,OCSP_REQUEST_new,d2i_OCSP_REQUEST,bp,p) ++ ++#define d2i_OCSP_RESPONSE_bio(bp,p) ASN1_d2i_bio_of(OCSP_RESPONSE,OCSP_RESPONSE_new,d2i_OCSP_RESPONSE,bp,p) ++ ++#define PEM_read_bio_OCSP_REQUEST(bp,x,cb) (OCSP_REQUEST *)PEM_ASN1_read_bio( \ ++ (char *(*)())d2i_OCSP_REQUEST,PEM_STRING_OCSP_REQUEST,bp,(char **)x,cb,NULL) ++ ++#define PEM_read_bio_OCSP_RESPONSE(bp,x,cb)(OCSP_RESPONSE *)PEM_ASN1_read_bio(\ ++ (char *(*)())d2i_OCSP_RESPONSE,PEM_STRING_OCSP_RESPONSE,bp,(char **)x,cb,NULL) ++ ++#define PEM_write_bio_OCSP_REQUEST(bp,o) \ ++ PEM_ASN1_write_bio((int (*)())i2d_OCSP_REQUEST,PEM_STRING_OCSP_REQUEST,\ ++ bp,(char *)o, NULL,NULL,0,NULL,NULL) ++ ++#define PEM_write_bio_OCSP_RESPONSE(bp,o) \ ++ PEM_ASN1_write_bio((int (*)())i2d_OCSP_RESPONSE,PEM_STRING_OCSP_RESPONSE,\ ++ bp,(char *)o, NULL,NULL,0,NULL,NULL) ++ ++#define i2d_OCSP_RESPONSE_bio(bp,o) ASN1_i2d_bio_of(OCSP_RESPONSE,i2d_OCSP_RESPONSE,bp,o) ++ ++#define i2d_OCSP_REQUEST_bio(bp,o) ASN1_i2d_bio_of(OCSP_REQUEST,i2d_OCSP_REQUEST,bp,o) ++ ++#define OCSP_REQUEST_sign(o,pkey,md) \ ++ ASN1_item_sign(ASN1_ITEM_rptr(OCSP_REQINFO),\ ++ o->optionalSignature->signatureAlgorithm,NULL,\ ++ o->optionalSignature->signature,o->tbsRequest,pkey,md) ++ ++#define OCSP_BASICRESP_sign(o,pkey,md,d) \ ++ ASN1_item_sign(ASN1_ITEM_rptr(OCSP_RESPDATA),o->signatureAlgorithm,NULL,\ ++ o->signature,o->tbsResponseData,pkey,md) ++ ++#define OCSP_REQUEST_verify(a,r) ASN1_item_verify(ASN1_ITEM_rptr(OCSP_REQINFO),\ ++ a->optionalSignature->signatureAlgorithm,\ ++ a->optionalSignature->signature,a->tbsRequest,r) ++ ++#define OCSP_BASICRESP_verify(a,r,d) ASN1_item_verify(ASN1_ITEM_rptr(OCSP_RESPDATA),\ ++ a->signatureAlgorithm,a->signature,a->tbsResponseData,r) ++ ++#define ASN1_BIT_STRING_digest(data,type,md,len) \ ++ ASN1_item_digest(ASN1_ITEM_rptr(ASN1_BIT_STRING),type,data,md,len) ++ ++#define OCSP_CERTSTATUS_dup(cs)\ ++ (OCSP_CERTSTATUS*)ASN1_dup((int(*)())i2d_OCSP_CERTSTATUS,\ ++ (char *(*)())d2i_OCSP_CERTSTATUS,(char *)(cs)) ++ ++OCSP_CERTID *OCSP_CERTID_dup(OCSP_CERTID *id); ++ ++OCSP_RESPONSE *OCSP_sendreq_bio(BIO *b, char *path, OCSP_REQUEST *req); ++OCSP_REQ_CTX *OCSP_sendreq_new(BIO *io, char *path, OCSP_REQUEST *req, ++ int maxline); ++int OCSP_sendreq_nbio(OCSP_RESPONSE **presp, OCSP_REQ_CTX *rctx); ++void OCSP_REQ_CTX_free(OCSP_REQ_CTX *rctx); ++int OCSP_REQ_CTX_set1_req(OCSP_REQ_CTX *rctx, OCSP_REQUEST *req); ++int OCSP_REQ_CTX_add1_header(OCSP_REQ_CTX *rctx, ++ const char *name, const char *value); ++ ++OCSP_CERTID *OCSP_cert_to_id(const EVP_MD *dgst, X509 *subject, X509 *issuer); ++ ++OCSP_CERTID *OCSP_cert_id_new(const EVP_MD *dgst, ++ X509_NAME *issuerName, ++ ASN1_BIT_STRING* issuerKey, ++ ASN1_INTEGER *serialNumber); ++ ++OCSP_ONEREQ *OCSP_request_add0_id(OCSP_REQUEST *req, OCSP_CERTID *cid); ++ ++int OCSP_request_add1_nonce(OCSP_REQUEST *req, unsigned char *val, int len); ++int OCSP_basic_add1_nonce(OCSP_BASICRESP *resp, unsigned char *val, int len); ++int OCSP_check_nonce(OCSP_REQUEST *req, OCSP_BASICRESP *bs); ++int OCSP_copy_nonce(OCSP_BASICRESP *resp, OCSP_REQUEST *req); ++ ++int OCSP_request_set1_name(OCSP_REQUEST *req, X509_NAME *nm); ++int OCSP_request_add1_cert(OCSP_REQUEST *req, X509 *cert); ++ ++int OCSP_request_sign(OCSP_REQUEST *req, ++ X509 *signer, ++ EVP_PKEY *key, ++ const EVP_MD *dgst, ++ STACK_OF(X509) *certs, ++ unsigned long flags); ++ ++int OCSP_response_status(OCSP_RESPONSE *resp); ++OCSP_BASICRESP *OCSP_response_get1_basic(OCSP_RESPONSE *resp); ++ ++int OCSP_resp_count(OCSP_BASICRESP *bs); ++OCSP_SINGLERESP *OCSP_resp_get0(OCSP_BASICRESP *bs, int idx); ++int OCSP_resp_find(OCSP_BASICRESP *bs, OCSP_CERTID *id, int last); ++int OCSP_single_get0_status(OCSP_SINGLERESP *single, int *reason, ++ ASN1_GENERALIZEDTIME **revtime, ++ ASN1_GENERALIZEDTIME **thisupd, ++ ASN1_GENERALIZEDTIME **nextupd); ++int OCSP_resp_find_status(OCSP_BASICRESP *bs, OCSP_CERTID *id, int *status, ++ int *reason, ++ ASN1_GENERALIZEDTIME **revtime, ++ ASN1_GENERALIZEDTIME **thisupd, ++ ASN1_GENERALIZEDTIME **nextupd); ++int OCSP_check_validity(ASN1_GENERALIZEDTIME *thisupd, ++ ASN1_GENERALIZEDTIME *nextupd, ++ long sec, long maxsec); ++ ++int OCSP_request_verify(OCSP_REQUEST *req, STACK_OF(X509) *certs, X509_STORE *store, unsigned long flags); ++ ++int OCSP_parse_url(char *url, char **phost, char **pport, char **ppath, int *pssl); ++ ++int OCSP_id_issuer_cmp(OCSP_CERTID *a, OCSP_CERTID *b); ++int OCSP_id_cmp(OCSP_CERTID *a, OCSP_CERTID *b); ++ ++int OCSP_request_onereq_count(OCSP_REQUEST *req); ++OCSP_ONEREQ *OCSP_request_onereq_get0(OCSP_REQUEST *req, int i); ++OCSP_CERTID *OCSP_onereq_get0_id(OCSP_ONEREQ *one); ++int OCSP_id_get0_info(ASN1_OCTET_STRING **piNameHash, ASN1_OBJECT **pmd, ++ ASN1_OCTET_STRING **pikeyHash, ++ ASN1_INTEGER **pserial, OCSP_CERTID *cid); ++int OCSP_request_is_signed(OCSP_REQUEST *req); ++OCSP_RESPONSE *OCSP_response_create(int status, OCSP_BASICRESP *bs); ++OCSP_SINGLERESP *OCSP_basic_add1_status(OCSP_BASICRESP *rsp, ++ OCSP_CERTID *cid, ++ int status, int reason, ++ ASN1_TIME *revtime, ++ ASN1_TIME *thisupd, ASN1_TIME *nextupd); ++int OCSP_basic_add1_cert(OCSP_BASICRESP *resp, X509 *cert); ++int OCSP_basic_sign(OCSP_BASICRESP *brsp, ++ X509 *signer, EVP_PKEY *key, const EVP_MD *dgst, ++ STACK_OF(X509) *certs, unsigned long flags); ++ ++X509_EXTENSION *OCSP_crlID_new(char *url, long *n, char *tim); ++ ++X509_EXTENSION *OCSP_accept_responses_new(char **oids); ++ ++X509_EXTENSION *OCSP_archive_cutoff_new(char* tim); ++ ++X509_EXTENSION *OCSP_url_svcloc_new(X509_NAME* issuer, char **urls); ++ ++int OCSP_REQUEST_get_ext_count(OCSP_REQUEST *x); ++int OCSP_REQUEST_get_ext_by_NID(OCSP_REQUEST *x, int nid, int lastpos); ++int OCSP_REQUEST_get_ext_by_OBJ(OCSP_REQUEST *x, ASN1_OBJECT *obj, int lastpos); ++int OCSP_REQUEST_get_ext_by_critical(OCSP_REQUEST *x, int crit, int lastpos); ++X509_EXTENSION *OCSP_REQUEST_get_ext(OCSP_REQUEST *x, int loc); ++X509_EXTENSION *OCSP_REQUEST_delete_ext(OCSP_REQUEST *x, int loc); ++void *OCSP_REQUEST_get1_ext_d2i(OCSP_REQUEST *x, int nid, int *crit, int *idx); ++int OCSP_REQUEST_add1_ext_i2d(OCSP_REQUEST *x, int nid, void *value, int crit, ++ unsigned long flags); ++int OCSP_REQUEST_add_ext(OCSP_REQUEST *x, X509_EXTENSION *ex, int loc); ++ ++int OCSP_ONEREQ_get_ext_count(OCSP_ONEREQ *x); ++int OCSP_ONEREQ_get_ext_by_NID(OCSP_ONEREQ *x, int nid, int lastpos); ++int OCSP_ONEREQ_get_ext_by_OBJ(OCSP_ONEREQ *x, ASN1_OBJECT *obj, int lastpos); ++int OCSP_ONEREQ_get_ext_by_critical(OCSP_ONEREQ *x, int crit, int lastpos); ++X509_EXTENSION *OCSP_ONEREQ_get_ext(OCSP_ONEREQ *x, int loc); ++X509_EXTENSION *OCSP_ONEREQ_delete_ext(OCSP_ONEREQ *x, int loc); ++void *OCSP_ONEREQ_get1_ext_d2i(OCSP_ONEREQ *x, int nid, int *crit, int *idx); ++int OCSP_ONEREQ_add1_ext_i2d(OCSP_ONEREQ *x, int nid, void *value, int crit, ++ unsigned long flags); ++int OCSP_ONEREQ_add_ext(OCSP_ONEREQ *x, X509_EXTENSION *ex, int loc); ++ ++int OCSP_BASICRESP_get_ext_count(OCSP_BASICRESP *x); ++int OCSP_BASICRESP_get_ext_by_NID(OCSP_BASICRESP *x, int nid, int lastpos); ++int OCSP_BASICRESP_get_ext_by_OBJ(OCSP_BASICRESP *x, ASN1_OBJECT *obj, int lastpos); ++int OCSP_BASICRESP_get_ext_by_critical(OCSP_BASICRESP *x, int crit, int lastpos); ++X509_EXTENSION *OCSP_BASICRESP_get_ext(OCSP_BASICRESP *x, int loc); ++X509_EXTENSION *OCSP_BASICRESP_delete_ext(OCSP_BASICRESP *x, int loc); ++void *OCSP_BASICRESP_get1_ext_d2i(OCSP_BASICRESP *x, int nid, int *crit, int *idx); ++int OCSP_BASICRESP_add1_ext_i2d(OCSP_BASICRESP *x, int nid, void *value, int crit, ++ unsigned long flags); ++int OCSP_BASICRESP_add_ext(OCSP_BASICRESP *x, X509_EXTENSION *ex, int loc); ++ ++int OCSP_SINGLERESP_get_ext_count(OCSP_SINGLERESP *x); ++int OCSP_SINGLERESP_get_ext_by_NID(OCSP_SINGLERESP *x, int nid, int lastpos); ++int OCSP_SINGLERESP_get_ext_by_OBJ(OCSP_SINGLERESP *x, ASN1_OBJECT *obj, int lastpos); ++int OCSP_SINGLERESP_get_ext_by_critical(OCSP_SINGLERESP *x, int crit, int lastpos); ++X509_EXTENSION *OCSP_SINGLERESP_get_ext(OCSP_SINGLERESP *x, int loc); ++X509_EXTENSION *OCSP_SINGLERESP_delete_ext(OCSP_SINGLERESP *x, int loc); ++void *OCSP_SINGLERESP_get1_ext_d2i(OCSP_SINGLERESP *x, int nid, int *crit, int *idx); ++int OCSP_SINGLERESP_add1_ext_i2d(OCSP_SINGLERESP *x, int nid, void *value, int crit, ++ unsigned long flags); ++int OCSP_SINGLERESP_add_ext(OCSP_SINGLERESP *x, X509_EXTENSION *ex, int loc); ++ ++DECLARE_ASN1_FUNCTIONS(OCSP_SINGLERESP) ++DECLARE_ASN1_FUNCTIONS(OCSP_CERTSTATUS) ++DECLARE_ASN1_FUNCTIONS(OCSP_REVOKEDINFO) ++DECLARE_ASN1_FUNCTIONS(OCSP_BASICRESP) ++DECLARE_ASN1_FUNCTIONS(OCSP_RESPDATA) ++DECLARE_ASN1_FUNCTIONS(OCSP_RESPID) ++DECLARE_ASN1_FUNCTIONS(OCSP_RESPONSE) ++DECLARE_ASN1_FUNCTIONS(OCSP_RESPBYTES) ++DECLARE_ASN1_FUNCTIONS(OCSP_ONEREQ) ++DECLARE_ASN1_FUNCTIONS(OCSP_CERTID) ++DECLARE_ASN1_FUNCTIONS(OCSP_REQUEST) ++DECLARE_ASN1_FUNCTIONS(OCSP_SIGNATURE) ++DECLARE_ASN1_FUNCTIONS(OCSP_REQINFO) ++DECLARE_ASN1_FUNCTIONS(OCSP_CRLID) ++DECLARE_ASN1_FUNCTIONS(OCSP_SERVICELOC) ++ ++const char *OCSP_response_status_str(long s); ++const char *OCSP_cert_status_str(long s); ++const char *OCSP_crl_reason_str(long s); ++ ++int OCSP_REQUEST_print(BIO *bp, OCSP_REQUEST* a, unsigned long flags); ++int OCSP_RESPONSE_print(BIO *bp, OCSP_RESPONSE* o, unsigned long flags); ++ ++int OCSP_basic_verify(OCSP_BASICRESP *bs, STACK_OF(X509) *certs, ++ X509_STORE *st, unsigned long flags); ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_OCSP_strings(void); ++ ++/* Error codes for the OCSP functions. */ ++ ++/* Function codes. */ ++#define OCSP_F_ASN1_STRING_ENCODE 100 ++#define OCSP_F_D2I_OCSP_NONCE 102 ++#define OCSP_F_OCSP_BASIC_ADD1_STATUS 103 ++#define OCSP_F_OCSP_BASIC_SIGN 104 ++#define OCSP_F_OCSP_BASIC_VERIFY 105 ++#define OCSP_F_OCSP_CERT_ID_NEW 101 ++#define OCSP_F_OCSP_CHECK_DELEGATED 106 ++#define OCSP_F_OCSP_CHECK_IDS 107 ++#define OCSP_F_OCSP_CHECK_ISSUER 108 ++#define OCSP_F_OCSP_CHECK_VALIDITY 115 ++#define OCSP_F_OCSP_MATCH_ISSUERID 109 ++#define OCSP_F_OCSP_PARSE_URL 114 ++#define OCSP_F_OCSP_REQUEST_SIGN 110 ++#define OCSP_F_OCSP_REQUEST_VERIFY 116 ++#define OCSP_F_OCSP_RESPONSE_GET1_BASIC 111 ++#define OCSP_F_OCSP_SENDREQ_BIO 112 ++#define OCSP_F_OCSP_SENDREQ_NBIO 117 ++#define OCSP_F_PARSE_HTTP_LINE1 118 ++#define OCSP_F_REQUEST_VERIFY 113 ++ ++/* Reason codes. */ ++#define OCSP_R_BAD_DATA 100 ++#define OCSP_R_CERTIFICATE_VERIFY_ERROR 101 ++#define OCSP_R_DIGEST_ERR 102 ++#define OCSP_R_ERROR_IN_NEXTUPDATE_FIELD 122 ++#define OCSP_R_ERROR_IN_THISUPDATE_FIELD 123 ++#define OCSP_R_ERROR_PARSING_URL 121 ++#define OCSP_R_MISSING_OCSPSIGNING_USAGE 103 ++#define OCSP_R_NEXTUPDATE_BEFORE_THISUPDATE 124 ++#define OCSP_R_NOT_BASIC_RESPONSE 104 ++#define OCSP_R_NO_CERTIFICATES_IN_CHAIN 105 ++#define OCSP_R_NO_CONTENT 106 ++#define OCSP_R_NO_PUBLIC_KEY 107 ++#define OCSP_R_NO_RESPONSE_DATA 108 ++#define OCSP_R_NO_REVOKED_TIME 109 ++#define OCSP_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 110 ++#define OCSP_R_REQUEST_NOT_SIGNED 128 ++#define OCSP_R_RESPONSE_CONTAINS_NO_REVOCATION_DATA 111 ++#define OCSP_R_ROOT_CA_NOT_TRUSTED 112 ++#define OCSP_R_SERVER_READ_ERROR 113 ++#define OCSP_R_SERVER_RESPONSE_ERROR 114 ++#define OCSP_R_SERVER_RESPONSE_PARSE_ERROR 115 ++#define OCSP_R_SERVER_WRITE_ERROR 116 ++#define OCSP_R_SIGNATURE_FAILURE 117 ++#define OCSP_R_SIGNER_CERTIFICATE_NOT_FOUND 118 ++#define OCSP_R_STATUS_EXPIRED 125 ++#define OCSP_R_STATUS_NOT_YET_VALID 126 ++#define OCSP_R_STATUS_TOO_OLD 127 ++#define OCSP_R_UNKNOWN_MESSAGE_DIGEST 119 ++#define OCSP_R_UNKNOWN_NID 120 ++#define OCSP_R_UNSUPPORTED_REQUESTORNAME_TYPE 129 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/opensslconf.h qt.patched/include/openssl/opensslconf.h +--- qt.orig/include/openssl/opensslconf.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/opensslconf.h 2010-08-27 12:01:45.446401900 +0200 +@@ -0,0 +1,223 @@ ++/* opensslconf.h */ ++/* WARNING: Generated automatically from opensslconf.h.in by Configure. */ ++ ++/* OpenSSL was configured with the following options: */ ++#ifndef OPENSSL_SYSNAME_WIN32 ++# define OPENSSL_SYSNAME_WIN32 ++#endif ++#ifndef OPENSSL_DOING_MAKEDEPEND ++ ++ ++#ifndef OPENSSL_NO_GMP ++# define OPENSSL_NO_GMP ++#endif ++#ifndef OPENSSL_NO_JPAKE ++# define OPENSSL_NO_JPAKE ++#endif ++#ifndef OPENSSL_NO_KRB5 ++# define OPENSSL_NO_KRB5 ++#endif ++#ifndef OPENSSL_NO_MD2 ++# define OPENSSL_NO_MD2 ++#endif ++#ifndef OPENSSL_NO_RC5 ++# define OPENSSL_NO_RC5 ++#endif ++#ifndef OPENSSL_NO_RFC3779 ++# define OPENSSL_NO_RFC3779 ++#endif ++#ifndef OPENSSL_NO_STORE ++# define OPENSSL_NO_STORE ++#endif ++ ++#endif /* OPENSSL_DOING_MAKEDEPEND */ ++ ++#ifndef OPENSSL_THREADS ++# define OPENSSL_THREADS ++#endif ++ ++/* The OPENSSL_NO_* macros are also defined as NO_* if the application ++ asks for it. This is a transient feature that is provided for those ++ who haven't had the time to do the appropriate changes in their ++ applications. */ ++#ifdef OPENSSL_ALGORITHM_DEFINES ++# if defined(OPENSSL_NO_GMP) && !defined(NO_GMP) ++# define NO_GMP ++# endif ++# if defined(OPENSSL_NO_JPAKE) && !defined(NO_JPAKE) ++# define NO_JPAKE ++# endif ++# if defined(OPENSSL_NO_KRB5) && !defined(NO_KRB5) ++# define NO_KRB5 ++# endif ++# if defined(OPENSSL_NO_MD2) && !defined(NO_MD2) ++# define NO_MD2 ++# endif ++# if defined(OPENSSL_NO_RC5) && !defined(NO_RC5) ++# define NO_RC5 ++# endif ++# if defined(OPENSSL_NO_RFC3779) && !defined(NO_RFC3779) ++# define NO_RFC3779 ++# endif ++# if defined(OPENSSL_NO_STORE) && !defined(NO_STORE) ++# define NO_STORE ++# endif ++#endif ++ ++#define OPENSSL_CPUID_OBJ ++ ++/* crypto/opensslconf.h.in */ ++ ++/* Generate 80386 code? */ ++#undef I386_ONLY ++ ++#if !(defined(VMS) || defined(__VMS)) /* VMS uses logical names instead */ ++#if defined(HEADER_CRYPTLIB_H) && !defined(OPENSSLDIR) ++#define ENGINESDIR "/usr/local/ssl/lib/engines" ++#define OPENSSLDIR "/usr/local/ssl" ++#endif ++#endif ++ ++#undef OPENSSL_UNISTD ++#define OPENSSL_UNISTD ++ ++#undef OPENSSL_EXPORT_VAR_AS_FUNCTION ++#define OPENSSL_EXPORT_VAR_AS_FUNCTION ++ ++#if defined(HEADER_IDEA_H) && !defined(IDEA_INT) ++#define IDEA_INT unsigned int ++#endif ++ ++#if defined(HEADER_MD2_H) && !defined(MD2_INT) ++#define MD2_INT unsigned int ++#endif ++ ++#if defined(HEADER_RC2_H) && !defined(RC2_INT) ++/* I need to put in a mod for the alpha - eay */ ++#define RC2_INT unsigned int ++#endif ++ ++#if defined(HEADER_RC4_H) ++#if !defined(RC4_INT) ++/* using int types make the structure larger but make the code faster ++ * on most boxes I have tested - up to %20 faster. */ ++/* ++ * I don't know what does "most" mean, but declaring "int" is a must on: ++ * - Intel P6 because partial register stalls are very expensive; ++ * - elder Alpha because it lacks byte load/store instructions; ++ */ ++#define RC4_INT unsigned int ++#endif ++#if !defined(RC4_CHUNK) ++/* ++ * This enables code handling data aligned at natural CPU word ++ * boundary. See crypto/rc4/rc4_enc.c for further details. ++ */ ++#undef RC4_CHUNK ++#endif ++#endif ++ ++#if (defined(HEADER_NEW_DES_H) || defined(HEADER_DES_H)) && !defined(DES_LONG) ++/* If this is set to 'unsigned int' on a DEC Alpha, this gives about a ++ * %20 speed up (longs are 8 bytes, int's are 4). */ ++#ifndef DES_LONG ++#define DES_LONG unsigned long ++#endif ++#endif ++ ++#if defined(HEADER_BN_H) && !defined(CONFIG_HEADER_BN_H) ++#define CONFIG_HEADER_BN_H ++#define BN_LLONG ++ ++/* Should we define BN_DIV2W here? */ ++ ++/* Only one for the following should be defined */ ++#undef SIXTY_FOUR_BIT_LONG ++#undef SIXTY_FOUR_BIT ++#define THIRTY_TWO_BIT ++#endif ++ ++#if defined(HEADER_RC4_LOCL_H) && !defined(CONFIG_HEADER_RC4_LOCL_H) ++#define CONFIG_HEADER_RC4_LOCL_H ++/* if this is defined data[i] is used instead of *data, this is a %20 ++ * speedup on x86 */ ++#define RC4_INDEX ++#endif ++ ++#if defined(HEADER_BF_LOCL_H) && !defined(CONFIG_HEADER_BF_LOCL_H) ++#define CONFIG_HEADER_BF_LOCL_H ++#undef BF_PTR ++#endif /* HEADER_BF_LOCL_H */ ++ ++#if defined(HEADER_DES_LOCL_H) && !defined(CONFIG_HEADER_DES_LOCL_H) ++#define CONFIG_HEADER_DES_LOCL_H ++#ifndef DES_DEFAULT_OPTIONS ++/* the following is tweaked from a config script, that is why it is a ++ * protected undef/define */ ++#ifndef DES_PTR ++#undef DES_PTR ++#endif ++ ++/* This helps C compiler generate the correct code for multiple functional ++ * units. It reduces register dependancies at the expense of 2 more ++ * registers */ ++#ifndef DES_RISC1 ++#undef DES_RISC1 ++#endif ++ ++#ifndef DES_RISC2 ++#undef DES_RISC2 ++#endif ++ ++#if defined(DES_RISC1) && defined(DES_RISC2) ++YOU SHOULD NOT HAVE BOTH DES_RISC1 AND DES_RISC2 DEFINED!!!!! ++#endif ++ ++/* Unroll the inner loop, this sometimes helps, sometimes hinders. ++ * Very mucy CPU dependant */ ++#ifndef DES_UNROLL ++#undef DES_UNROLL ++#endif ++ ++/* These default values were supplied by ++ * Peter Gutman ++ * They are only used if nothing else has been defined */ ++#if !defined(DES_PTR) && !defined(DES_RISC1) && !defined(DES_RISC2) && !defined(DES_UNROLL) ++/* Special defines which change the way the code is built depending on the ++ CPU and OS. For SGI machines you can use _MIPS_SZLONG (32 or 64) to find ++ even newer MIPS CPU's, but at the moment one size fits all for ++ optimization options. Older Sparc's work better with only UNROLL, but ++ there's no way to tell at compile time what it is you're running on */ ++ ++#if defined( sun ) /* Newer Sparc's */ ++# define DES_PTR ++# define DES_RISC1 ++# define DES_UNROLL ++#elif defined( __ultrix ) /* Older MIPS */ ++# define DES_PTR ++# define DES_RISC2 ++# define DES_UNROLL ++#elif defined( __osf1__ ) /* Alpha */ ++# define DES_PTR ++# define DES_RISC2 ++#elif defined ( _AIX ) /* RS6000 */ ++ /* Unknown */ ++#elif defined( __hpux ) /* HP-PA */ ++ /* Unknown */ ++#elif defined( __aux ) /* 68K */ ++ /* Unknown */ ++#elif defined( __dgux ) /* 88K (but P6 in latest boxes) */ ++# define DES_UNROLL ++#elif defined( __sgi ) /* Newer MIPS */ ++# define DES_PTR ++# define DES_RISC2 ++# define DES_UNROLL ++#elif defined(i386) || defined(__i386__) /* x86 boxes, should be gcc */ ++# define DES_PTR ++# define DES_RISC1 ++# define DES_UNROLL ++#endif /* Systems-specific speed defines */ ++#endif ++ ++#endif /* DES_DEFAULT_OPTIONS */ ++#endif /* HEADER_DES_LOCL_H */ +diff -urN qt.orig/include/openssl/opensslv.h qt.patched/include/openssl/opensslv.h +--- qt.orig/include/openssl/opensslv.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/opensslv.h 2010-08-27 12:01:45.462026300 +0200 +@@ -0,0 +1,89 @@ ++#ifndef HEADER_OPENSSLV_H ++#define HEADER_OPENSSLV_H ++ ++/* Numeric release version identifier: ++ * MNNFFPPS: major minor fix patch status ++ * The status nibble has one of the values 0 for development, 1 to e for betas ++ * 1 to 14, and f for release. The patch level is exactly that. ++ * For example: ++ * 0.9.3-dev 0x00903000 ++ * 0.9.3-beta1 0x00903001 ++ * 0.9.3-beta2-dev 0x00903002 ++ * 0.9.3-beta2 0x00903002 (same as ...beta2-dev) ++ * 0.9.3 0x0090300f ++ * 0.9.3a 0x0090301f ++ * 0.9.4 0x0090400f ++ * 1.2.3z 0x102031af ++ * ++ * For continuity reasons (because 0.9.5 is already out, and is coded ++ * 0x00905100), between 0.9.5 and 0.9.6 the coding of the patch level ++ * part is slightly different, by setting the highest bit. This means ++ * that 0.9.5a looks like this: 0x0090581f. At 0.9.6, we can start ++ * with 0x0090600S... ++ * ++ * (Prior to 0.9.3-dev a different scheme was used: 0.9.2b is 0x0922.) ++ * (Prior to 0.9.5a beta1, a different scheme was used: MMNNFFRBB for ++ * major minor fix final patch/beta) ++ */ ++#define OPENSSL_VERSION_NUMBER 0x1000001fL ++#ifdef OPENSSL_FIPS ++#define OPENSSL_VERSION_TEXT "OpenSSL 1.0.0a-fips 1 Jun 2010" ++#else ++#define OPENSSL_VERSION_TEXT "OpenSSL 1.0.0a 1 Jun 2010" ++#endif ++#define OPENSSL_VERSION_PTEXT " part of " OPENSSL_VERSION_TEXT ++ ++ ++/* The macros below are to be used for shared library (.so, .dll, ...) ++ * versioning. That kind of versioning works a bit differently between ++ * operating systems. The most usual scheme is to set a major and a minor ++ * number, and have the runtime loader check that the major number is equal ++ * to what it was at application link time, while the minor number has to ++ * be greater or equal to what it was at application link time. With this ++ * scheme, the version number is usually part of the file name, like this: ++ * ++ * libcrypto.so.0.9 ++ * ++ * Some unixen also make a softlink with the major verson number only: ++ * ++ * libcrypto.so.0 ++ * ++ * On Tru64 and IRIX 6.x it works a little bit differently. There, the ++ * shared library version is stored in the file, and is actually a series ++ * of versions, separated by colons. The rightmost version present in the ++ * library when linking an application is stored in the application to be ++ * matched at run time. When the application is run, a check is done to ++ * see if the library version stored in the application matches any of the ++ * versions in the version string of the library itself. ++ * This version string can be constructed in any way, depending on what ++ * kind of matching is desired. However, to implement the same scheme as ++ * the one used in the other unixen, all compatible versions, from lowest ++ * to highest, should be part of the string. Consecutive builds would ++ * give the following versions strings: ++ * ++ * 3.0 ++ * 3.0:3.1 ++ * 3.0:3.1:3.2 ++ * 4.0 ++ * 4.0:4.1 ++ * ++ * Notice how version 4 is completely incompatible with version, and ++ * therefore give the breach you can see. ++ * ++ * There may be other schemes as well that I haven't yet discovered. ++ * ++ * So, here's the way it works here: first of all, the library version ++ * number doesn't need at all to match the overall OpenSSL version. ++ * However, it's nice and more understandable if it actually does. ++ * The current library version is stored in the macro SHLIB_VERSION_NUMBER, ++ * which is just a piece of text in the format "M.m.e" (Major, minor, edit). ++ * For the sake of Tru64, IRIX, and any other OS that behaves in similar ways, ++ * we need to keep a history of version numbers, which is done in the ++ * macro SHLIB_VERSION_HISTORY. The numbers are separated by colons and ++ * should only keep the versions that are binary compatible with the current. ++ */ ++#define SHLIB_VERSION_HISTORY "" ++#define SHLIB_VERSION_NUMBER "1.0.0" ++ ++ ++#endif /* HEADER_OPENSSLV_H */ +diff -urN qt.orig/include/openssl/ossl_typ.h qt.patched/include/openssl/ossl_typ.h +--- qt.orig/include/openssl/ossl_typ.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/ossl_typ.h 2010-08-27 12:01:45.462026300 +0200 +@@ -0,0 +1,200 @@ ++/* ==================================================================== ++ * Copyright (c) 1998-2001 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * openssl-core@openssl.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.openssl.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++ ++#ifndef HEADER_OPENSSL_TYPES_H ++#define HEADER_OPENSSL_TYPES_H ++ ++#include ++ ++#ifdef NO_ASN1_TYPEDEFS ++#define ASN1_INTEGER ASN1_STRING ++#define ASN1_ENUMERATED ASN1_STRING ++#define ASN1_BIT_STRING ASN1_STRING ++#define ASN1_OCTET_STRING ASN1_STRING ++#define ASN1_PRINTABLESTRING ASN1_STRING ++#define ASN1_T61STRING ASN1_STRING ++#define ASN1_IA5STRING ASN1_STRING ++#define ASN1_UTCTIME ASN1_STRING ++#define ASN1_GENERALIZEDTIME ASN1_STRING ++#define ASN1_TIME ASN1_STRING ++#define ASN1_GENERALSTRING ASN1_STRING ++#define ASN1_UNIVERSALSTRING ASN1_STRING ++#define ASN1_BMPSTRING ASN1_STRING ++#define ASN1_VISIBLESTRING ASN1_STRING ++#define ASN1_UTF8STRING ASN1_STRING ++#define ASN1_BOOLEAN int ++#define ASN1_NULL int ++#else ++typedef struct asn1_string_st ASN1_INTEGER; ++typedef struct asn1_string_st ASN1_ENUMERATED; ++typedef struct asn1_string_st ASN1_BIT_STRING; ++typedef struct asn1_string_st ASN1_OCTET_STRING; ++typedef struct asn1_string_st ASN1_PRINTABLESTRING; ++typedef struct asn1_string_st ASN1_T61STRING; ++typedef struct asn1_string_st ASN1_IA5STRING; ++typedef struct asn1_string_st ASN1_GENERALSTRING; ++typedef struct asn1_string_st ASN1_UNIVERSALSTRING; ++typedef struct asn1_string_st ASN1_BMPSTRING; ++typedef struct asn1_string_st ASN1_UTCTIME; ++typedef struct asn1_string_st ASN1_TIME; ++typedef struct asn1_string_st ASN1_GENERALIZEDTIME; ++typedef struct asn1_string_st ASN1_VISIBLESTRING; ++typedef struct asn1_string_st ASN1_UTF8STRING; ++typedef int ASN1_BOOLEAN; ++typedef int ASN1_NULL; ++#endif ++ ++typedef struct asn1_pctx_st ASN1_PCTX; ++ ++#ifdef OPENSSL_SYS_WIN32 ++#undef X509_NAME ++#undef X509_EXTENSIONS ++#undef X509_CERT_PAIR ++#undef PKCS7_ISSUER_AND_SERIAL ++#undef OCSP_REQUEST ++#undef OCSP_RESPONSE ++#endif ++ ++#ifdef BIGNUM ++#undef BIGNUM ++#endif ++typedef struct bignum_st BIGNUM; ++typedef struct bignum_ctx BN_CTX; ++typedef struct bn_blinding_st BN_BLINDING; ++typedef struct bn_mont_ctx_st BN_MONT_CTX; ++typedef struct bn_recp_ctx_st BN_RECP_CTX; ++typedef struct bn_gencb_st BN_GENCB; ++ ++typedef struct buf_mem_st BUF_MEM; ++ ++typedef struct evp_cipher_st EVP_CIPHER; ++typedef struct evp_cipher_ctx_st EVP_CIPHER_CTX; ++typedef struct env_md_st EVP_MD; ++typedef struct env_md_ctx_st EVP_MD_CTX; ++typedef struct evp_pkey_st EVP_PKEY; ++ ++typedef struct evp_pkey_asn1_method_st EVP_PKEY_ASN1_METHOD; ++ ++typedef struct evp_pkey_method_st EVP_PKEY_METHOD; ++typedef struct evp_pkey_ctx_st EVP_PKEY_CTX; ++ ++typedef struct dh_st DH; ++typedef struct dh_method DH_METHOD; ++ ++typedef struct dsa_st DSA; ++typedef struct dsa_method DSA_METHOD; ++ ++typedef struct rsa_st RSA; ++typedef struct rsa_meth_st RSA_METHOD; ++ ++typedef struct rand_meth_st RAND_METHOD; ++ ++typedef struct ecdh_method ECDH_METHOD; ++typedef struct ecdsa_method ECDSA_METHOD; ++ ++typedef struct x509_st X509; ++typedef struct X509_algor_st X509_ALGOR; ++typedef struct X509_crl_st X509_CRL; ++typedef struct x509_crl_method_st X509_CRL_METHOD; ++typedef struct x509_revoked_st X509_REVOKED; ++typedef struct X509_name_st X509_NAME; ++typedef struct X509_pubkey_st X509_PUBKEY; ++typedef struct x509_store_st X509_STORE; ++typedef struct x509_store_ctx_st X509_STORE_CTX; ++ ++typedef struct pkcs8_priv_key_info_st PKCS8_PRIV_KEY_INFO; ++ ++typedef struct v3_ext_ctx X509V3_CTX; ++typedef struct conf_st CONF; ++ ++typedef struct store_st STORE; ++typedef struct store_method_st STORE_METHOD; ++ ++typedef struct ui_st UI; ++typedef struct ui_method_st UI_METHOD; ++ ++typedef struct st_ERR_FNS ERR_FNS; ++ ++typedef struct engine_st ENGINE; ++typedef struct ssl_st SSL; ++typedef struct ssl_ctx_st SSL_CTX; ++ ++typedef struct X509_POLICY_NODE_st X509_POLICY_NODE; ++typedef struct X509_POLICY_LEVEL_st X509_POLICY_LEVEL; ++typedef struct X509_POLICY_TREE_st X509_POLICY_TREE; ++typedef struct X509_POLICY_CACHE_st X509_POLICY_CACHE; ++ ++typedef struct AUTHORITY_KEYID_st AUTHORITY_KEYID; ++typedef struct DIST_POINT_st DIST_POINT; ++typedef struct ISSUING_DIST_POINT_st ISSUING_DIST_POINT; ++typedef struct NAME_CONSTRAINTS_st NAME_CONSTRAINTS; ++ ++ /* If placed in pkcs12.h, we end up with a circular depency with pkcs7.h */ ++#define DECLARE_PKCS12_STACK_OF(type) /* Nothing */ ++#define IMPLEMENT_PKCS12_STACK_OF(type) /* Nothing */ ++ ++typedef struct crypto_ex_data_st CRYPTO_EX_DATA; ++/* Callback types for crypto.h */ ++typedef int CRYPTO_EX_new(void *parent, void *ptr, CRYPTO_EX_DATA *ad, ++ int idx, long argl, void *argp); ++typedef void CRYPTO_EX_free(void *parent, void *ptr, CRYPTO_EX_DATA *ad, ++ int idx, long argl, void *argp); ++typedef int CRYPTO_EX_dup(CRYPTO_EX_DATA *to, CRYPTO_EX_DATA *from, void *from_d, ++ int idx, long argl, void *argp); ++ ++typedef struct ocsp_req_ctx_st OCSP_REQ_CTX; ++typedef struct ocsp_response_st OCSP_RESPONSE; ++typedef struct ocsp_responder_id_st OCSP_RESPID; ++ ++#endif /* def HEADER_OPENSSL_TYPES_H */ +diff -urN qt.orig/include/openssl/pem.h qt.patched/include/openssl/pem.h +--- qt.orig/include/openssl/pem.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/pem.h 2010-08-27 12:01:45.477650700 +0200 +@@ -0,0 +1,641 @@ ++/* crypto/pem/pem.h */ ++/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_PEM_H ++#define HEADER_PEM_H ++ ++#include ++#ifndef OPENSSL_NO_BIO ++#include ++#endif ++#ifndef OPENSSL_NO_STACK ++#include ++#endif ++#include ++#include ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#define PEM_BUFSIZE 1024 ++ ++#define PEM_OBJ_UNDEF 0 ++#define PEM_OBJ_X509 1 ++#define PEM_OBJ_X509_REQ 2 ++#define PEM_OBJ_CRL 3 ++#define PEM_OBJ_SSL_SESSION 4 ++#define PEM_OBJ_PRIV_KEY 10 ++#define PEM_OBJ_PRIV_RSA 11 ++#define PEM_OBJ_PRIV_DSA 12 ++#define PEM_OBJ_PRIV_DH 13 ++#define PEM_OBJ_PUB_RSA 14 ++#define PEM_OBJ_PUB_DSA 15 ++#define PEM_OBJ_PUB_DH 16 ++#define PEM_OBJ_DHPARAMS 17 ++#define PEM_OBJ_DSAPARAMS 18 ++#define PEM_OBJ_PRIV_RSA_PUBLIC 19 ++#define PEM_OBJ_PRIV_ECDSA 20 ++#define PEM_OBJ_PUB_ECDSA 21 ++#define PEM_OBJ_ECPARAMETERS 22 ++ ++#define PEM_ERROR 30 ++#define PEM_DEK_DES_CBC 40 ++#define PEM_DEK_IDEA_CBC 45 ++#define PEM_DEK_DES_EDE 50 ++#define PEM_DEK_DES_ECB 60 ++#define PEM_DEK_RSA 70 ++#define PEM_DEK_RSA_MD2 80 ++#define PEM_DEK_RSA_MD5 90 ++ ++#define PEM_MD_MD2 NID_md2 ++#define PEM_MD_MD5 NID_md5 ++#define PEM_MD_SHA NID_sha ++#define PEM_MD_MD2_RSA NID_md2WithRSAEncryption ++#define PEM_MD_MD5_RSA NID_md5WithRSAEncryption ++#define PEM_MD_SHA_RSA NID_sha1WithRSAEncryption ++ ++#define PEM_STRING_X509_OLD "X509 CERTIFICATE" ++#define PEM_STRING_X509 "CERTIFICATE" ++#define PEM_STRING_X509_PAIR "CERTIFICATE PAIR" ++#define PEM_STRING_X509_TRUSTED "TRUSTED CERTIFICATE" ++#define PEM_STRING_X509_REQ_OLD "NEW CERTIFICATE REQUEST" ++#define PEM_STRING_X509_REQ "CERTIFICATE REQUEST" ++#define PEM_STRING_X509_CRL "X509 CRL" ++#define PEM_STRING_EVP_PKEY "ANY PRIVATE KEY" ++#define PEM_STRING_PUBLIC "PUBLIC KEY" ++#define PEM_STRING_RSA "RSA PRIVATE KEY" ++#define PEM_STRING_RSA_PUBLIC "RSA PUBLIC KEY" ++#define PEM_STRING_DSA "DSA PRIVATE KEY" ++#define PEM_STRING_DSA_PUBLIC "DSA PUBLIC KEY" ++#define PEM_STRING_PKCS7 "PKCS7" ++#define PEM_STRING_PKCS7_SIGNED "PKCS #7 SIGNED DATA" ++#define PEM_STRING_PKCS8 "ENCRYPTED PRIVATE KEY" ++#define PEM_STRING_PKCS8INF "PRIVATE KEY" ++#define PEM_STRING_DHPARAMS "DH PARAMETERS" ++#define PEM_STRING_SSL_SESSION "SSL SESSION PARAMETERS" ++#define PEM_STRING_DSAPARAMS "DSA PARAMETERS" ++#define PEM_STRING_ECDSA_PUBLIC "ECDSA PUBLIC KEY" ++#define PEM_STRING_ECPARAMETERS "EC PARAMETERS" ++#define PEM_STRING_ECPRIVATEKEY "EC PRIVATE KEY" ++#define PEM_STRING_PARAMETERS "PARAMETERS" ++#define PEM_STRING_CMS "CMS" ++ ++ /* Note that this structure is initialised by PEM_SealInit and cleaned up ++ by PEM_SealFinal (at least for now) */ ++typedef struct PEM_Encode_Seal_st ++ { ++ EVP_ENCODE_CTX encode; ++ EVP_MD_CTX md; ++ EVP_CIPHER_CTX cipher; ++ } PEM_ENCODE_SEAL_CTX; ++ ++/* enc_type is one off */ ++#define PEM_TYPE_ENCRYPTED 10 ++#define PEM_TYPE_MIC_ONLY 20 ++#define PEM_TYPE_MIC_CLEAR 30 ++#define PEM_TYPE_CLEAR 40 ++ ++typedef struct pem_recip_st ++ { ++ char *name; ++ X509_NAME *dn; ++ ++ int cipher; ++ int key_enc; ++ /* char iv[8]; unused and wrong size */ ++ } PEM_USER; ++ ++typedef struct pem_ctx_st ++ { ++ int type; /* what type of object */ ++ ++ struct { ++ int version; ++ int mode; ++ } proc_type; ++ ++ char *domain; ++ ++ struct { ++ int cipher; ++ /* unused, and wrong size ++ unsigned char iv[8]; */ ++ } DEK_info; ++ ++ PEM_USER *originator; ++ ++ int num_recipient; ++ PEM_USER **recipient; ++ ++ /* XXX(ben): don#t think this is used! ++ STACK *x509_chain; / * certificate chain */ ++ EVP_MD *md; /* signature type */ ++ ++ int md_enc; /* is the md encrypted or not? */ ++ int md_len; /* length of md_data */ ++ char *md_data; /* message digest, could be pkey encrypted */ ++ ++ EVP_CIPHER *dec; /* date encryption cipher */ ++ int key_len; /* key length */ ++ unsigned char *key; /* key */ ++ /* unused, and wrong size ++ unsigned char iv[8]; */ ++ ++ ++ int data_enc; /* is the data encrypted */ ++ int data_len; ++ unsigned char *data; ++ } PEM_CTX; ++ ++/* These macros make the PEM_read/PEM_write functions easier to maintain and ++ * write. Now they are all implemented with either: ++ * IMPLEMENT_PEM_rw(...) or IMPLEMENT_PEM_rw_cb(...) ++ */ ++ ++#ifdef OPENSSL_NO_FP_API ++ ++#define IMPLEMENT_PEM_read_fp(name, type, str, asn1) /**/ ++#define IMPLEMENT_PEM_write_fp(name, type, str, asn1) /**/ ++#define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) /**/ ++#define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) /**/ ++#define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) /**/ ++ ++#else ++ ++#define IMPLEMENT_PEM_read_fp(name, type, str, asn1) \ ++type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u)\ ++{ \ ++return PEM_ASN1_read((d2i_of_void *)d2i_##asn1, str,fp,(void **)x,cb,u); \ ++} ++ ++#define IMPLEMENT_PEM_write_fp(name, type, str, asn1) \ ++int PEM_write_##name(FILE *fp, type *x) \ ++{ \ ++return PEM_ASN1_write((i2d_of_void *)i2d_##asn1,str,fp,x,NULL,NULL,0,NULL,NULL); \ ++} ++ ++#define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) \ ++int PEM_write_##name(FILE *fp, const type *x) \ ++{ \ ++return PEM_ASN1_write((i2d_of_void *)i2d_##asn1,str,fp,(void *)x,NULL,NULL,0,NULL,NULL); \ ++} ++ ++#define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) \ ++int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \ ++ unsigned char *kstr, int klen, pem_password_cb *cb, \ ++ void *u) \ ++ { \ ++ return PEM_ASN1_write((i2d_of_void *)i2d_##asn1,str,fp,x,enc,kstr,klen,cb,u); \ ++ } ++ ++#define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) \ ++int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \ ++ unsigned char *kstr, int klen, pem_password_cb *cb, \ ++ void *u) \ ++ { \ ++ return PEM_ASN1_write((i2d_of_void *)i2d_##asn1,str,fp,x,enc,kstr,klen,cb,u); \ ++ } ++ ++#endif ++ ++#define IMPLEMENT_PEM_read_bio(name, type, str, asn1) \ ++type *PEM_read_bio_##name(BIO *bp, type **x, pem_password_cb *cb, void *u)\ ++{ \ ++return PEM_ASN1_read_bio((d2i_of_void *)d2i_##asn1, str,bp,(void **)x,cb,u); \ ++} ++ ++#define IMPLEMENT_PEM_write_bio(name, type, str, asn1) \ ++int PEM_write_bio_##name(BIO *bp, type *x) \ ++{ \ ++return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1,str,bp,x,NULL,NULL,0,NULL,NULL); \ ++} ++ ++#define IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \ ++int PEM_write_bio_##name(BIO *bp, const type *x) \ ++{ \ ++return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1,str,bp,(void *)x,NULL,NULL,0,NULL,NULL); \ ++} ++ ++#define IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \ ++int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \ ++ unsigned char *kstr, int klen, pem_password_cb *cb, void *u) \ ++ { \ ++ return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1,str,bp,x,enc,kstr,klen,cb,u); \ ++ } ++ ++#define IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \ ++int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \ ++ unsigned char *kstr, int klen, pem_password_cb *cb, void *u) \ ++ { \ ++ return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1,str,bp,(void *)x,enc,kstr,klen,cb,u); \ ++ } ++ ++#define IMPLEMENT_PEM_write(name, type, str, asn1) \ ++ IMPLEMENT_PEM_write_bio(name, type, str, asn1) \ ++ IMPLEMENT_PEM_write_fp(name, type, str, asn1) ++ ++#define IMPLEMENT_PEM_write_const(name, type, str, asn1) \ ++ IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \ ++ IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) ++ ++#define IMPLEMENT_PEM_write_cb(name, type, str, asn1) \ ++ IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \ ++ IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) ++ ++#define IMPLEMENT_PEM_write_cb_const(name, type, str, asn1) \ ++ IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \ ++ IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) ++ ++#define IMPLEMENT_PEM_read(name, type, str, asn1) \ ++ IMPLEMENT_PEM_read_bio(name, type, str, asn1) \ ++ IMPLEMENT_PEM_read_fp(name, type, str, asn1) ++ ++#define IMPLEMENT_PEM_rw(name, type, str, asn1) \ ++ IMPLEMENT_PEM_read(name, type, str, asn1) \ ++ IMPLEMENT_PEM_write(name, type, str, asn1) ++ ++#define IMPLEMENT_PEM_rw_const(name, type, str, asn1) \ ++ IMPLEMENT_PEM_read(name, type, str, asn1) \ ++ IMPLEMENT_PEM_write_const(name, type, str, asn1) ++ ++#define IMPLEMENT_PEM_rw_cb(name, type, str, asn1) \ ++ IMPLEMENT_PEM_read(name, type, str, asn1) \ ++ IMPLEMENT_PEM_write_cb(name, type, str, asn1) ++ ++/* These are the same except they are for the declarations */ ++ ++#if defined(OPENSSL_NO_FP_API) ++ ++#define DECLARE_PEM_read_fp(name, type) /**/ ++#define DECLARE_PEM_write_fp(name, type) /**/ ++#define DECLARE_PEM_write_cb_fp(name, type) /**/ ++ ++#else ++ ++#define DECLARE_PEM_read_fp(name, type) \ ++ type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u); ++ ++#define DECLARE_PEM_write_fp(name, type) \ ++ int PEM_write_##name(FILE *fp, type *x); ++ ++#define DECLARE_PEM_write_fp_const(name, type) \ ++ int PEM_write_##name(FILE *fp, const type *x); ++ ++#define DECLARE_PEM_write_cb_fp(name, type) \ ++ int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \ ++ unsigned char *kstr, int klen, pem_password_cb *cb, void *u); ++ ++#endif ++ ++#ifndef OPENSSL_NO_BIO ++#define DECLARE_PEM_read_bio(name, type) \ ++ type *PEM_read_bio_##name(BIO *bp, type **x, pem_password_cb *cb, void *u); ++ ++#define DECLARE_PEM_write_bio(name, type) \ ++ int PEM_write_bio_##name(BIO *bp, type *x); ++ ++#define DECLARE_PEM_write_bio_const(name, type) \ ++ int PEM_write_bio_##name(BIO *bp, const type *x); ++ ++#define DECLARE_PEM_write_cb_bio(name, type) \ ++ int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \ ++ unsigned char *kstr, int klen, pem_password_cb *cb, void *u); ++ ++#else ++ ++#define DECLARE_PEM_read_bio(name, type) /**/ ++#define DECLARE_PEM_write_bio(name, type) /**/ ++#define DECLARE_PEM_write_bio_const(name, type) /**/ ++#define DECLARE_PEM_write_cb_bio(name, type) /**/ ++ ++#endif ++ ++#define DECLARE_PEM_write(name, type) \ ++ DECLARE_PEM_write_bio(name, type) \ ++ DECLARE_PEM_write_fp(name, type) ++ ++#define DECLARE_PEM_write_const(name, type) \ ++ DECLARE_PEM_write_bio_const(name, type) \ ++ DECLARE_PEM_write_fp_const(name, type) ++ ++#define DECLARE_PEM_write_cb(name, type) \ ++ DECLARE_PEM_write_cb_bio(name, type) \ ++ DECLARE_PEM_write_cb_fp(name, type) ++ ++#define DECLARE_PEM_read(name, type) \ ++ DECLARE_PEM_read_bio(name, type) \ ++ DECLARE_PEM_read_fp(name, type) ++ ++#define DECLARE_PEM_rw(name, type) \ ++ DECLARE_PEM_read(name, type) \ ++ DECLARE_PEM_write(name, type) ++ ++#define DECLARE_PEM_rw_const(name, type) \ ++ DECLARE_PEM_read(name, type) \ ++ DECLARE_PEM_write_const(name, type) ++ ++#define DECLARE_PEM_rw_cb(name, type) \ ++ DECLARE_PEM_read(name, type) \ ++ DECLARE_PEM_write_cb(name, type) ++ ++#if 1 ++/* "userdata": new with OpenSSL 0.9.4 */ ++typedef int pem_password_cb(char *buf, int size, int rwflag, void *userdata); ++#else ++/* OpenSSL 0.9.3, 0.9.3a */ ++typedef int pem_password_cb(char *buf, int size, int rwflag); ++#endif ++ ++int PEM_get_EVP_CIPHER_INFO(char *header, EVP_CIPHER_INFO *cipher); ++int PEM_do_header (EVP_CIPHER_INFO *cipher, unsigned char *data,long *len, ++ pem_password_cb *callback,void *u); ++ ++#ifndef OPENSSL_NO_BIO ++int PEM_read_bio(BIO *bp, char **name, char **header, ++ unsigned char **data,long *len); ++int PEM_write_bio(BIO *bp,const char *name,char *hdr,unsigned char *data, ++ long len); ++int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm, const char *name, BIO *bp, ++ pem_password_cb *cb, void *u); ++void * PEM_ASN1_read_bio(d2i_of_void *d2i, const char *name, BIO *bp, ++ void **x, pem_password_cb *cb, void *u); ++int PEM_ASN1_write_bio(i2d_of_void *i2d,const char *name,BIO *bp, void *x, ++ const EVP_CIPHER *enc,unsigned char *kstr,int klen, ++ pem_password_cb *cb, void *u); ++ ++STACK_OF(X509_INFO) * PEM_X509_INFO_read_bio(BIO *bp, STACK_OF(X509_INFO) *sk, pem_password_cb *cb, void *u); ++int PEM_X509_INFO_write_bio(BIO *bp,X509_INFO *xi, EVP_CIPHER *enc, ++ unsigned char *kstr, int klen, pem_password_cb *cd, void *u); ++#endif ++ ++int PEM_read(FILE *fp, char **name, char **header, ++ unsigned char **data,long *len); ++int PEM_write(FILE *fp,char *name,char *hdr,unsigned char *data,long len); ++void * PEM_ASN1_read(d2i_of_void *d2i, const char *name, FILE *fp, void **x, ++ pem_password_cb *cb, void *u); ++int PEM_ASN1_write(i2d_of_void *i2d,const char *name,FILE *fp, ++ void *x,const EVP_CIPHER *enc,unsigned char *kstr, ++ int klen,pem_password_cb *callback, void *u); ++STACK_OF(X509_INFO) * PEM_X509_INFO_read(FILE *fp, STACK_OF(X509_INFO) *sk, ++ pem_password_cb *cb, void *u); ++ ++int PEM_SealInit(PEM_ENCODE_SEAL_CTX *ctx, EVP_CIPHER *type, ++ EVP_MD *md_type, unsigned char **ek, int *ekl, ++ unsigned char *iv, EVP_PKEY **pubk, int npubk); ++void PEM_SealUpdate(PEM_ENCODE_SEAL_CTX *ctx, unsigned char *out, int *outl, ++ unsigned char *in, int inl); ++int PEM_SealFinal(PEM_ENCODE_SEAL_CTX *ctx, unsigned char *sig,int *sigl, ++ unsigned char *out, int *outl, EVP_PKEY *priv); ++ ++void PEM_SignInit(EVP_MD_CTX *ctx, EVP_MD *type); ++void PEM_SignUpdate(EVP_MD_CTX *ctx,unsigned char *d,unsigned int cnt); ++int PEM_SignFinal(EVP_MD_CTX *ctx, unsigned char *sigret, ++ unsigned int *siglen, EVP_PKEY *pkey); ++ ++int PEM_def_callback(char *buf, int num, int w, void *key); ++void PEM_proc_type(char *buf, int type); ++void PEM_dek_info(char *buf, const char *type, int len, char *str); ++ ++ ++#include ++ ++DECLARE_PEM_rw(X509, X509) ++ ++DECLARE_PEM_rw(X509_AUX, X509) ++ ++DECLARE_PEM_rw(X509_CERT_PAIR, X509_CERT_PAIR) ++ ++DECLARE_PEM_rw(X509_REQ, X509_REQ) ++DECLARE_PEM_write(X509_REQ_NEW, X509_REQ) ++ ++DECLARE_PEM_rw(X509_CRL, X509_CRL) ++ ++DECLARE_PEM_rw(PKCS7, PKCS7) ++ ++DECLARE_PEM_rw(NETSCAPE_CERT_SEQUENCE, NETSCAPE_CERT_SEQUENCE) ++ ++DECLARE_PEM_rw(PKCS8, X509_SIG) ++ ++DECLARE_PEM_rw(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO) ++ ++#ifndef OPENSSL_NO_RSA ++ ++DECLARE_PEM_rw_cb(RSAPrivateKey, RSA) ++ ++DECLARE_PEM_rw_const(RSAPublicKey, RSA) ++DECLARE_PEM_rw(RSA_PUBKEY, RSA) ++ ++#endif ++ ++#ifndef OPENSSL_NO_DSA ++ ++DECLARE_PEM_rw_cb(DSAPrivateKey, DSA) ++ ++DECLARE_PEM_rw(DSA_PUBKEY, DSA) ++ ++DECLARE_PEM_rw_const(DSAparams, DSA) ++ ++#endif ++ ++#ifndef OPENSSL_NO_EC ++DECLARE_PEM_rw_const(ECPKParameters, EC_GROUP) ++DECLARE_PEM_rw_cb(ECPrivateKey, EC_KEY) ++DECLARE_PEM_rw(EC_PUBKEY, EC_KEY) ++#endif ++ ++#ifndef OPENSSL_NO_DH ++ ++DECLARE_PEM_rw_const(DHparams, DH) ++ ++#endif ++ ++DECLARE_PEM_rw_cb(PrivateKey, EVP_PKEY) ++ ++DECLARE_PEM_rw(PUBKEY, EVP_PKEY) ++ ++int PEM_write_bio_PKCS8PrivateKey_nid(BIO *bp, EVP_PKEY *x, int nid, ++ char *kstr, int klen, ++ pem_password_cb *cb, void *u); ++int PEM_write_bio_PKCS8PrivateKey(BIO *, EVP_PKEY *, const EVP_CIPHER *, ++ char *, int, pem_password_cb *, void *); ++int i2d_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc, ++ char *kstr, int klen, ++ pem_password_cb *cb, void *u); ++int i2d_PKCS8PrivateKey_nid_bio(BIO *bp, EVP_PKEY *x, int nid, ++ char *kstr, int klen, ++ pem_password_cb *cb, void *u); ++EVP_PKEY *d2i_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY **x, pem_password_cb *cb, void *u); ++ ++int i2d_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc, ++ char *kstr, int klen, ++ pem_password_cb *cb, void *u); ++int i2d_PKCS8PrivateKey_nid_fp(FILE *fp, EVP_PKEY *x, int nid, ++ char *kstr, int klen, ++ pem_password_cb *cb, void *u); ++int PEM_write_PKCS8PrivateKey_nid(FILE *fp, EVP_PKEY *x, int nid, ++ char *kstr, int klen, ++ pem_password_cb *cb, void *u); ++ ++EVP_PKEY *d2i_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY **x, pem_password_cb *cb, void *u); ++ ++int PEM_write_PKCS8PrivateKey(FILE *fp,EVP_PKEY *x,const EVP_CIPHER *enc, ++ char *kstr,int klen, pem_password_cb *cd, void *u); ++ ++EVP_PKEY *PEM_read_bio_Parameters(BIO *bp, EVP_PKEY **x); ++int PEM_write_bio_Parameters(BIO *bp, EVP_PKEY *x); ++ ++ ++EVP_PKEY *b2i_PrivateKey(const unsigned char **in, long length); ++EVP_PKEY *b2i_PublicKey(const unsigned char **in, long length); ++EVP_PKEY *b2i_PrivateKey_bio(BIO *in); ++EVP_PKEY *b2i_PublicKey_bio(BIO *in); ++int i2b_PrivateKey_bio(BIO *out, EVP_PKEY *pk); ++int i2b_PublicKey_bio(BIO *out, EVP_PKEY *pk); ++#ifndef OPENSSL_NO_RC4 ++EVP_PKEY *b2i_PVK_bio(BIO *in, pem_password_cb *cb, void *u); ++int i2b_PVK_bio(BIO *out, EVP_PKEY *pk, int enclevel, ++ pem_password_cb *cb, void *u); ++#endif ++ ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_PEM_strings(void); ++ ++/* Error codes for the PEM functions. */ ++ ++/* Function codes. */ ++#define PEM_F_B2I_DSS 127 ++#define PEM_F_B2I_PVK_BIO 128 ++#define PEM_F_B2I_RSA 129 ++#define PEM_F_CHECK_BITLEN_DSA 130 ++#define PEM_F_CHECK_BITLEN_RSA 131 ++#define PEM_F_D2I_PKCS8PRIVATEKEY_BIO 120 ++#define PEM_F_D2I_PKCS8PRIVATEKEY_FP 121 ++#define PEM_F_DO_B2I 132 ++#define PEM_F_DO_B2I_BIO 133 ++#define PEM_F_DO_BLOB_HEADER 134 ++#define PEM_F_DO_PK8PKEY 126 ++#define PEM_F_DO_PK8PKEY_FP 125 ++#define PEM_F_DO_PVK_BODY 135 ++#define PEM_F_DO_PVK_HEADER 136 ++#define PEM_F_I2B_PVK 137 ++#define PEM_F_I2B_PVK_BIO 138 ++#define PEM_F_LOAD_IV 101 ++#define PEM_F_PEM_ASN1_READ 102 ++#define PEM_F_PEM_ASN1_READ_BIO 103 ++#define PEM_F_PEM_ASN1_WRITE 104 ++#define PEM_F_PEM_ASN1_WRITE_BIO 105 ++#define PEM_F_PEM_DEF_CALLBACK 100 ++#define PEM_F_PEM_DO_HEADER 106 ++#define PEM_F_PEM_F_PEM_WRITE_PKCS8PRIVATEKEY 118 ++#define PEM_F_PEM_GET_EVP_CIPHER_INFO 107 ++#define PEM_F_PEM_PK8PKEY 119 ++#define PEM_F_PEM_READ 108 ++#define PEM_F_PEM_READ_BIO 109 ++#define PEM_F_PEM_READ_BIO_PARAMETERS 140 ++#define PEM_F_PEM_READ_BIO_PRIVATEKEY 123 ++#define PEM_F_PEM_READ_PRIVATEKEY 124 ++#define PEM_F_PEM_SEALFINAL 110 ++#define PEM_F_PEM_SEALINIT 111 ++#define PEM_F_PEM_SIGNFINAL 112 ++#define PEM_F_PEM_WRITE 113 ++#define PEM_F_PEM_WRITE_BIO 114 ++#define PEM_F_PEM_WRITE_PRIVATEKEY 139 ++#define PEM_F_PEM_X509_INFO_READ 115 ++#define PEM_F_PEM_X509_INFO_READ_BIO 116 ++#define PEM_F_PEM_X509_INFO_WRITE_BIO 117 ++ ++/* Reason codes. */ ++#define PEM_R_BAD_BASE64_DECODE 100 ++#define PEM_R_BAD_DECRYPT 101 ++#define PEM_R_BAD_END_LINE 102 ++#define PEM_R_BAD_IV_CHARS 103 ++#define PEM_R_BAD_MAGIC_NUMBER 116 ++#define PEM_R_BAD_PASSWORD_READ 104 ++#define PEM_R_BAD_VERSION_NUMBER 117 ++#define PEM_R_BIO_WRITE_FAILURE 118 ++#define PEM_R_CIPHER_IS_NULL 127 ++#define PEM_R_ERROR_CONVERTING_PRIVATE_KEY 115 ++#define PEM_R_EXPECTING_PRIVATE_KEY_BLOB 119 ++#define PEM_R_EXPECTING_PUBLIC_KEY_BLOB 120 ++#define PEM_R_INCONSISTENT_HEADER 121 ++#define PEM_R_KEYBLOB_HEADER_PARSE_ERROR 122 ++#define PEM_R_KEYBLOB_TOO_SHORT 123 ++#define PEM_R_NOT_DEK_INFO 105 ++#define PEM_R_NOT_ENCRYPTED 106 ++#define PEM_R_NOT_PROC_TYPE 107 ++#define PEM_R_NO_START_LINE 108 ++#define PEM_R_PROBLEMS_GETTING_PASSWORD 109 ++#define PEM_R_PUBLIC_KEY_NO_RSA 110 ++#define PEM_R_PVK_DATA_TOO_SHORT 124 ++#define PEM_R_PVK_TOO_SHORT 125 ++#define PEM_R_READ_KEY 111 ++#define PEM_R_SHORT_HEADER 112 ++#define PEM_R_UNSUPPORTED_CIPHER 113 ++#define PEM_R_UNSUPPORTED_ENCRYPTION 114 ++#define PEM_R_UNSUPPORTED_KEY_COMPONENTS 126 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/pem2.h qt.patched/include/openssl/pem2.h +--- qt.orig/include/openssl/pem2.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/pem2.h 2010-08-27 12:01:45.493275100 +0200 +@@ -0,0 +1,70 @@ ++/* ==================================================================== ++ * Copyright (c) 1999 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * licensing@OpenSSL.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++ ++/* ++ * This header only exists to break a circular dependency between pem and err ++ * Ben 30 Jan 1999. ++ */ ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#ifndef HEADER_PEM_H ++void ERR_load_PEM_strings(void); ++#endif ++ ++#ifdef __cplusplus ++} ++#endif +diff -urN qt.orig/include/openssl/pkcs12.h qt.patched/include/openssl/pkcs12.h +--- qt.orig/include/openssl/pkcs12.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/pkcs12.h 2010-08-27 12:01:45.508899500 +0200 +@@ -0,0 +1,331 @@ ++/* pkcs12.h */ ++/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL ++ * project 1999. ++ */ ++/* ==================================================================== ++ * Copyright (c) 1999 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * licensing@OpenSSL.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++ ++#ifndef HEADER_PKCS12_H ++#define HEADER_PKCS12_H ++ ++#include ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#define PKCS12_KEY_ID 1 ++#define PKCS12_IV_ID 2 ++#define PKCS12_MAC_ID 3 ++ ++/* Default iteration count */ ++#ifndef PKCS12_DEFAULT_ITER ++#define PKCS12_DEFAULT_ITER PKCS5_DEFAULT_ITER ++#endif ++ ++#define PKCS12_MAC_KEY_LENGTH 20 ++ ++#define PKCS12_SALT_LEN 8 ++ ++/* Uncomment out next line for unicode password and names, otherwise ASCII */ ++ ++/*#define PBE_UNICODE*/ ++ ++#ifdef PBE_UNICODE ++#define PKCS12_key_gen PKCS12_key_gen_uni ++#define PKCS12_add_friendlyname PKCS12_add_friendlyname_uni ++#else ++#define PKCS12_key_gen PKCS12_key_gen_asc ++#define PKCS12_add_friendlyname PKCS12_add_friendlyname_asc ++#endif ++ ++/* MS key usage constants */ ++ ++#define KEY_EX 0x10 ++#define KEY_SIG 0x80 ++ ++typedef struct { ++X509_SIG *dinfo; ++ASN1_OCTET_STRING *salt; ++ASN1_INTEGER *iter; /* defaults to 1 */ ++} PKCS12_MAC_DATA; ++ ++typedef struct { ++ASN1_INTEGER *version; ++PKCS12_MAC_DATA *mac; ++PKCS7 *authsafes; ++} PKCS12; ++ ++typedef struct { ++ASN1_OBJECT *type; ++union { ++ struct pkcs12_bag_st *bag; /* secret, crl and certbag */ ++ struct pkcs8_priv_key_info_st *keybag; /* keybag */ ++ X509_SIG *shkeybag; /* shrouded key bag */ ++ STACK_OF(PKCS12_SAFEBAG) *safes; ++ ASN1_TYPE *other; ++}value; ++STACK_OF(X509_ATTRIBUTE) *attrib; ++} PKCS12_SAFEBAG; ++ ++DECLARE_STACK_OF(PKCS12_SAFEBAG) ++DECLARE_ASN1_SET_OF(PKCS12_SAFEBAG) ++DECLARE_PKCS12_STACK_OF(PKCS12_SAFEBAG) ++ ++typedef struct pkcs12_bag_st { ++ASN1_OBJECT *type; ++union { ++ ASN1_OCTET_STRING *x509cert; ++ ASN1_OCTET_STRING *x509crl; ++ ASN1_OCTET_STRING *octet; ++ ASN1_IA5STRING *sdsicert; ++ ASN1_TYPE *other; /* Secret or other bag */ ++}value; ++} PKCS12_BAGS; ++ ++#define PKCS12_ERROR 0 ++#define PKCS12_OK 1 ++ ++/* Compatibility macros */ ++ ++#define M_PKCS12_x5092certbag PKCS12_x5092certbag ++#define M_PKCS12_x509crl2certbag PKCS12_x509crl2certbag ++ ++#define M_PKCS12_certbag2x509 PKCS12_certbag2x509 ++#define M_PKCS12_certbag2x509crl PKCS12_certbag2x509crl ++ ++#define M_PKCS12_unpack_p7data PKCS12_unpack_p7data ++#define M_PKCS12_pack_authsafes PKCS12_pack_authsafes ++#define M_PKCS12_unpack_authsafes PKCS12_unpack_authsafes ++#define M_PKCS12_unpack_p7encdata PKCS12_unpack_p7encdata ++ ++#define M_PKCS12_decrypt_skey PKCS12_decrypt_skey ++#define M_PKCS8_decrypt PKCS8_decrypt ++ ++#define M_PKCS12_bag_type(bg) OBJ_obj2nid((bg)->type) ++#define M_PKCS12_cert_bag_type(bg) OBJ_obj2nid((bg)->value.bag->type) ++#define M_PKCS12_crl_bag_type M_PKCS12_cert_bag_type ++ ++#define PKCS12_get_attr(bag, attr_nid) \ ++ PKCS12_get_attr_gen(bag->attrib, attr_nid) ++ ++#define PKCS8_get_attr(p8, attr_nid) \ ++ PKCS12_get_attr_gen(p8->attributes, attr_nid) ++ ++#define PKCS12_mac_present(p12) ((p12)->mac ? 1 : 0) ++ ++ ++PKCS12_SAFEBAG *PKCS12_x5092certbag(X509 *x509); ++PKCS12_SAFEBAG *PKCS12_x509crl2certbag(X509_CRL *crl); ++X509 *PKCS12_certbag2x509(PKCS12_SAFEBAG *bag); ++X509_CRL *PKCS12_certbag2x509crl(PKCS12_SAFEBAG *bag); ++ ++PKCS12_SAFEBAG *PKCS12_item_pack_safebag(void *obj, const ASN1_ITEM *it, int nid1, ++ int nid2); ++PKCS12_SAFEBAG *PKCS12_MAKE_KEYBAG(PKCS8_PRIV_KEY_INFO *p8); ++PKCS8_PRIV_KEY_INFO *PKCS8_decrypt(X509_SIG *p8, const char *pass, int passlen); ++PKCS8_PRIV_KEY_INFO *PKCS12_decrypt_skey(PKCS12_SAFEBAG *bag, const char *pass, ++ int passlen); ++X509_SIG *PKCS8_encrypt(int pbe_nid, const EVP_CIPHER *cipher, ++ const char *pass, int passlen, ++ unsigned char *salt, int saltlen, int iter, ++ PKCS8_PRIV_KEY_INFO *p8); ++PKCS12_SAFEBAG *PKCS12_MAKE_SHKEYBAG(int pbe_nid, const char *pass, ++ int passlen, unsigned char *salt, ++ int saltlen, int iter, ++ PKCS8_PRIV_KEY_INFO *p8); ++PKCS7 *PKCS12_pack_p7data(STACK_OF(PKCS12_SAFEBAG) *sk); ++STACK_OF(PKCS12_SAFEBAG) *PKCS12_unpack_p7data(PKCS7 *p7); ++PKCS7 *PKCS12_pack_p7encdata(int pbe_nid, const char *pass, int passlen, ++ unsigned char *salt, int saltlen, int iter, ++ STACK_OF(PKCS12_SAFEBAG) *bags); ++STACK_OF(PKCS12_SAFEBAG) *PKCS12_unpack_p7encdata(PKCS7 *p7, const char *pass, int passlen); ++ ++int PKCS12_pack_authsafes(PKCS12 *p12, STACK_OF(PKCS7) *safes); ++STACK_OF(PKCS7) *PKCS12_unpack_authsafes(PKCS12 *p12); ++ ++int PKCS12_add_localkeyid(PKCS12_SAFEBAG *bag, unsigned char *name, int namelen); ++int PKCS12_add_friendlyname_asc(PKCS12_SAFEBAG *bag, const char *name, ++ int namelen); ++int PKCS12_add_CSPName_asc(PKCS12_SAFEBAG *bag, const char *name, ++ int namelen); ++int PKCS12_add_friendlyname_uni(PKCS12_SAFEBAG *bag, const unsigned char *name, ++ int namelen); ++int PKCS8_add_keyusage(PKCS8_PRIV_KEY_INFO *p8, int usage); ++ASN1_TYPE *PKCS12_get_attr_gen(STACK_OF(X509_ATTRIBUTE) *attrs, int attr_nid); ++char *PKCS12_get_friendlyname(PKCS12_SAFEBAG *bag); ++unsigned char *PKCS12_pbe_crypt(X509_ALGOR *algor, const char *pass, ++ int passlen, unsigned char *in, int inlen, ++ unsigned char **data, int *datalen, int en_de); ++void * PKCS12_item_decrypt_d2i(X509_ALGOR *algor, const ASN1_ITEM *it, ++ const char *pass, int passlen, ASN1_OCTET_STRING *oct, int zbuf); ++ASN1_OCTET_STRING *PKCS12_item_i2d_encrypt(X509_ALGOR *algor, const ASN1_ITEM *it, ++ const char *pass, int passlen, ++ void *obj, int zbuf); ++PKCS12 *PKCS12_init(int mode); ++int PKCS12_key_gen_asc(const char *pass, int passlen, unsigned char *salt, ++ int saltlen, int id, int iter, int n, ++ unsigned char *out, const EVP_MD *md_type); ++int PKCS12_key_gen_uni(unsigned char *pass, int passlen, unsigned char *salt, int saltlen, int id, int iter, int n, unsigned char *out, const EVP_MD *md_type); ++int PKCS12_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen, ++ ASN1_TYPE *param, const EVP_CIPHER *cipher, const EVP_MD *md_type, ++ int en_de); ++int PKCS12_gen_mac(PKCS12 *p12, const char *pass, int passlen, ++ unsigned char *mac, unsigned int *maclen); ++int PKCS12_verify_mac(PKCS12 *p12, const char *pass, int passlen); ++int PKCS12_set_mac(PKCS12 *p12, const char *pass, int passlen, ++ unsigned char *salt, int saltlen, int iter, ++ const EVP_MD *md_type); ++int PKCS12_setup_mac(PKCS12 *p12, int iter, unsigned char *salt, ++ int saltlen, const EVP_MD *md_type); ++unsigned char *OPENSSL_asc2uni(const char *asc, int asclen, unsigned char **uni, int *unilen); ++char *OPENSSL_uni2asc(unsigned char *uni, int unilen); ++ ++DECLARE_ASN1_FUNCTIONS(PKCS12) ++DECLARE_ASN1_FUNCTIONS(PKCS12_MAC_DATA) ++DECLARE_ASN1_FUNCTIONS(PKCS12_SAFEBAG) ++DECLARE_ASN1_FUNCTIONS(PKCS12_BAGS) ++ ++DECLARE_ASN1_ITEM(PKCS12_SAFEBAGS) ++DECLARE_ASN1_ITEM(PKCS12_AUTHSAFES) ++ ++void PKCS12_PBE_add(void); ++int PKCS12_parse(PKCS12 *p12, const char *pass, EVP_PKEY **pkey, X509 **cert, ++ STACK_OF(X509) **ca); ++PKCS12 *PKCS12_create(char *pass, char *name, EVP_PKEY *pkey, X509 *cert, ++ STACK_OF(X509) *ca, int nid_key, int nid_cert, int iter, ++ int mac_iter, int keytype); ++ ++PKCS12_SAFEBAG *PKCS12_add_cert(STACK_OF(PKCS12_SAFEBAG) **pbags, X509 *cert); ++PKCS12_SAFEBAG *PKCS12_add_key(STACK_OF(PKCS12_SAFEBAG) **pbags, EVP_PKEY *key, ++ int key_usage, int iter, ++ int key_nid, char *pass); ++int PKCS12_add_safe(STACK_OF(PKCS7) **psafes, STACK_OF(PKCS12_SAFEBAG) *bags, ++ int safe_nid, int iter, char *pass); ++PKCS12 *PKCS12_add_safes(STACK_OF(PKCS7) *safes, int p7_nid); ++ ++int i2d_PKCS12_bio(BIO *bp, PKCS12 *p12); ++int i2d_PKCS12_fp(FILE *fp, PKCS12 *p12); ++PKCS12 *d2i_PKCS12_bio(BIO *bp, PKCS12 **p12); ++PKCS12 *d2i_PKCS12_fp(FILE *fp, PKCS12 **p12); ++int PKCS12_newpass(PKCS12 *p12, char *oldpass, char *newpass); ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_PKCS12_strings(void); ++ ++/* Error codes for the PKCS12 functions. */ ++ ++/* Function codes. */ ++#define PKCS12_F_PARSE_BAG 129 ++#define PKCS12_F_PARSE_BAGS 103 ++#define PKCS12_F_PKCS12_ADD_FRIENDLYNAME 100 ++#define PKCS12_F_PKCS12_ADD_FRIENDLYNAME_ASC 127 ++#define PKCS12_F_PKCS12_ADD_FRIENDLYNAME_UNI 102 ++#define PKCS12_F_PKCS12_ADD_LOCALKEYID 104 ++#define PKCS12_F_PKCS12_CREATE 105 ++#define PKCS12_F_PKCS12_GEN_MAC 107 ++#define PKCS12_F_PKCS12_INIT 109 ++#define PKCS12_F_PKCS12_ITEM_DECRYPT_D2I 106 ++#define PKCS12_F_PKCS12_ITEM_I2D_ENCRYPT 108 ++#define PKCS12_F_PKCS12_ITEM_PACK_SAFEBAG 117 ++#define PKCS12_F_PKCS12_KEY_GEN_ASC 110 ++#define PKCS12_F_PKCS12_KEY_GEN_UNI 111 ++#define PKCS12_F_PKCS12_MAKE_KEYBAG 112 ++#define PKCS12_F_PKCS12_MAKE_SHKEYBAG 113 ++#define PKCS12_F_PKCS12_NEWPASS 128 ++#define PKCS12_F_PKCS12_PACK_P7DATA 114 ++#define PKCS12_F_PKCS12_PACK_P7ENCDATA 115 ++#define PKCS12_F_PKCS12_PARSE 118 ++#define PKCS12_F_PKCS12_PBE_CRYPT 119 ++#define PKCS12_F_PKCS12_PBE_KEYIVGEN 120 ++#define PKCS12_F_PKCS12_SETUP_MAC 122 ++#define PKCS12_F_PKCS12_SET_MAC 123 ++#define PKCS12_F_PKCS12_UNPACK_AUTHSAFES 130 ++#define PKCS12_F_PKCS12_UNPACK_P7DATA 131 ++#define PKCS12_F_PKCS12_VERIFY_MAC 126 ++#define PKCS12_F_PKCS8_ADD_KEYUSAGE 124 ++#define PKCS12_F_PKCS8_ENCRYPT 125 ++ ++/* Reason codes. */ ++#define PKCS12_R_CANT_PACK_STRUCTURE 100 ++#define PKCS12_R_CONTENT_TYPE_NOT_DATA 121 ++#define PKCS12_R_DECODE_ERROR 101 ++#define PKCS12_R_ENCODE_ERROR 102 ++#define PKCS12_R_ENCRYPT_ERROR 103 ++#define PKCS12_R_ERROR_SETTING_ENCRYPTED_DATA_TYPE 120 ++#define PKCS12_R_INVALID_NULL_ARGUMENT 104 ++#define PKCS12_R_INVALID_NULL_PKCS12_POINTER 105 ++#define PKCS12_R_IV_GEN_ERROR 106 ++#define PKCS12_R_KEY_GEN_ERROR 107 ++#define PKCS12_R_MAC_ABSENT 108 ++#define PKCS12_R_MAC_GENERATION_ERROR 109 ++#define PKCS12_R_MAC_SETUP_ERROR 110 ++#define PKCS12_R_MAC_STRING_SET_ERROR 111 ++#define PKCS12_R_MAC_VERIFY_ERROR 112 ++#define PKCS12_R_MAC_VERIFY_FAILURE 113 ++#define PKCS12_R_PARSE_ERROR 114 ++#define PKCS12_R_PKCS12_ALGOR_CIPHERINIT_ERROR 115 ++#define PKCS12_R_PKCS12_CIPHERFINAL_ERROR 116 ++#define PKCS12_R_PKCS12_PBE_CRYPT_ERROR 117 ++#define PKCS12_R_UNKNOWN_DIGEST_ALGORITHM 118 ++#define PKCS12_R_UNSUPPORTED_PKCS12_MODE 119 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/pkcs7.h qt.patched/include/openssl/pkcs7.h +--- qt.orig/include/openssl/pkcs7.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/pkcs7.h 2010-08-27 12:01:45.508899500 +0200 +@@ -0,0 +1,499 @@ ++/* crypto/pkcs7/pkcs7.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_PKCS7_H ++#define HEADER_PKCS7_H ++ ++#include ++#include ++#include ++ ++#include ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#ifdef OPENSSL_SYS_WIN32 ++/* Under Win32 thes are defined in wincrypt.h */ ++#undef PKCS7_ISSUER_AND_SERIAL ++#undef PKCS7_SIGNER_INFO ++#endif ++ ++/* ++Encryption_ID DES-CBC ++Digest_ID MD5 ++Digest_Encryption_ID rsaEncryption ++Key_Encryption_ID rsaEncryption ++*/ ++ ++typedef struct pkcs7_issuer_and_serial_st ++ { ++ X509_NAME *issuer; ++ ASN1_INTEGER *serial; ++ } PKCS7_ISSUER_AND_SERIAL; ++ ++typedef struct pkcs7_signer_info_st ++ { ++ ASN1_INTEGER *version; /* version 1 */ ++ PKCS7_ISSUER_AND_SERIAL *issuer_and_serial; ++ X509_ALGOR *digest_alg; ++ STACK_OF(X509_ATTRIBUTE) *auth_attr; /* [ 0 ] */ ++ X509_ALGOR *digest_enc_alg; ++ ASN1_OCTET_STRING *enc_digest; ++ STACK_OF(X509_ATTRIBUTE) *unauth_attr; /* [ 1 ] */ ++ ++ /* The private key to sign with */ ++ EVP_PKEY *pkey; ++ } PKCS7_SIGNER_INFO; ++ ++DECLARE_STACK_OF(PKCS7_SIGNER_INFO) ++DECLARE_ASN1_SET_OF(PKCS7_SIGNER_INFO) ++ ++typedef struct pkcs7_recip_info_st ++ { ++ ASN1_INTEGER *version; /* version 0 */ ++ PKCS7_ISSUER_AND_SERIAL *issuer_and_serial; ++ X509_ALGOR *key_enc_algor; ++ ASN1_OCTET_STRING *enc_key; ++ X509 *cert; /* get the pub-key from this */ ++ } PKCS7_RECIP_INFO; ++ ++DECLARE_STACK_OF(PKCS7_RECIP_INFO) ++DECLARE_ASN1_SET_OF(PKCS7_RECIP_INFO) ++ ++typedef struct pkcs7_signed_st ++ { ++ ASN1_INTEGER *version; /* version 1 */ ++ STACK_OF(X509_ALGOR) *md_algs; /* md used */ ++ STACK_OF(X509) *cert; /* [ 0 ] */ ++ STACK_OF(X509_CRL) *crl; /* [ 1 ] */ ++ STACK_OF(PKCS7_SIGNER_INFO) *signer_info; ++ ++ struct pkcs7_st *contents; ++ } PKCS7_SIGNED; ++/* The above structure is very very similar to PKCS7_SIGN_ENVELOPE. ++ * How about merging the two */ ++ ++typedef struct pkcs7_enc_content_st ++ { ++ ASN1_OBJECT *content_type; ++ X509_ALGOR *algorithm; ++ ASN1_OCTET_STRING *enc_data; /* [ 0 ] */ ++ const EVP_CIPHER *cipher; ++ } PKCS7_ENC_CONTENT; ++ ++typedef struct pkcs7_enveloped_st ++ { ++ ASN1_INTEGER *version; /* version 0 */ ++ STACK_OF(PKCS7_RECIP_INFO) *recipientinfo; ++ PKCS7_ENC_CONTENT *enc_data; ++ } PKCS7_ENVELOPE; ++ ++typedef struct pkcs7_signedandenveloped_st ++ { ++ ASN1_INTEGER *version; /* version 1 */ ++ STACK_OF(X509_ALGOR) *md_algs; /* md used */ ++ STACK_OF(X509) *cert; /* [ 0 ] */ ++ STACK_OF(X509_CRL) *crl; /* [ 1 ] */ ++ STACK_OF(PKCS7_SIGNER_INFO) *signer_info; ++ ++ PKCS7_ENC_CONTENT *enc_data; ++ STACK_OF(PKCS7_RECIP_INFO) *recipientinfo; ++ } PKCS7_SIGN_ENVELOPE; ++ ++typedef struct pkcs7_digest_st ++ { ++ ASN1_INTEGER *version; /* version 0 */ ++ X509_ALGOR *md; /* md used */ ++ struct pkcs7_st *contents; ++ ASN1_OCTET_STRING *digest; ++ } PKCS7_DIGEST; ++ ++typedef struct pkcs7_encrypted_st ++ { ++ ASN1_INTEGER *version; /* version 0 */ ++ PKCS7_ENC_CONTENT *enc_data; ++ } PKCS7_ENCRYPT; ++ ++typedef struct pkcs7_st ++ { ++ /* The following is non NULL if it contains ASN1 encoding of ++ * this structure */ ++ unsigned char *asn1; ++ long length; ++ ++#define PKCS7_S_HEADER 0 ++#define PKCS7_S_BODY 1 ++#define PKCS7_S_TAIL 2 ++ int state; /* used during processing */ ++ ++ int detached; ++ ++ ASN1_OBJECT *type; ++ /* content as defined by the type */ ++ /* all encryption/message digests are applied to the 'contents', ++ * leaving out the 'type' field. */ ++ union { ++ char *ptr; ++ ++ /* NID_pkcs7_data */ ++ ASN1_OCTET_STRING *data; ++ ++ /* NID_pkcs7_signed */ ++ PKCS7_SIGNED *sign; ++ ++ /* NID_pkcs7_enveloped */ ++ PKCS7_ENVELOPE *enveloped; ++ ++ /* NID_pkcs7_signedAndEnveloped */ ++ PKCS7_SIGN_ENVELOPE *signed_and_enveloped; ++ ++ /* NID_pkcs7_digest */ ++ PKCS7_DIGEST *digest; ++ ++ /* NID_pkcs7_encrypted */ ++ PKCS7_ENCRYPT *encrypted; ++ ++ /* Anything else */ ++ ASN1_TYPE *other; ++ } d; ++ } PKCS7; ++ ++DECLARE_STACK_OF(PKCS7) ++DECLARE_ASN1_SET_OF(PKCS7) ++DECLARE_PKCS12_STACK_OF(PKCS7) ++ ++#define PKCS7_OP_SET_DETACHED_SIGNATURE 1 ++#define PKCS7_OP_GET_DETACHED_SIGNATURE 2 ++ ++#define PKCS7_get_signed_attributes(si) ((si)->auth_attr) ++#define PKCS7_get_attributes(si) ((si)->unauth_attr) ++ ++#define PKCS7_type_is_signed(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_signed) ++#define PKCS7_type_is_encrypted(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_encrypted) ++#define PKCS7_type_is_enveloped(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_enveloped) ++#define PKCS7_type_is_signedAndEnveloped(a) \ ++ (OBJ_obj2nid((a)->type) == NID_pkcs7_signedAndEnveloped) ++#define PKCS7_type_is_data(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_data) ++#define PKCS7_type_is_digest(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_digest) ++#define PKCS7_type_is_encrypted(a) \ ++ (OBJ_obj2nid((a)->type) == NID_pkcs7_encrypted) ++ ++#define PKCS7_type_is_digest(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_digest) ++ ++#define PKCS7_set_detached(p,v) \ ++ PKCS7_ctrl(p,PKCS7_OP_SET_DETACHED_SIGNATURE,v,NULL) ++#define PKCS7_get_detached(p) \ ++ PKCS7_ctrl(p,PKCS7_OP_GET_DETACHED_SIGNATURE,0,NULL) ++ ++#define PKCS7_is_detached(p7) (PKCS7_type_is_signed(p7) && PKCS7_get_detached(p7)) ++ ++/* S/MIME related flags */ ++ ++#define PKCS7_TEXT 0x1 ++#define PKCS7_NOCERTS 0x2 ++#define PKCS7_NOSIGS 0x4 ++#define PKCS7_NOCHAIN 0x8 ++#define PKCS7_NOINTERN 0x10 ++#define PKCS7_NOVERIFY 0x20 ++#define PKCS7_DETACHED 0x40 ++#define PKCS7_BINARY 0x80 ++#define PKCS7_NOATTR 0x100 ++#define PKCS7_NOSMIMECAP 0x200 ++#define PKCS7_NOOLDMIMETYPE 0x400 ++#define PKCS7_CRLFEOL 0x800 ++#define PKCS7_STREAM 0x1000 ++#define PKCS7_NOCRL 0x2000 ++#define PKCS7_PARTIAL 0x4000 ++#define PKCS7_REUSE_DIGEST 0x8000 ++ ++/* Flags: for compatibility with older code */ ++ ++#define SMIME_TEXT PKCS7_TEXT ++#define SMIME_NOCERTS PKCS7_NOCERTS ++#define SMIME_NOSIGS PKCS7_NOSIGS ++#define SMIME_NOCHAIN PKCS7_NOCHAIN ++#define SMIME_NOINTERN PKCS7_NOINTERN ++#define SMIME_NOVERIFY PKCS7_NOVERIFY ++#define SMIME_DETACHED PKCS7_DETACHED ++#define SMIME_BINARY PKCS7_BINARY ++#define SMIME_NOATTR PKCS7_NOATTR ++ ++DECLARE_ASN1_FUNCTIONS(PKCS7_ISSUER_AND_SERIAL) ++ ++int PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data,const EVP_MD *type, ++ unsigned char *md,unsigned int *len); ++#ifndef OPENSSL_NO_FP_API ++PKCS7 *d2i_PKCS7_fp(FILE *fp,PKCS7 **p7); ++int i2d_PKCS7_fp(FILE *fp,PKCS7 *p7); ++#endif ++PKCS7 *PKCS7_dup(PKCS7 *p7); ++PKCS7 *d2i_PKCS7_bio(BIO *bp,PKCS7 **p7); ++int i2d_PKCS7_bio(BIO *bp,PKCS7 *p7); ++int i2d_PKCS7_bio_stream(BIO *out, PKCS7 *p7, BIO *in, int flags); ++int PEM_write_bio_PKCS7_stream(BIO *out, PKCS7 *p7, BIO *in, int flags); ++ ++DECLARE_ASN1_FUNCTIONS(PKCS7_SIGNER_INFO) ++DECLARE_ASN1_FUNCTIONS(PKCS7_RECIP_INFO) ++DECLARE_ASN1_FUNCTIONS(PKCS7_SIGNED) ++DECLARE_ASN1_FUNCTIONS(PKCS7_ENC_CONTENT) ++DECLARE_ASN1_FUNCTIONS(PKCS7_ENVELOPE) ++DECLARE_ASN1_FUNCTIONS(PKCS7_SIGN_ENVELOPE) ++DECLARE_ASN1_FUNCTIONS(PKCS7_DIGEST) ++DECLARE_ASN1_FUNCTIONS(PKCS7_ENCRYPT) ++DECLARE_ASN1_FUNCTIONS(PKCS7) ++ ++DECLARE_ASN1_ITEM(PKCS7_ATTR_SIGN) ++DECLARE_ASN1_ITEM(PKCS7_ATTR_VERIFY) ++ ++DECLARE_ASN1_NDEF_FUNCTION(PKCS7) ++DECLARE_ASN1_PRINT_FUNCTION(PKCS7) ++ ++long PKCS7_ctrl(PKCS7 *p7, int cmd, long larg, char *parg); ++ ++int PKCS7_set_type(PKCS7 *p7, int type); ++int PKCS7_set0_type_other(PKCS7 *p7, int type, ASN1_TYPE *other); ++int PKCS7_set_content(PKCS7 *p7, PKCS7 *p7_data); ++int PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO *p7i, X509 *x509, EVP_PKEY *pkey, ++ const EVP_MD *dgst); ++int PKCS7_SIGNER_INFO_sign(PKCS7_SIGNER_INFO *si); ++int PKCS7_add_signer(PKCS7 *p7, PKCS7_SIGNER_INFO *p7i); ++int PKCS7_add_certificate(PKCS7 *p7, X509 *x509); ++int PKCS7_add_crl(PKCS7 *p7, X509_CRL *x509); ++int PKCS7_content_new(PKCS7 *p7, int nid); ++int PKCS7_dataVerify(X509_STORE *cert_store, X509_STORE_CTX *ctx, ++ BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si); ++int PKCS7_signatureVerify(BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si, ++ X509 *x509); ++ ++BIO *PKCS7_dataInit(PKCS7 *p7, BIO *bio); ++int PKCS7_dataFinal(PKCS7 *p7, BIO *bio); ++BIO *PKCS7_dataDecode(PKCS7 *p7, EVP_PKEY *pkey, BIO *in_bio, X509 *pcert); ++ ++ ++PKCS7_SIGNER_INFO *PKCS7_add_signature(PKCS7 *p7, X509 *x509, ++ EVP_PKEY *pkey, const EVP_MD *dgst); ++X509 *PKCS7_cert_from_signer_info(PKCS7 *p7, PKCS7_SIGNER_INFO *si); ++int PKCS7_set_digest(PKCS7 *p7, const EVP_MD *md); ++STACK_OF(PKCS7_SIGNER_INFO) *PKCS7_get_signer_info(PKCS7 *p7); ++ ++PKCS7_RECIP_INFO *PKCS7_add_recipient(PKCS7 *p7, X509 *x509); ++void PKCS7_SIGNER_INFO_get0_algs(PKCS7_SIGNER_INFO *si, EVP_PKEY **pk, ++ X509_ALGOR **pdig, X509_ALGOR **psig); ++void PKCS7_RECIP_INFO_get0_alg(PKCS7_RECIP_INFO *ri, X509_ALGOR **penc); ++int PKCS7_add_recipient_info(PKCS7 *p7, PKCS7_RECIP_INFO *ri); ++int PKCS7_RECIP_INFO_set(PKCS7_RECIP_INFO *p7i, X509 *x509); ++int PKCS7_set_cipher(PKCS7 *p7, const EVP_CIPHER *cipher); ++int PKCS7_stream(unsigned char ***boundary, PKCS7 *p7); ++ ++PKCS7_ISSUER_AND_SERIAL *PKCS7_get_issuer_and_serial(PKCS7 *p7, int idx); ++ASN1_OCTET_STRING *PKCS7_digest_from_attributes(STACK_OF(X509_ATTRIBUTE) *sk); ++int PKCS7_add_signed_attribute(PKCS7_SIGNER_INFO *p7si,int nid,int type, ++ void *data); ++int PKCS7_add_attribute (PKCS7_SIGNER_INFO *p7si, int nid, int atrtype, ++ void *value); ++ASN1_TYPE *PKCS7_get_attribute(PKCS7_SIGNER_INFO *si, int nid); ++ASN1_TYPE *PKCS7_get_signed_attribute(PKCS7_SIGNER_INFO *si, int nid); ++int PKCS7_set_signed_attributes(PKCS7_SIGNER_INFO *p7si, ++ STACK_OF(X509_ATTRIBUTE) *sk); ++int PKCS7_set_attributes(PKCS7_SIGNER_INFO *p7si,STACK_OF(X509_ATTRIBUTE) *sk); ++ ++ ++PKCS7 *PKCS7_sign(X509 *signcert, EVP_PKEY *pkey, STACK_OF(X509) *certs, ++ BIO *data, int flags); ++ ++PKCS7_SIGNER_INFO *PKCS7_sign_add_signer(PKCS7 *p7, ++ X509 *signcert, EVP_PKEY *pkey, const EVP_MD *md, ++ int flags); ++ ++int PKCS7_final(PKCS7 *p7, BIO *data, int flags); ++int PKCS7_verify(PKCS7 *p7, STACK_OF(X509) *certs, X509_STORE *store, ++ BIO *indata, BIO *out, int flags); ++STACK_OF(X509) *PKCS7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs, int flags); ++PKCS7 *PKCS7_encrypt(STACK_OF(X509) *certs, BIO *in, const EVP_CIPHER *cipher, ++ int flags); ++int PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data, int flags); ++ ++int PKCS7_add_attrib_smimecap(PKCS7_SIGNER_INFO *si, ++ STACK_OF(X509_ALGOR) *cap); ++STACK_OF(X509_ALGOR) *PKCS7_get_smimecap(PKCS7_SIGNER_INFO *si); ++int PKCS7_simple_smimecap(STACK_OF(X509_ALGOR) *sk, int nid, int arg); ++ ++int PKCS7_add_attrib_content_type(PKCS7_SIGNER_INFO *si, ASN1_OBJECT *coid); ++int PKCS7_add0_attrib_signing_time(PKCS7_SIGNER_INFO *si, ASN1_TIME *t); ++int PKCS7_add1_attrib_digest(PKCS7_SIGNER_INFO *si, ++ const unsigned char *md, int mdlen); ++ ++int SMIME_write_PKCS7(BIO *bio, PKCS7 *p7, BIO *data, int flags); ++PKCS7 *SMIME_read_PKCS7(BIO *bio, BIO **bcont); ++ ++BIO *BIO_new_PKCS7(BIO *out, PKCS7 *p7); ++ ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_PKCS7_strings(void); ++ ++/* Error codes for the PKCS7 functions. */ ++ ++/* Function codes. */ ++#define PKCS7_F_B64_READ_PKCS7 120 ++#define PKCS7_F_B64_WRITE_PKCS7 121 ++#define PKCS7_F_DO_PKCS7_SIGNED_ATTRIB 136 ++#define PKCS7_F_I2D_PKCS7_BIO_STREAM 140 ++#define PKCS7_F_PKCS7_ADD0_ATTRIB_SIGNING_TIME 135 ++#define PKCS7_F_PKCS7_ADD_ATTRIB_SMIMECAP 118 ++#define PKCS7_F_PKCS7_ADD_CERTIFICATE 100 ++#define PKCS7_F_PKCS7_ADD_CRL 101 ++#define PKCS7_F_PKCS7_ADD_RECIPIENT_INFO 102 ++#define PKCS7_F_PKCS7_ADD_SIGNATURE 131 ++#define PKCS7_F_PKCS7_ADD_SIGNER 103 ++#define PKCS7_F_PKCS7_BIO_ADD_DIGEST 125 ++#define PKCS7_F_PKCS7_COPY_EXISTING_DIGEST 138 ++#define PKCS7_F_PKCS7_CTRL 104 ++#define PKCS7_F_PKCS7_DATADECODE 112 ++#define PKCS7_F_PKCS7_DATAFINAL 128 ++#define PKCS7_F_PKCS7_DATAINIT 105 ++#define PKCS7_F_PKCS7_DATASIGN 106 ++#define PKCS7_F_PKCS7_DATAVERIFY 107 ++#define PKCS7_F_PKCS7_DECRYPT 114 ++#define PKCS7_F_PKCS7_DECRYPT_RINFO 133 ++#define PKCS7_F_PKCS7_ENCODE_RINFO 132 ++#define PKCS7_F_PKCS7_ENCRYPT 115 ++#define PKCS7_F_PKCS7_FINAL 134 ++#define PKCS7_F_PKCS7_FIND_DIGEST 127 ++#define PKCS7_F_PKCS7_GET0_SIGNERS 124 ++#define PKCS7_F_PKCS7_RECIP_INFO_SET 130 ++#define PKCS7_F_PKCS7_SET_CIPHER 108 ++#define PKCS7_F_PKCS7_SET_CONTENT 109 ++#define PKCS7_F_PKCS7_SET_DIGEST 126 ++#define PKCS7_F_PKCS7_SET_TYPE 110 ++#define PKCS7_F_PKCS7_SIGN 116 ++#define PKCS7_F_PKCS7_SIGNATUREVERIFY 113 ++#define PKCS7_F_PKCS7_SIGNER_INFO_SET 129 ++#define PKCS7_F_PKCS7_SIGNER_INFO_SIGN 139 ++#define PKCS7_F_PKCS7_SIGN_ADD_SIGNER 137 ++#define PKCS7_F_PKCS7_SIMPLE_SMIMECAP 119 ++#define PKCS7_F_PKCS7_VERIFY 117 ++#define PKCS7_F_SMIME_READ_PKCS7 122 ++#define PKCS7_F_SMIME_TEXT 123 ++ ++/* Reason codes. */ ++#define PKCS7_R_CERTIFICATE_VERIFY_ERROR 117 ++#define PKCS7_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER 144 ++#define PKCS7_R_CIPHER_NOT_INITIALIZED 116 ++#define PKCS7_R_CONTENT_AND_DATA_PRESENT 118 ++#define PKCS7_R_CTRL_ERROR 152 ++#define PKCS7_R_DECODE_ERROR 130 ++#define PKCS7_R_DECRYPTED_KEY_IS_WRONG_LENGTH 100 ++#define PKCS7_R_DECRYPT_ERROR 119 ++#define PKCS7_R_DIGEST_FAILURE 101 ++#define PKCS7_R_ENCRYPTION_CTRL_FAILURE 149 ++#define PKCS7_R_ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 150 ++#define PKCS7_R_ERROR_ADDING_RECIPIENT 120 ++#define PKCS7_R_ERROR_SETTING_CIPHER 121 ++#define PKCS7_R_INVALID_MIME_TYPE 131 ++#define PKCS7_R_INVALID_NULL_POINTER 143 ++#define PKCS7_R_MIME_NO_CONTENT_TYPE 132 ++#define PKCS7_R_MIME_PARSE_ERROR 133 ++#define PKCS7_R_MIME_SIG_PARSE_ERROR 134 ++#define PKCS7_R_MISSING_CERIPEND_INFO 103 ++#define PKCS7_R_NO_CONTENT 122 ++#define PKCS7_R_NO_CONTENT_TYPE 135 ++#define PKCS7_R_NO_DEFAULT_DIGEST 151 ++#define PKCS7_R_NO_MATCHING_DIGEST_TYPE_FOUND 154 ++#define PKCS7_R_NO_MULTIPART_BODY_FAILURE 136 ++#define PKCS7_R_NO_MULTIPART_BOUNDARY 137 ++#define PKCS7_R_NO_RECIPIENT_MATCHES_CERTIFICATE 115 ++#define PKCS7_R_NO_RECIPIENT_MATCHES_KEY 146 ++#define PKCS7_R_NO_SIGNATURES_ON_DATA 123 ++#define PKCS7_R_NO_SIGNERS 142 ++#define PKCS7_R_NO_SIG_CONTENT_TYPE 138 ++#define PKCS7_R_OPERATION_NOT_SUPPORTED_ON_THIS_TYPE 104 ++#define PKCS7_R_PKCS7_ADD_SIGNATURE_ERROR 124 ++#define PKCS7_R_PKCS7_ADD_SIGNER_ERROR 153 ++#define PKCS7_R_PKCS7_DATAFINAL 126 ++#define PKCS7_R_PKCS7_DATAFINAL_ERROR 125 ++#define PKCS7_R_PKCS7_DATASIGN 145 ++#define PKCS7_R_PKCS7_PARSE_ERROR 139 ++#define PKCS7_R_PKCS7_SIG_PARSE_ERROR 140 ++#define PKCS7_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 127 ++#define PKCS7_R_SIGNATURE_FAILURE 105 ++#define PKCS7_R_SIGNER_CERTIFICATE_NOT_FOUND 128 ++#define PKCS7_R_SIGNING_CTRL_FAILURE 147 ++#define PKCS7_R_SIGNING_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 148 ++#define PKCS7_R_SIG_INVALID_MIME_TYPE 141 ++#define PKCS7_R_SMIME_TEXT_ERROR 129 ++#define PKCS7_R_UNABLE_TO_FIND_CERTIFICATE 106 ++#define PKCS7_R_UNABLE_TO_FIND_MEM_BIO 107 ++#define PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST 108 ++#define PKCS7_R_UNKNOWN_DIGEST_TYPE 109 ++#define PKCS7_R_UNKNOWN_OPERATION 110 ++#define PKCS7_R_UNSUPPORTED_CIPHER_TYPE 111 ++#define PKCS7_R_UNSUPPORTED_CONTENT_TYPE 112 ++#define PKCS7_R_WRONG_CONTENT_TYPE 113 ++#define PKCS7_R_WRONG_PKCS7_TYPE 114 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/pqueue.h qt.patched/include/openssl/pqueue.h +--- qt.orig/include/openssl/pqueue.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/pqueue.h 2010-08-27 12:01:45.524523900 +0200 +@@ -0,0 +1,94 @@ ++/* crypto/pqueue/pqueue.h */ ++/* ++ * DTLS implementation written by Nagendra Modadugu ++ * (nagendra@cs.stanford.edu) for the OpenSSL project 2005. ++ */ ++/* ==================================================================== ++ * Copyright (c) 1999-2005 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * openssl-core@OpenSSL.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++ ++#ifndef HEADER_PQUEUE_H ++#define HEADER_PQUEUE_H ++ ++#include ++#include ++#include ++ ++typedef struct _pqueue *pqueue; ++ ++typedef struct _pitem ++ { ++ unsigned char priority[8]; /* 64-bit value in big-endian encoding */ ++ void *data; ++ struct _pitem *next; ++ } pitem; ++ ++typedef struct _pitem *piterator; ++ ++pitem *pitem_new(unsigned char *prio64be, void *data); ++void pitem_free(pitem *item); ++ ++pqueue pqueue_new(void); ++void pqueue_free(pqueue pq); ++ ++pitem *pqueue_insert(pqueue pq, pitem *item); ++pitem *pqueue_peek(pqueue pq); ++pitem *pqueue_pop(pqueue pq); ++pitem *pqueue_find(pqueue pq, unsigned char *prio64be); ++pitem *pqueue_iterator(pqueue pq); ++pitem *pqueue_next(piterator *iter); ++ ++void pqueue_print(pqueue pq); ++int pqueue_size(pqueue pq); ++ ++#endif /* ! HEADER_PQUEUE_H */ +diff -urN qt.orig/include/openssl/rand.h qt.patched/include/openssl/rand.h +--- qt.orig/include/openssl/rand.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/rand.h 2010-08-27 12:01:45.540148300 +0200 +@@ -0,0 +1,140 @@ ++/* crypto/rand/rand.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_RAND_H ++#define HEADER_RAND_H ++ ++#include ++#include ++#include ++ ++#if defined(OPENSSL_SYS_WINDOWS) ++#include ++#endif ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#if defined(OPENSSL_FIPS) ++#define FIPS_RAND_SIZE_T size_t ++#endif ++ ++/* Already defined in ossl_typ.h */ ++/* typedef struct rand_meth_st RAND_METHOD; */ ++ ++struct rand_meth_st ++ { ++ void (*seed)(const void *buf, int num); ++ int (*bytes)(unsigned char *buf, int num); ++ void (*cleanup)(void); ++ void (*add)(const void *buf, int num, double entropy); ++ int (*pseudorand)(unsigned char *buf, int num); ++ int (*status)(void); ++ }; ++ ++#ifdef BN_DEBUG ++extern int rand_predictable; ++#endif ++ ++int RAND_set_rand_method(const RAND_METHOD *meth); ++const RAND_METHOD *RAND_get_rand_method(void); ++#ifndef OPENSSL_NO_ENGINE ++int RAND_set_rand_engine(ENGINE *engine); ++#endif ++RAND_METHOD *RAND_SSLeay(void); ++void RAND_cleanup(void ); ++int RAND_bytes(unsigned char *buf,int num); ++int RAND_pseudo_bytes(unsigned char *buf,int num); ++void RAND_seed(const void *buf,int num); ++void RAND_add(const void *buf,int num,double entropy); ++int RAND_load_file(const char *file,long max_bytes); ++int RAND_write_file(const char *file); ++const char *RAND_file_name(char *file,size_t num); ++int RAND_status(void); ++int RAND_query_egd_bytes(const char *path, unsigned char *buf, int bytes); ++int RAND_egd(const char *path); ++int RAND_egd_bytes(const char *path,int bytes); ++int RAND_poll(void); ++ ++#if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_WIN32) ++ ++void RAND_screen(void); ++int RAND_event(UINT, WPARAM, LPARAM); ++ ++#endif ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_RAND_strings(void); ++ ++/* Error codes for the RAND functions. */ ++ ++/* Function codes. */ ++#define RAND_F_RAND_GET_RAND_METHOD 101 ++#define RAND_F_SSLEAY_RAND_BYTES 100 ++ ++/* Reason codes. */ ++#define RAND_R_PRNG_NOT_SEEDED 100 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/rc2.h qt.patched/include/openssl/rc2.h +--- qt.orig/include/openssl/rc2.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/rc2.h 2010-08-27 12:01:45.540148300 +0200 +@@ -0,0 +1,101 @@ ++/* crypto/rc2/rc2.h */ ++/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_RC2_H ++#define HEADER_RC2_H ++ ++#include /* OPENSSL_NO_RC2, RC2_INT */ ++#ifdef OPENSSL_NO_RC2 ++#error RC2 is disabled. ++#endif ++ ++#define RC2_ENCRYPT 1 ++#define RC2_DECRYPT 0 ++ ++#define RC2_BLOCK 8 ++#define RC2_KEY_LENGTH 16 ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++typedef struct rc2_key_st ++ { ++ RC2_INT data[64]; ++ } RC2_KEY; ++ ++ ++void RC2_set_key(RC2_KEY *key, int len, const unsigned char *data,int bits); ++void RC2_ecb_encrypt(const unsigned char *in,unsigned char *out,RC2_KEY *key, ++ int enc); ++void RC2_encrypt(unsigned long *data,RC2_KEY *key); ++void RC2_decrypt(unsigned long *data,RC2_KEY *key); ++void RC2_cbc_encrypt(const unsigned char *in, unsigned char *out, long length, ++ RC2_KEY *ks, unsigned char *iv, int enc); ++void RC2_cfb64_encrypt(const unsigned char *in, unsigned char *out, ++ long length, RC2_KEY *schedule, unsigned char *ivec, ++ int *num, int enc); ++void RC2_ofb64_encrypt(const unsigned char *in, unsigned char *out, ++ long length, RC2_KEY *schedule, unsigned char *ivec, ++ int *num); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff -urN qt.orig/include/openssl/rc4.h qt.patched/include/openssl/rc4.h +--- qt.orig/include/openssl/rc4.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/rc4.h 2010-08-27 12:01:45.555772700 +0200 +@@ -0,0 +1,89 @@ ++/* crypto/rc4/rc4.h */ ++/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_RC4_H ++#define HEADER_RC4_H ++ ++#include /* OPENSSL_NO_RC4, RC4_INT */ ++#ifdef OPENSSL_NO_RC4 ++#error RC4 is disabled. ++#endif ++ ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++typedef struct rc4_key_st ++ { ++ RC4_INT x,y; ++ RC4_INT data[256]; ++ } RC4_KEY; ++ ++ ++const char *RC4_options(void); ++void RC4_set_key(RC4_KEY *key, int len, const unsigned char *data); ++void RC4(RC4_KEY *key, size_t len, const unsigned char *indata, ++ unsigned char *outdata); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff -urN qt.orig/include/openssl/ripemd.h qt.patched/include/openssl/ripemd.h +--- qt.orig/include/openssl/ripemd.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/ripemd.h 2010-08-27 12:01:45.571397100 +0200 +@@ -0,0 +1,104 @@ ++/* crypto/ripemd/ripemd.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_RIPEMD_H ++#define HEADER_RIPEMD_H ++ ++#include ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#ifdef OPENSSL_NO_RIPEMD ++#error RIPEMD is disabled. ++#endif ++ ++#if defined(__LP32__) ++#define RIPEMD160_LONG unsigned long ++#elif defined(OPENSSL_SYS_CRAY) || defined(__ILP64__) ++#define RIPEMD160_LONG unsigned long ++#define RIPEMD160_LONG_LOG2 3 ++#else ++#define RIPEMD160_LONG unsigned int ++#endif ++ ++#define RIPEMD160_CBLOCK 64 ++#define RIPEMD160_LBLOCK (RIPEMD160_CBLOCK/4) ++#define RIPEMD160_DIGEST_LENGTH 20 ++ ++typedef struct RIPEMD160state_st ++ { ++ RIPEMD160_LONG A,B,C,D,E; ++ RIPEMD160_LONG Nl,Nh; ++ RIPEMD160_LONG data[RIPEMD160_LBLOCK]; ++ unsigned int num; ++ } RIPEMD160_CTX; ++ ++int RIPEMD160_Init(RIPEMD160_CTX *c); ++int RIPEMD160_Update(RIPEMD160_CTX *c, const void *data, size_t len); ++int RIPEMD160_Final(unsigned char *md, RIPEMD160_CTX *c); ++unsigned char *RIPEMD160(const unsigned char *d, size_t n, ++ unsigned char *md); ++void RIPEMD160_Transform(RIPEMD160_CTX *c, const unsigned char *b); ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff -urN qt.orig/include/openssl/rsa.h qt.patched/include/openssl/rsa.h +--- qt.orig/include/openssl/rsa.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/rsa.h 2010-08-27 12:01:45.571397100 +0200 +@@ -0,0 +1,503 @@ ++/* crypto/rsa/rsa.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_RSA_H ++#define HEADER_RSA_H ++ ++#include ++ ++#ifndef OPENSSL_NO_BIO ++#include ++#endif ++#include ++#include ++#ifndef OPENSSL_NO_DEPRECATED ++#include ++#endif ++ ++#ifdef OPENSSL_NO_RSA ++#error RSA is disabled. ++#endif ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* Declared already in ossl_typ.h */ ++/* typedef struct rsa_st RSA; */ ++/* typedef struct rsa_meth_st RSA_METHOD; */ ++ ++struct rsa_meth_st ++ { ++ const char *name; ++ int (*rsa_pub_enc)(int flen,const unsigned char *from, ++ unsigned char *to, ++ RSA *rsa,int padding); ++ int (*rsa_pub_dec)(int flen,const unsigned char *from, ++ unsigned char *to, ++ RSA *rsa,int padding); ++ int (*rsa_priv_enc)(int flen,const unsigned char *from, ++ unsigned char *to, ++ RSA *rsa,int padding); ++ int (*rsa_priv_dec)(int flen,const unsigned char *from, ++ unsigned char *to, ++ RSA *rsa,int padding); ++ int (*rsa_mod_exp)(BIGNUM *r0,const BIGNUM *I,RSA *rsa,BN_CTX *ctx); /* Can be null */ ++ int (*bn_mod_exp)(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, ++ const BIGNUM *m, BN_CTX *ctx, ++ BN_MONT_CTX *m_ctx); /* Can be null */ ++ int (*init)(RSA *rsa); /* called at new */ ++ int (*finish)(RSA *rsa); /* called at free */ ++ int flags; /* RSA_METHOD_FLAG_* things */ ++ char *app_data; /* may be needed! */ ++/* New sign and verify functions: some libraries don't allow arbitrary data ++ * to be signed/verified: this allows them to be used. Note: for this to work ++ * the RSA_public_decrypt() and RSA_private_encrypt() should *NOT* be used ++ * RSA_sign(), RSA_verify() should be used instead. Note: for backwards ++ * compatibility this functionality is only enabled if the RSA_FLAG_SIGN_VER ++ * option is set in 'flags'. ++ */ ++ int (*rsa_sign)(int type, ++ const unsigned char *m, unsigned int m_length, ++ unsigned char *sigret, unsigned int *siglen, const RSA *rsa); ++ int (*rsa_verify)(int dtype, ++ const unsigned char *m, unsigned int m_length, ++ const unsigned char *sigbuf, unsigned int siglen, ++ const RSA *rsa); ++/* If this callback is NULL, the builtin software RSA key-gen will be used. This ++ * is for behavioural compatibility whilst the code gets rewired, but one day ++ * it would be nice to assume there are no such things as "builtin software" ++ * implementations. */ ++ int (*rsa_keygen)(RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb); ++ }; ++ ++struct rsa_st ++ { ++ /* The first parameter is used to pickup errors where ++ * this is passed instead of aEVP_PKEY, it is set to 0 */ ++ int pad; ++ long version; ++ const RSA_METHOD *meth; ++ /* functional reference if 'meth' is ENGINE-provided */ ++ ENGINE *engine; ++ BIGNUM *n; ++ BIGNUM *e; ++ BIGNUM *d; ++ BIGNUM *p; ++ BIGNUM *q; ++ BIGNUM *dmp1; ++ BIGNUM *dmq1; ++ BIGNUM *iqmp; ++ /* be careful using this if the RSA structure is shared */ ++ CRYPTO_EX_DATA ex_data; ++ int references; ++ int flags; ++ ++ /* Used to cache montgomery values */ ++ BN_MONT_CTX *_method_mod_n; ++ BN_MONT_CTX *_method_mod_p; ++ BN_MONT_CTX *_method_mod_q; ++ ++ /* all BIGNUM values are actually in the following data, if it is not ++ * NULL */ ++ char *bignum_data; ++ BN_BLINDING *blinding; ++ BN_BLINDING *mt_blinding; ++ }; ++ ++#ifndef OPENSSL_RSA_MAX_MODULUS_BITS ++# define OPENSSL_RSA_MAX_MODULUS_BITS 16384 ++#endif ++ ++#ifndef OPENSSL_RSA_SMALL_MODULUS_BITS ++# define OPENSSL_RSA_SMALL_MODULUS_BITS 3072 ++#endif ++#ifndef OPENSSL_RSA_MAX_PUBEXP_BITS ++# define OPENSSL_RSA_MAX_PUBEXP_BITS 64 /* exponent limit enforced for "large" modulus only */ ++#endif ++ ++#define RSA_3 0x3L ++#define RSA_F4 0x10001L ++ ++#define RSA_METHOD_FLAG_NO_CHECK 0x0001 /* don't check pub/private match */ ++ ++#define RSA_FLAG_CACHE_PUBLIC 0x0002 ++#define RSA_FLAG_CACHE_PRIVATE 0x0004 ++#define RSA_FLAG_BLINDING 0x0008 ++#define RSA_FLAG_THREAD_SAFE 0x0010 ++/* This flag means the private key operations will be handled by rsa_mod_exp ++ * and that they do not depend on the private key components being present: ++ * for example a key stored in external hardware. Without this flag bn_mod_exp ++ * gets called when private key components are absent. ++ */ ++#define RSA_FLAG_EXT_PKEY 0x0020 ++ ++/* This flag in the RSA_METHOD enables the new rsa_sign, rsa_verify functions. ++ */ ++#define RSA_FLAG_SIGN_VER 0x0040 ++ ++#define RSA_FLAG_NO_BLINDING 0x0080 /* new with 0.9.6j and 0.9.7b; the built-in ++ * RSA implementation now uses blinding by ++ * default (ignoring RSA_FLAG_BLINDING), ++ * but other engines might not need it ++ */ ++#define RSA_FLAG_NO_CONSTTIME 0x0100 /* new with 0.9.8f; the built-in RSA ++ * implementation now uses constant time ++ * operations by default in private key operations, ++ * e.g., constant time modular exponentiation, ++ * modular inverse without leaking branches, ++ * division without leaking branches. This ++ * flag disables these constant time ++ * operations and results in faster RSA ++ * private key operations. ++ */ ++#ifndef OPENSSL_NO_DEPRECATED ++#define RSA_FLAG_NO_EXP_CONSTTIME RSA_FLAG_NO_CONSTTIME /* deprecated name for the flag*/ ++ /* new with 0.9.7h; the built-in RSA ++ * implementation now uses constant time ++ * modular exponentiation for secret exponents ++ * by default. This flag causes the ++ * faster variable sliding window method to ++ * be used for all exponents. ++ */ ++#endif ++ ++ ++#define EVP_PKEY_CTX_set_rsa_padding(ctx, pad) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, -1, EVP_PKEY_CTRL_RSA_PADDING, \ ++ pad, NULL) ++ ++#define EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, len) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, \ ++ (EVP_PKEY_OP_SIGN|EVP_PKEY_OP_VERIFY), \ ++ EVP_PKEY_CTRL_RSA_PSS_SALTLEN, \ ++ len, NULL) ++ ++#define EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, bits) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_KEYGEN, \ ++ EVP_PKEY_CTRL_RSA_KEYGEN_BITS, bits, NULL) ++ ++#define EVP_PKEY_CTX_set_rsa_keygen_pubexp(ctx, pubexp) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_KEYGEN, \ ++ EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP, 0, pubexp) ++ ++#define EVP_PKEY_CTRL_RSA_PADDING (EVP_PKEY_ALG_CTRL + 1) ++#define EVP_PKEY_CTRL_RSA_PSS_SALTLEN (EVP_PKEY_ALG_CTRL + 2) ++ ++#define EVP_PKEY_CTRL_RSA_KEYGEN_BITS (EVP_PKEY_ALG_CTRL + 3) ++#define EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP (EVP_PKEY_ALG_CTRL + 4) ++ ++#define RSA_PKCS1_PADDING 1 ++#define RSA_SSLV23_PADDING 2 ++#define RSA_NO_PADDING 3 ++#define RSA_PKCS1_OAEP_PADDING 4 ++#define RSA_X931_PADDING 5 ++/* EVP_PKEY_ only */ ++#define RSA_PKCS1_PSS_PADDING 6 ++ ++#define RSA_PKCS1_PADDING_SIZE 11 ++ ++#define RSA_set_app_data(s,arg) RSA_set_ex_data(s,0,arg) ++#define RSA_get_app_data(s) RSA_get_ex_data(s,0) ++ ++RSA * RSA_new(void); ++RSA * RSA_new_method(ENGINE *engine); ++int RSA_size(const RSA *); ++ ++/* Deprecated version */ ++#ifndef OPENSSL_NO_DEPRECATED ++RSA * RSA_generate_key(int bits, unsigned long e,void ++ (*callback)(int,int,void *),void *cb_arg); ++#endif /* !defined(OPENSSL_NO_DEPRECATED) */ ++ ++/* New version */ ++int RSA_generate_key_ex(RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb); ++ ++int RSA_check_key(const RSA *); ++ /* next 4 return -1 on error */ ++int RSA_public_encrypt(int flen, const unsigned char *from, ++ unsigned char *to, RSA *rsa,int padding); ++int RSA_private_encrypt(int flen, const unsigned char *from, ++ unsigned char *to, RSA *rsa,int padding); ++int RSA_public_decrypt(int flen, const unsigned char *from, ++ unsigned char *to, RSA *rsa,int padding); ++int RSA_private_decrypt(int flen, const unsigned char *from, ++ unsigned char *to, RSA *rsa,int padding); ++void RSA_free (RSA *r); ++/* "up" the RSA object's reference count */ ++int RSA_up_ref(RSA *r); ++ ++int RSA_flags(const RSA *r); ++ ++void RSA_set_default_method(const RSA_METHOD *meth); ++const RSA_METHOD *RSA_get_default_method(void); ++const RSA_METHOD *RSA_get_method(const RSA *rsa); ++int RSA_set_method(RSA *rsa, const RSA_METHOD *meth); ++ ++/* This function needs the memory locking malloc callbacks to be installed */ ++int RSA_memory_lock(RSA *r); ++ ++/* these are the actual SSLeay RSA functions */ ++const RSA_METHOD *RSA_PKCS1_SSLeay(void); ++ ++const RSA_METHOD *RSA_null_method(void); ++ ++DECLARE_ASN1_ENCODE_FUNCTIONS_const(RSA, RSAPublicKey) ++DECLARE_ASN1_ENCODE_FUNCTIONS_const(RSA, RSAPrivateKey) ++ ++#ifndef OPENSSL_NO_FP_API ++int RSA_print_fp(FILE *fp, const RSA *r,int offset); ++#endif ++ ++#ifndef OPENSSL_NO_BIO ++int RSA_print(BIO *bp, const RSA *r,int offset); ++#endif ++ ++#ifndef OPENSSL_NO_RC4 ++int i2d_RSA_NET(const RSA *a, unsigned char **pp, ++ int (*cb)(char *buf, int len, const char *prompt, int verify), ++ int sgckey); ++RSA *d2i_RSA_NET(RSA **a, const unsigned char **pp, long length, ++ int (*cb)(char *buf, int len, const char *prompt, int verify), ++ int sgckey); ++ ++int i2d_Netscape_RSA(const RSA *a, unsigned char **pp, ++ int (*cb)(char *buf, int len, const char *prompt, ++ int verify)); ++RSA *d2i_Netscape_RSA(RSA **a, const unsigned char **pp, long length, ++ int (*cb)(char *buf, int len, const char *prompt, ++ int verify)); ++#endif ++ ++/* The following 2 functions sign and verify a X509_SIG ASN1 object ++ * inside PKCS#1 padded RSA encryption */ ++int RSA_sign(int type, const unsigned char *m, unsigned int m_length, ++ unsigned char *sigret, unsigned int *siglen, RSA *rsa); ++int RSA_verify(int type, const unsigned char *m, unsigned int m_length, ++ const unsigned char *sigbuf, unsigned int siglen, RSA *rsa); ++ ++/* The following 2 function sign and verify a ASN1_OCTET_STRING ++ * object inside PKCS#1 padded RSA encryption */ ++int RSA_sign_ASN1_OCTET_STRING(int type, ++ const unsigned char *m, unsigned int m_length, ++ unsigned char *sigret, unsigned int *siglen, RSA *rsa); ++int RSA_verify_ASN1_OCTET_STRING(int type, ++ const unsigned char *m, unsigned int m_length, ++ unsigned char *sigbuf, unsigned int siglen, RSA *rsa); ++ ++int RSA_blinding_on(RSA *rsa, BN_CTX *ctx); ++void RSA_blinding_off(RSA *rsa); ++BN_BLINDING *RSA_setup_blinding(RSA *rsa, BN_CTX *ctx); ++ ++int RSA_padding_add_PKCS1_type_1(unsigned char *to,int tlen, ++ const unsigned char *f,int fl); ++int RSA_padding_check_PKCS1_type_1(unsigned char *to,int tlen, ++ const unsigned char *f,int fl,int rsa_len); ++int RSA_padding_add_PKCS1_type_2(unsigned char *to,int tlen, ++ const unsigned char *f,int fl); ++int RSA_padding_check_PKCS1_type_2(unsigned char *to,int tlen, ++ const unsigned char *f,int fl,int rsa_len); ++int PKCS1_MGF1(unsigned char *mask, long len, ++ const unsigned char *seed, long seedlen, const EVP_MD *dgst); ++int RSA_padding_add_PKCS1_OAEP(unsigned char *to,int tlen, ++ const unsigned char *f,int fl, ++ const unsigned char *p,int pl); ++int RSA_padding_check_PKCS1_OAEP(unsigned char *to,int tlen, ++ const unsigned char *f,int fl,int rsa_len, ++ const unsigned char *p,int pl); ++int RSA_padding_add_SSLv23(unsigned char *to,int tlen, ++ const unsigned char *f,int fl); ++int RSA_padding_check_SSLv23(unsigned char *to,int tlen, ++ const unsigned char *f,int fl,int rsa_len); ++int RSA_padding_add_none(unsigned char *to,int tlen, ++ const unsigned char *f,int fl); ++int RSA_padding_check_none(unsigned char *to,int tlen, ++ const unsigned char *f,int fl,int rsa_len); ++int RSA_padding_add_X931(unsigned char *to,int tlen, ++ const unsigned char *f,int fl); ++int RSA_padding_check_X931(unsigned char *to,int tlen, ++ const unsigned char *f,int fl,int rsa_len); ++int RSA_X931_hash_id(int nid); ++ ++int RSA_verify_PKCS1_PSS(RSA *rsa, const unsigned char *mHash, ++ const EVP_MD *Hash, const unsigned char *EM, int sLen); ++int RSA_padding_add_PKCS1_PSS(RSA *rsa, unsigned char *EM, ++ const unsigned char *mHash, ++ const EVP_MD *Hash, int sLen); ++ ++int RSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, ++ CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func); ++int RSA_set_ex_data(RSA *r,int idx,void *arg); ++void *RSA_get_ex_data(const RSA *r, int idx); ++ ++RSA *RSAPublicKey_dup(RSA *rsa); ++RSA *RSAPrivateKey_dup(RSA *rsa); ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_RSA_strings(void); ++ ++/* Error codes for the RSA functions. */ ++ ++/* Function codes. */ ++#define RSA_F_CHECK_PADDING_MD 140 ++#define RSA_F_DO_RSA_PRINT 146 ++#define RSA_F_INT_RSA_VERIFY 145 ++#define RSA_F_MEMORY_LOCK 100 ++#define RSA_F_OLD_RSA_PRIV_DECODE 147 ++#define RSA_F_PKEY_RSA_CTRL 143 ++#define RSA_F_PKEY_RSA_CTRL_STR 144 ++#define RSA_F_PKEY_RSA_SIGN 142 ++#define RSA_F_PKEY_RSA_VERIFYRECOVER 141 ++#define RSA_F_RSA_BUILTIN_KEYGEN 129 ++#define RSA_F_RSA_CHECK_KEY 123 ++#define RSA_F_RSA_EAY_PRIVATE_DECRYPT 101 ++#define RSA_F_RSA_EAY_PRIVATE_ENCRYPT 102 ++#define RSA_F_RSA_EAY_PUBLIC_DECRYPT 103 ++#define RSA_F_RSA_EAY_PUBLIC_ENCRYPT 104 ++#define RSA_F_RSA_GENERATE_KEY 105 ++#define RSA_F_RSA_MEMORY_LOCK 130 ++#define RSA_F_RSA_NEW_METHOD 106 ++#define RSA_F_RSA_NULL 124 ++#define RSA_F_RSA_NULL_MOD_EXP 131 ++#define RSA_F_RSA_NULL_PRIVATE_DECRYPT 132 ++#define RSA_F_RSA_NULL_PRIVATE_ENCRYPT 133 ++#define RSA_F_RSA_NULL_PUBLIC_DECRYPT 134 ++#define RSA_F_RSA_NULL_PUBLIC_ENCRYPT 135 ++#define RSA_F_RSA_PADDING_ADD_NONE 107 ++#define RSA_F_RSA_PADDING_ADD_PKCS1_OAEP 121 ++#define RSA_F_RSA_PADDING_ADD_PKCS1_PSS 125 ++#define RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_1 108 ++#define RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_2 109 ++#define RSA_F_RSA_PADDING_ADD_SSLV23 110 ++#define RSA_F_RSA_PADDING_ADD_X931 127 ++#define RSA_F_RSA_PADDING_CHECK_NONE 111 ++#define RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP 122 ++#define RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_1 112 ++#define RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_2 113 ++#define RSA_F_RSA_PADDING_CHECK_SSLV23 114 ++#define RSA_F_RSA_PADDING_CHECK_X931 128 ++#define RSA_F_RSA_PRINT 115 ++#define RSA_F_RSA_PRINT_FP 116 ++#define RSA_F_RSA_PRIV_DECODE 137 ++#define RSA_F_RSA_PRIV_ENCODE 138 ++#define RSA_F_RSA_PUB_DECODE 139 ++#define RSA_F_RSA_SETUP_BLINDING 136 ++#define RSA_F_RSA_SIGN 117 ++#define RSA_F_RSA_SIGN_ASN1_OCTET_STRING 118 ++#define RSA_F_RSA_VERIFY 119 ++#define RSA_F_RSA_VERIFY_ASN1_OCTET_STRING 120 ++#define RSA_F_RSA_VERIFY_PKCS1_PSS 126 ++ ++/* Reason codes. */ ++#define RSA_R_ALGORITHM_MISMATCH 100 ++#define RSA_R_BAD_E_VALUE 101 ++#define RSA_R_BAD_FIXED_HEADER_DECRYPT 102 ++#define RSA_R_BAD_PAD_BYTE_COUNT 103 ++#define RSA_R_BAD_SIGNATURE 104 ++#define RSA_R_BLOCK_TYPE_IS_NOT_01 106 ++#define RSA_R_BLOCK_TYPE_IS_NOT_02 107 ++#define RSA_R_DATA_GREATER_THAN_MOD_LEN 108 ++#define RSA_R_DATA_TOO_LARGE 109 ++#define RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE 110 ++#define RSA_R_DATA_TOO_LARGE_FOR_MODULUS 132 ++#define RSA_R_DATA_TOO_SMALL 111 ++#define RSA_R_DATA_TOO_SMALL_FOR_KEY_SIZE 122 ++#define RSA_R_DIGEST_TOO_BIG_FOR_RSA_KEY 112 ++#define RSA_R_DMP1_NOT_CONGRUENT_TO_D 124 ++#define RSA_R_DMQ1_NOT_CONGRUENT_TO_D 125 ++#define RSA_R_D_E_NOT_CONGRUENT_TO_1 123 ++#define RSA_R_FIRST_OCTET_INVALID 133 ++#define RSA_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE 144 ++#define RSA_R_INVALID_DIGEST_LENGTH 143 ++#define RSA_R_INVALID_HEADER 137 ++#define RSA_R_INVALID_KEYBITS 145 ++#define RSA_R_INVALID_MESSAGE_LENGTH 131 ++#define RSA_R_INVALID_PADDING 138 ++#define RSA_R_INVALID_PADDING_MODE 141 ++#define RSA_R_INVALID_PSS_SALTLEN 146 ++#define RSA_R_INVALID_TRAILER 139 ++#define RSA_R_INVALID_X931_DIGEST 142 ++#define RSA_R_IQMP_NOT_INVERSE_OF_Q 126 ++#define RSA_R_KEY_SIZE_TOO_SMALL 120 ++#define RSA_R_LAST_OCTET_INVALID 134 ++#define RSA_R_MODULUS_TOO_LARGE 105 ++#define RSA_R_NO_PUBLIC_EXPONENT 140 ++#define RSA_R_NULL_BEFORE_BLOCK_MISSING 113 ++#define RSA_R_N_DOES_NOT_EQUAL_P_Q 127 ++#define RSA_R_OAEP_DECODING_ERROR 121 ++#define RSA_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE 148 ++#define RSA_R_PADDING_CHECK_FAILED 114 ++#define RSA_R_P_NOT_PRIME 128 ++#define RSA_R_Q_NOT_PRIME 129 ++#define RSA_R_RSA_OPERATIONS_NOT_SUPPORTED 130 ++#define RSA_R_SLEN_CHECK_FAILED 136 ++#define RSA_R_SLEN_RECOVERY_FAILED 135 ++#define RSA_R_SSLV3_ROLLBACK_ATTACK 115 ++#define RSA_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD 116 ++#define RSA_R_UNKNOWN_ALGORITHM_TYPE 117 ++#define RSA_R_UNKNOWN_PADDING_TYPE 118 ++#define RSA_R_VALUE_MISSING 147 ++#define RSA_R_WRONG_SIGNATURE_LENGTH 119 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/safestack.h qt.patched/include/openssl/safestack.h +--- qt.orig/include/openssl/safestack.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/safestack.h 2010-08-27 12:01:45.602645900 +0200 +@@ -0,0 +1,2574 @@ ++/* ==================================================================== ++ * Copyright (c) 1999 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * openssl-core@openssl.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.openssl.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++ ++#ifndef HEADER_SAFESTACK_H ++#define HEADER_SAFESTACK_H ++ ++#include ++ ++#ifndef CHECKED_PTR_OF ++#define CHECKED_PTR_OF(type, p) \ ++ ((void*) (1 ? p : (type*)0)) ++#endif ++ ++/* In C++ we get problems because an explicit cast is needed from (void *) ++ * we use CHECKED_STACK_OF to ensure the correct type is passed in the macros ++ * below. ++ */ ++ ++#define CHECKED_STACK_OF(type, p) \ ++ ((_STACK*) (1 ? p : (STACK_OF(type)*)0)) ++ ++#define CHECKED_SK_FREE_FUNC(type, p) \ ++ ((void (*)(void *)) ((1 ? p : (void (*)(type *))0))) ++ ++#define CHECKED_SK_FREE_FUNC2(type, p) \ ++ ((void (*)(void *)) ((1 ? p : (void (*)(type))0))) ++ ++#define CHECKED_SK_CMP_FUNC(type, p) \ ++ ((int (*)(const void *, const void *)) \ ++ ((1 ? p : (int (*)(const type * const *, const type * const *))0))) ++ ++#define STACK_OF(type) struct stack_st_##type ++#define PREDECLARE_STACK_OF(type) STACK_OF(type); ++ ++#define DECLARE_STACK_OF(type) \ ++STACK_OF(type) \ ++ { \ ++ _STACK stack; \ ++ }; ++#define DECLARE_SPECIAL_STACK_OF(type, type2) \ ++STACK_OF(type) \ ++ { \ ++ _STACK stack; \ ++ }; ++ ++#define IMPLEMENT_STACK_OF(type) /* nada (obsolete in new safestack approach)*/ ++ ++ ++/* Strings are special: normally an lhash entry will point to a single ++ * (somewhat) mutable object. In the case of strings: ++ * ++ * a) Instead of a single char, there is an array of chars, NUL-terminated. ++ * b) The string may have be immutable. ++ * ++ * So, they need their own declarations. Especially important for ++ * type-checking tools, such as Deputy. ++ * ++o * In practice, however, it appears to be hard to have a const ++ * string. For now, I'm settling for dealing with the fact it is a ++ * string at all. ++ */ ++typedef char *OPENSSL_STRING; ++ ++typedef const char *OPENSSL_CSTRING; ++ ++/* Confusingly, LHASH_OF(STRING) deals with char ** throughout, but ++ * STACK_OF(STRING) is really more like STACK_OF(char), only, as ++ * mentioned above, instead of a single char each entry is a ++ * NUL-terminated array of chars. So, we have to implement STRING ++ * specially for STACK_OF. This is dealt with in the autogenerated ++ * macros below. ++ */ ++ ++DECLARE_SPECIAL_STACK_OF(OPENSSL_STRING, char) ++ ++/* Similarly, we sometimes use a block of characters, NOT ++ * nul-terminated. These should also be distinguished from "normal" ++ * stacks. */ ++ ++typedef void *OPENSSL_BLOCK; ++DECLARE_SPECIAL_STACK_OF(OPENSSL_BLOCK, void) ++ ++/* SKM_sk_... stack macros are internal to safestack.h: ++ * never use them directly, use sk__... instead */ ++#define SKM_sk_new(type, cmp) \ ++ ((STACK_OF(type) *)sk_new(CHECKED_SK_CMP_FUNC(type, cmp))) ++#define SKM_sk_new_null(type) \ ++ ((STACK_OF(type) *)sk_new_null()) ++#define SKM_sk_free(type, st) \ ++ sk_free(CHECKED_STACK_OF(type, st)) ++#define SKM_sk_num(type, st) \ ++ sk_num(CHECKED_STACK_OF(type, st)) ++#define SKM_sk_value(type, st,i) \ ++ ((type *)sk_value(CHECKED_STACK_OF(type, st), i)) ++#define SKM_sk_set(type, st,i,val) \ ++ sk_set(CHECKED_STACK_OF(type, st), i, CHECKED_PTR_OF(type, val)) ++#define SKM_sk_zero(type, st) \ ++ sk_zero(CHECKED_STACK_OF(type, st)) ++#define SKM_sk_push(type, st, val) \ ++ sk_push(CHECKED_STACK_OF(type, st), CHECKED_PTR_OF(type, val)) ++#define SKM_sk_unshift(type, st, val) \ ++ sk_unshift(CHECKED_STACK_OF(type, st), CHECKED_PTR_OF(type, val)) ++#define SKM_sk_find(type, st, val) \ ++ sk_find(CHECKED_STACK_OF(type, st), CHECKED_PTR_OF(type, val)) ++#define SKM_sk_find_ex(type, st, val) \ ++ sk_find_ex(CHECKED_STACK_OF(type, st), \ ++ CHECKED_PTR_OF(type, val)) ++#define SKM_sk_delete(type, st, i) \ ++ (type *)sk_delete(CHECKED_STACK_OF(type, st), i) ++#define SKM_sk_delete_ptr(type, st, ptr) \ ++ (type *)sk_delete_ptr(CHECKED_STACK_OF(type, st), CHECKED_PTR_OF(type, ptr)) ++#define SKM_sk_insert(type, st,val, i) \ ++ sk_insert(CHECKED_STACK_OF(type, st), CHECKED_PTR_OF(type, val), i) ++#define SKM_sk_set_cmp_func(type, st, cmp) \ ++ ((int (*)(const type * const *,const type * const *)) \ ++ sk_set_cmp_func(CHECKED_STACK_OF(type, st), CHECKED_SK_CMP_FUNC(type, cmp))) ++#define SKM_sk_dup(type, st) \ ++ (STACK_OF(type) *)sk_dup(CHECKED_STACK_OF(type, st)) ++#define SKM_sk_pop_free(type, st, free_func) \ ++ sk_pop_free(CHECKED_STACK_OF(type, st), CHECKED_SK_FREE_FUNC(type, free_func)) ++#define SKM_sk_shift(type, st) \ ++ (type *)sk_shift(CHECKED_STACK_OF(type, st)) ++#define SKM_sk_pop(type, st) \ ++ (type *)sk_pop(CHECKED_STACK_OF(type, st)) ++#define SKM_sk_sort(type, st) \ ++ sk_sort(CHECKED_STACK_OF(type, st)) ++#define SKM_sk_is_sorted(type, st) \ ++ sk_is_sorted(CHECKED_STACK_OF(type, st)) ++ ++#define SKM_ASN1_SET_OF_d2i(type, st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ (STACK_OF(type) *)d2i_ASN1_SET((STACK_OF(OPENSSL_BLOCK) **)CHECKED_STACK_OF(type, st), \ ++ pp, length, \ ++ CHECKED_D2I_OF(type, d2i_func), \ ++ CHECKED_SK_FREE_FUNC(type, free_func), \ ++ ex_tag, ex_class) ++ ++#define SKM_ASN1_SET_OF_i2d(type, st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ i2d_ASN1_SET((STACK_OF(OPENSSL_BLOCK) *)CHECKED_STACK_OF(type, st), pp, \ ++ CHECKED_I2D_OF(type, i2d_func), \ ++ ex_tag, ex_class, is_set) ++ ++#define SKM_ASN1_seq_pack(type, st, i2d_func, buf, len) \ ++ ASN1_seq_pack(CHECKED_PTR_OF(STACK_OF(type), st), \ ++ CHECKED_I2D_OF(type, i2d_func), buf, len) ++ ++#define SKM_ASN1_seq_unpack(type, buf, len, d2i_func, free_func) \ ++ (STACK_OF(type) *)ASN1_seq_unpack(buf, len, CHECKED_D2I_OF(type, d2i_func), CHECKED_SK_FREE_FUNC(type, free_func)) ++ ++#define SKM_PKCS12_decrypt_d2i(type, algor, d2i_func, free_func, pass, passlen, oct, seq) \ ++ (STACK_OF(type) *)PKCS12_decrypt_d2i(algor, \ ++ CHECKED_D2I_OF(type, d2i_func), \ ++ CHECKED_SK_FREE_FUNC(type, free_func), \ ++ pass, passlen, oct, seq) ++ ++/* This block of defines is updated by util/mkstack.pl, please do not touch! */ ++#define sk_ACCESS_DESCRIPTION_new(cmp) SKM_sk_new(ACCESS_DESCRIPTION, (cmp)) ++#define sk_ACCESS_DESCRIPTION_new_null() SKM_sk_new_null(ACCESS_DESCRIPTION) ++#define sk_ACCESS_DESCRIPTION_free(st) SKM_sk_free(ACCESS_DESCRIPTION, (st)) ++#define sk_ACCESS_DESCRIPTION_num(st) SKM_sk_num(ACCESS_DESCRIPTION, (st)) ++#define sk_ACCESS_DESCRIPTION_value(st, i) SKM_sk_value(ACCESS_DESCRIPTION, (st), (i)) ++#define sk_ACCESS_DESCRIPTION_set(st, i, val) SKM_sk_set(ACCESS_DESCRIPTION, (st), (i), (val)) ++#define sk_ACCESS_DESCRIPTION_zero(st) SKM_sk_zero(ACCESS_DESCRIPTION, (st)) ++#define sk_ACCESS_DESCRIPTION_push(st, val) SKM_sk_push(ACCESS_DESCRIPTION, (st), (val)) ++#define sk_ACCESS_DESCRIPTION_unshift(st, val) SKM_sk_unshift(ACCESS_DESCRIPTION, (st), (val)) ++#define sk_ACCESS_DESCRIPTION_find(st, val) SKM_sk_find(ACCESS_DESCRIPTION, (st), (val)) ++#define sk_ACCESS_DESCRIPTION_find_ex(st, val) SKM_sk_find_ex(ACCESS_DESCRIPTION, (st), (val)) ++#define sk_ACCESS_DESCRIPTION_delete(st, i) SKM_sk_delete(ACCESS_DESCRIPTION, (st), (i)) ++#define sk_ACCESS_DESCRIPTION_delete_ptr(st, ptr) SKM_sk_delete_ptr(ACCESS_DESCRIPTION, (st), (ptr)) ++#define sk_ACCESS_DESCRIPTION_insert(st, val, i) SKM_sk_insert(ACCESS_DESCRIPTION, (st), (val), (i)) ++#define sk_ACCESS_DESCRIPTION_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ACCESS_DESCRIPTION, (st), (cmp)) ++#define sk_ACCESS_DESCRIPTION_dup(st) SKM_sk_dup(ACCESS_DESCRIPTION, st) ++#define sk_ACCESS_DESCRIPTION_pop_free(st, free_func) SKM_sk_pop_free(ACCESS_DESCRIPTION, (st), (free_func)) ++#define sk_ACCESS_DESCRIPTION_shift(st) SKM_sk_shift(ACCESS_DESCRIPTION, (st)) ++#define sk_ACCESS_DESCRIPTION_pop(st) SKM_sk_pop(ACCESS_DESCRIPTION, (st)) ++#define sk_ACCESS_DESCRIPTION_sort(st) SKM_sk_sort(ACCESS_DESCRIPTION, (st)) ++#define sk_ACCESS_DESCRIPTION_is_sorted(st) SKM_sk_is_sorted(ACCESS_DESCRIPTION, (st)) ++ ++#define sk_ASIdOrRange_new(cmp) SKM_sk_new(ASIdOrRange, (cmp)) ++#define sk_ASIdOrRange_new_null() SKM_sk_new_null(ASIdOrRange) ++#define sk_ASIdOrRange_free(st) SKM_sk_free(ASIdOrRange, (st)) ++#define sk_ASIdOrRange_num(st) SKM_sk_num(ASIdOrRange, (st)) ++#define sk_ASIdOrRange_value(st, i) SKM_sk_value(ASIdOrRange, (st), (i)) ++#define sk_ASIdOrRange_set(st, i, val) SKM_sk_set(ASIdOrRange, (st), (i), (val)) ++#define sk_ASIdOrRange_zero(st) SKM_sk_zero(ASIdOrRange, (st)) ++#define sk_ASIdOrRange_push(st, val) SKM_sk_push(ASIdOrRange, (st), (val)) ++#define sk_ASIdOrRange_unshift(st, val) SKM_sk_unshift(ASIdOrRange, (st), (val)) ++#define sk_ASIdOrRange_find(st, val) SKM_sk_find(ASIdOrRange, (st), (val)) ++#define sk_ASIdOrRange_find_ex(st, val) SKM_sk_find_ex(ASIdOrRange, (st), (val)) ++#define sk_ASIdOrRange_delete(st, i) SKM_sk_delete(ASIdOrRange, (st), (i)) ++#define sk_ASIdOrRange_delete_ptr(st, ptr) SKM_sk_delete_ptr(ASIdOrRange, (st), (ptr)) ++#define sk_ASIdOrRange_insert(st, val, i) SKM_sk_insert(ASIdOrRange, (st), (val), (i)) ++#define sk_ASIdOrRange_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ASIdOrRange, (st), (cmp)) ++#define sk_ASIdOrRange_dup(st) SKM_sk_dup(ASIdOrRange, st) ++#define sk_ASIdOrRange_pop_free(st, free_func) SKM_sk_pop_free(ASIdOrRange, (st), (free_func)) ++#define sk_ASIdOrRange_shift(st) SKM_sk_shift(ASIdOrRange, (st)) ++#define sk_ASIdOrRange_pop(st) SKM_sk_pop(ASIdOrRange, (st)) ++#define sk_ASIdOrRange_sort(st) SKM_sk_sort(ASIdOrRange, (st)) ++#define sk_ASIdOrRange_is_sorted(st) SKM_sk_is_sorted(ASIdOrRange, (st)) ++ ++#define sk_ASN1_GENERALSTRING_new(cmp) SKM_sk_new(ASN1_GENERALSTRING, (cmp)) ++#define sk_ASN1_GENERALSTRING_new_null() SKM_sk_new_null(ASN1_GENERALSTRING) ++#define sk_ASN1_GENERALSTRING_free(st) SKM_sk_free(ASN1_GENERALSTRING, (st)) ++#define sk_ASN1_GENERALSTRING_num(st) SKM_sk_num(ASN1_GENERALSTRING, (st)) ++#define sk_ASN1_GENERALSTRING_value(st, i) SKM_sk_value(ASN1_GENERALSTRING, (st), (i)) ++#define sk_ASN1_GENERALSTRING_set(st, i, val) SKM_sk_set(ASN1_GENERALSTRING, (st), (i), (val)) ++#define sk_ASN1_GENERALSTRING_zero(st) SKM_sk_zero(ASN1_GENERALSTRING, (st)) ++#define sk_ASN1_GENERALSTRING_push(st, val) SKM_sk_push(ASN1_GENERALSTRING, (st), (val)) ++#define sk_ASN1_GENERALSTRING_unshift(st, val) SKM_sk_unshift(ASN1_GENERALSTRING, (st), (val)) ++#define sk_ASN1_GENERALSTRING_find(st, val) SKM_sk_find(ASN1_GENERALSTRING, (st), (val)) ++#define sk_ASN1_GENERALSTRING_find_ex(st, val) SKM_sk_find_ex(ASN1_GENERALSTRING, (st), (val)) ++#define sk_ASN1_GENERALSTRING_delete(st, i) SKM_sk_delete(ASN1_GENERALSTRING, (st), (i)) ++#define sk_ASN1_GENERALSTRING_delete_ptr(st, ptr) SKM_sk_delete_ptr(ASN1_GENERALSTRING, (st), (ptr)) ++#define sk_ASN1_GENERALSTRING_insert(st, val, i) SKM_sk_insert(ASN1_GENERALSTRING, (st), (val), (i)) ++#define sk_ASN1_GENERALSTRING_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ASN1_GENERALSTRING, (st), (cmp)) ++#define sk_ASN1_GENERALSTRING_dup(st) SKM_sk_dup(ASN1_GENERALSTRING, st) ++#define sk_ASN1_GENERALSTRING_pop_free(st, free_func) SKM_sk_pop_free(ASN1_GENERALSTRING, (st), (free_func)) ++#define sk_ASN1_GENERALSTRING_shift(st) SKM_sk_shift(ASN1_GENERALSTRING, (st)) ++#define sk_ASN1_GENERALSTRING_pop(st) SKM_sk_pop(ASN1_GENERALSTRING, (st)) ++#define sk_ASN1_GENERALSTRING_sort(st) SKM_sk_sort(ASN1_GENERALSTRING, (st)) ++#define sk_ASN1_GENERALSTRING_is_sorted(st) SKM_sk_is_sorted(ASN1_GENERALSTRING, (st)) ++ ++#define sk_ASN1_INTEGER_new(cmp) SKM_sk_new(ASN1_INTEGER, (cmp)) ++#define sk_ASN1_INTEGER_new_null() SKM_sk_new_null(ASN1_INTEGER) ++#define sk_ASN1_INTEGER_free(st) SKM_sk_free(ASN1_INTEGER, (st)) ++#define sk_ASN1_INTEGER_num(st) SKM_sk_num(ASN1_INTEGER, (st)) ++#define sk_ASN1_INTEGER_value(st, i) SKM_sk_value(ASN1_INTEGER, (st), (i)) ++#define sk_ASN1_INTEGER_set(st, i, val) SKM_sk_set(ASN1_INTEGER, (st), (i), (val)) ++#define sk_ASN1_INTEGER_zero(st) SKM_sk_zero(ASN1_INTEGER, (st)) ++#define sk_ASN1_INTEGER_push(st, val) SKM_sk_push(ASN1_INTEGER, (st), (val)) ++#define sk_ASN1_INTEGER_unshift(st, val) SKM_sk_unshift(ASN1_INTEGER, (st), (val)) ++#define sk_ASN1_INTEGER_find(st, val) SKM_sk_find(ASN1_INTEGER, (st), (val)) ++#define sk_ASN1_INTEGER_find_ex(st, val) SKM_sk_find_ex(ASN1_INTEGER, (st), (val)) ++#define sk_ASN1_INTEGER_delete(st, i) SKM_sk_delete(ASN1_INTEGER, (st), (i)) ++#define sk_ASN1_INTEGER_delete_ptr(st, ptr) SKM_sk_delete_ptr(ASN1_INTEGER, (st), (ptr)) ++#define sk_ASN1_INTEGER_insert(st, val, i) SKM_sk_insert(ASN1_INTEGER, (st), (val), (i)) ++#define sk_ASN1_INTEGER_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ASN1_INTEGER, (st), (cmp)) ++#define sk_ASN1_INTEGER_dup(st) SKM_sk_dup(ASN1_INTEGER, st) ++#define sk_ASN1_INTEGER_pop_free(st, free_func) SKM_sk_pop_free(ASN1_INTEGER, (st), (free_func)) ++#define sk_ASN1_INTEGER_shift(st) SKM_sk_shift(ASN1_INTEGER, (st)) ++#define sk_ASN1_INTEGER_pop(st) SKM_sk_pop(ASN1_INTEGER, (st)) ++#define sk_ASN1_INTEGER_sort(st) SKM_sk_sort(ASN1_INTEGER, (st)) ++#define sk_ASN1_INTEGER_is_sorted(st) SKM_sk_is_sorted(ASN1_INTEGER, (st)) ++ ++#define sk_ASN1_OBJECT_new(cmp) SKM_sk_new(ASN1_OBJECT, (cmp)) ++#define sk_ASN1_OBJECT_new_null() SKM_sk_new_null(ASN1_OBJECT) ++#define sk_ASN1_OBJECT_free(st) SKM_sk_free(ASN1_OBJECT, (st)) ++#define sk_ASN1_OBJECT_num(st) SKM_sk_num(ASN1_OBJECT, (st)) ++#define sk_ASN1_OBJECT_value(st, i) SKM_sk_value(ASN1_OBJECT, (st), (i)) ++#define sk_ASN1_OBJECT_set(st, i, val) SKM_sk_set(ASN1_OBJECT, (st), (i), (val)) ++#define sk_ASN1_OBJECT_zero(st) SKM_sk_zero(ASN1_OBJECT, (st)) ++#define sk_ASN1_OBJECT_push(st, val) SKM_sk_push(ASN1_OBJECT, (st), (val)) ++#define sk_ASN1_OBJECT_unshift(st, val) SKM_sk_unshift(ASN1_OBJECT, (st), (val)) ++#define sk_ASN1_OBJECT_find(st, val) SKM_sk_find(ASN1_OBJECT, (st), (val)) ++#define sk_ASN1_OBJECT_find_ex(st, val) SKM_sk_find_ex(ASN1_OBJECT, (st), (val)) ++#define sk_ASN1_OBJECT_delete(st, i) SKM_sk_delete(ASN1_OBJECT, (st), (i)) ++#define sk_ASN1_OBJECT_delete_ptr(st, ptr) SKM_sk_delete_ptr(ASN1_OBJECT, (st), (ptr)) ++#define sk_ASN1_OBJECT_insert(st, val, i) SKM_sk_insert(ASN1_OBJECT, (st), (val), (i)) ++#define sk_ASN1_OBJECT_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ASN1_OBJECT, (st), (cmp)) ++#define sk_ASN1_OBJECT_dup(st) SKM_sk_dup(ASN1_OBJECT, st) ++#define sk_ASN1_OBJECT_pop_free(st, free_func) SKM_sk_pop_free(ASN1_OBJECT, (st), (free_func)) ++#define sk_ASN1_OBJECT_shift(st) SKM_sk_shift(ASN1_OBJECT, (st)) ++#define sk_ASN1_OBJECT_pop(st) SKM_sk_pop(ASN1_OBJECT, (st)) ++#define sk_ASN1_OBJECT_sort(st) SKM_sk_sort(ASN1_OBJECT, (st)) ++#define sk_ASN1_OBJECT_is_sorted(st) SKM_sk_is_sorted(ASN1_OBJECT, (st)) ++ ++#define sk_ASN1_STRING_TABLE_new(cmp) SKM_sk_new(ASN1_STRING_TABLE, (cmp)) ++#define sk_ASN1_STRING_TABLE_new_null() SKM_sk_new_null(ASN1_STRING_TABLE) ++#define sk_ASN1_STRING_TABLE_free(st) SKM_sk_free(ASN1_STRING_TABLE, (st)) ++#define sk_ASN1_STRING_TABLE_num(st) SKM_sk_num(ASN1_STRING_TABLE, (st)) ++#define sk_ASN1_STRING_TABLE_value(st, i) SKM_sk_value(ASN1_STRING_TABLE, (st), (i)) ++#define sk_ASN1_STRING_TABLE_set(st, i, val) SKM_sk_set(ASN1_STRING_TABLE, (st), (i), (val)) ++#define sk_ASN1_STRING_TABLE_zero(st) SKM_sk_zero(ASN1_STRING_TABLE, (st)) ++#define sk_ASN1_STRING_TABLE_push(st, val) SKM_sk_push(ASN1_STRING_TABLE, (st), (val)) ++#define sk_ASN1_STRING_TABLE_unshift(st, val) SKM_sk_unshift(ASN1_STRING_TABLE, (st), (val)) ++#define sk_ASN1_STRING_TABLE_find(st, val) SKM_sk_find(ASN1_STRING_TABLE, (st), (val)) ++#define sk_ASN1_STRING_TABLE_find_ex(st, val) SKM_sk_find_ex(ASN1_STRING_TABLE, (st), (val)) ++#define sk_ASN1_STRING_TABLE_delete(st, i) SKM_sk_delete(ASN1_STRING_TABLE, (st), (i)) ++#define sk_ASN1_STRING_TABLE_delete_ptr(st, ptr) SKM_sk_delete_ptr(ASN1_STRING_TABLE, (st), (ptr)) ++#define sk_ASN1_STRING_TABLE_insert(st, val, i) SKM_sk_insert(ASN1_STRING_TABLE, (st), (val), (i)) ++#define sk_ASN1_STRING_TABLE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ASN1_STRING_TABLE, (st), (cmp)) ++#define sk_ASN1_STRING_TABLE_dup(st) SKM_sk_dup(ASN1_STRING_TABLE, st) ++#define sk_ASN1_STRING_TABLE_pop_free(st, free_func) SKM_sk_pop_free(ASN1_STRING_TABLE, (st), (free_func)) ++#define sk_ASN1_STRING_TABLE_shift(st) SKM_sk_shift(ASN1_STRING_TABLE, (st)) ++#define sk_ASN1_STRING_TABLE_pop(st) SKM_sk_pop(ASN1_STRING_TABLE, (st)) ++#define sk_ASN1_STRING_TABLE_sort(st) SKM_sk_sort(ASN1_STRING_TABLE, (st)) ++#define sk_ASN1_STRING_TABLE_is_sorted(st) SKM_sk_is_sorted(ASN1_STRING_TABLE, (st)) ++ ++#define sk_ASN1_TYPE_new(cmp) SKM_sk_new(ASN1_TYPE, (cmp)) ++#define sk_ASN1_TYPE_new_null() SKM_sk_new_null(ASN1_TYPE) ++#define sk_ASN1_TYPE_free(st) SKM_sk_free(ASN1_TYPE, (st)) ++#define sk_ASN1_TYPE_num(st) SKM_sk_num(ASN1_TYPE, (st)) ++#define sk_ASN1_TYPE_value(st, i) SKM_sk_value(ASN1_TYPE, (st), (i)) ++#define sk_ASN1_TYPE_set(st, i, val) SKM_sk_set(ASN1_TYPE, (st), (i), (val)) ++#define sk_ASN1_TYPE_zero(st) SKM_sk_zero(ASN1_TYPE, (st)) ++#define sk_ASN1_TYPE_push(st, val) SKM_sk_push(ASN1_TYPE, (st), (val)) ++#define sk_ASN1_TYPE_unshift(st, val) SKM_sk_unshift(ASN1_TYPE, (st), (val)) ++#define sk_ASN1_TYPE_find(st, val) SKM_sk_find(ASN1_TYPE, (st), (val)) ++#define sk_ASN1_TYPE_find_ex(st, val) SKM_sk_find_ex(ASN1_TYPE, (st), (val)) ++#define sk_ASN1_TYPE_delete(st, i) SKM_sk_delete(ASN1_TYPE, (st), (i)) ++#define sk_ASN1_TYPE_delete_ptr(st, ptr) SKM_sk_delete_ptr(ASN1_TYPE, (st), (ptr)) ++#define sk_ASN1_TYPE_insert(st, val, i) SKM_sk_insert(ASN1_TYPE, (st), (val), (i)) ++#define sk_ASN1_TYPE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ASN1_TYPE, (st), (cmp)) ++#define sk_ASN1_TYPE_dup(st) SKM_sk_dup(ASN1_TYPE, st) ++#define sk_ASN1_TYPE_pop_free(st, free_func) SKM_sk_pop_free(ASN1_TYPE, (st), (free_func)) ++#define sk_ASN1_TYPE_shift(st) SKM_sk_shift(ASN1_TYPE, (st)) ++#define sk_ASN1_TYPE_pop(st) SKM_sk_pop(ASN1_TYPE, (st)) ++#define sk_ASN1_TYPE_sort(st) SKM_sk_sort(ASN1_TYPE, (st)) ++#define sk_ASN1_TYPE_is_sorted(st) SKM_sk_is_sorted(ASN1_TYPE, (st)) ++ ++#define sk_ASN1_UTF8STRING_new(cmp) SKM_sk_new(ASN1_UTF8STRING, (cmp)) ++#define sk_ASN1_UTF8STRING_new_null() SKM_sk_new_null(ASN1_UTF8STRING) ++#define sk_ASN1_UTF8STRING_free(st) SKM_sk_free(ASN1_UTF8STRING, (st)) ++#define sk_ASN1_UTF8STRING_num(st) SKM_sk_num(ASN1_UTF8STRING, (st)) ++#define sk_ASN1_UTF8STRING_value(st, i) SKM_sk_value(ASN1_UTF8STRING, (st), (i)) ++#define sk_ASN1_UTF8STRING_set(st, i, val) SKM_sk_set(ASN1_UTF8STRING, (st), (i), (val)) ++#define sk_ASN1_UTF8STRING_zero(st) SKM_sk_zero(ASN1_UTF8STRING, (st)) ++#define sk_ASN1_UTF8STRING_push(st, val) SKM_sk_push(ASN1_UTF8STRING, (st), (val)) ++#define sk_ASN1_UTF8STRING_unshift(st, val) SKM_sk_unshift(ASN1_UTF8STRING, (st), (val)) ++#define sk_ASN1_UTF8STRING_find(st, val) SKM_sk_find(ASN1_UTF8STRING, (st), (val)) ++#define sk_ASN1_UTF8STRING_find_ex(st, val) SKM_sk_find_ex(ASN1_UTF8STRING, (st), (val)) ++#define sk_ASN1_UTF8STRING_delete(st, i) SKM_sk_delete(ASN1_UTF8STRING, (st), (i)) ++#define sk_ASN1_UTF8STRING_delete_ptr(st, ptr) SKM_sk_delete_ptr(ASN1_UTF8STRING, (st), (ptr)) ++#define sk_ASN1_UTF8STRING_insert(st, val, i) SKM_sk_insert(ASN1_UTF8STRING, (st), (val), (i)) ++#define sk_ASN1_UTF8STRING_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ASN1_UTF8STRING, (st), (cmp)) ++#define sk_ASN1_UTF8STRING_dup(st) SKM_sk_dup(ASN1_UTF8STRING, st) ++#define sk_ASN1_UTF8STRING_pop_free(st, free_func) SKM_sk_pop_free(ASN1_UTF8STRING, (st), (free_func)) ++#define sk_ASN1_UTF8STRING_shift(st) SKM_sk_shift(ASN1_UTF8STRING, (st)) ++#define sk_ASN1_UTF8STRING_pop(st) SKM_sk_pop(ASN1_UTF8STRING, (st)) ++#define sk_ASN1_UTF8STRING_sort(st) SKM_sk_sort(ASN1_UTF8STRING, (st)) ++#define sk_ASN1_UTF8STRING_is_sorted(st) SKM_sk_is_sorted(ASN1_UTF8STRING, (st)) ++ ++#define sk_ASN1_VALUE_new(cmp) SKM_sk_new(ASN1_VALUE, (cmp)) ++#define sk_ASN1_VALUE_new_null() SKM_sk_new_null(ASN1_VALUE) ++#define sk_ASN1_VALUE_free(st) SKM_sk_free(ASN1_VALUE, (st)) ++#define sk_ASN1_VALUE_num(st) SKM_sk_num(ASN1_VALUE, (st)) ++#define sk_ASN1_VALUE_value(st, i) SKM_sk_value(ASN1_VALUE, (st), (i)) ++#define sk_ASN1_VALUE_set(st, i, val) SKM_sk_set(ASN1_VALUE, (st), (i), (val)) ++#define sk_ASN1_VALUE_zero(st) SKM_sk_zero(ASN1_VALUE, (st)) ++#define sk_ASN1_VALUE_push(st, val) SKM_sk_push(ASN1_VALUE, (st), (val)) ++#define sk_ASN1_VALUE_unshift(st, val) SKM_sk_unshift(ASN1_VALUE, (st), (val)) ++#define sk_ASN1_VALUE_find(st, val) SKM_sk_find(ASN1_VALUE, (st), (val)) ++#define sk_ASN1_VALUE_find_ex(st, val) SKM_sk_find_ex(ASN1_VALUE, (st), (val)) ++#define sk_ASN1_VALUE_delete(st, i) SKM_sk_delete(ASN1_VALUE, (st), (i)) ++#define sk_ASN1_VALUE_delete_ptr(st, ptr) SKM_sk_delete_ptr(ASN1_VALUE, (st), (ptr)) ++#define sk_ASN1_VALUE_insert(st, val, i) SKM_sk_insert(ASN1_VALUE, (st), (val), (i)) ++#define sk_ASN1_VALUE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ASN1_VALUE, (st), (cmp)) ++#define sk_ASN1_VALUE_dup(st) SKM_sk_dup(ASN1_VALUE, st) ++#define sk_ASN1_VALUE_pop_free(st, free_func) SKM_sk_pop_free(ASN1_VALUE, (st), (free_func)) ++#define sk_ASN1_VALUE_shift(st) SKM_sk_shift(ASN1_VALUE, (st)) ++#define sk_ASN1_VALUE_pop(st) SKM_sk_pop(ASN1_VALUE, (st)) ++#define sk_ASN1_VALUE_sort(st) SKM_sk_sort(ASN1_VALUE, (st)) ++#define sk_ASN1_VALUE_is_sorted(st) SKM_sk_is_sorted(ASN1_VALUE, (st)) ++ ++#define sk_BIO_new(cmp) SKM_sk_new(BIO, (cmp)) ++#define sk_BIO_new_null() SKM_sk_new_null(BIO) ++#define sk_BIO_free(st) SKM_sk_free(BIO, (st)) ++#define sk_BIO_num(st) SKM_sk_num(BIO, (st)) ++#define sk_BIO_value(st, i) SKM_sk_value(BIO, (st), (i)) ++#define sk_BIO_set(st, i, val) SKM_sk_set(BIO, (st), (i), (val)) ++#define sk_BIO_zero(st) SKM_sk_zero(BIO, (st)) ++#define sk_BIO_push(st, val) SKM_sk_push(BIO, (st), (val)) ++#define sk_BIO_unshift(st, val) SKM_sk_unshift(BIO, (st), (val)) ++#define sk_BIO_find(st, val) SKM_sk_find(BIO, (st), (val)) ++#define sk_BIO_find_ex(st, val) SKM_sk_find_ex(BIO, (st), (val)) ++#define sk_BIO_delete(st, i) SKM_sk_delete(BIO, (st), (i)) ++#define sk_BIO_delete_ptr(st, ptr) SKM_sk_delete_ptr(BIO, (st), (ptr)) ++#define sk_BIO_insert(st, val, i) SKM_sk_insert(BIO, (st), (val), (i)) ++#define sk_BIO_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(BIO, (st), (cmp)) ++#define sk_BIO_dup(st) SKM_sk_dup(BIO, st) ++#define sk_BIO_pop_free(st, free_func) SKM_sk_pop_free(BIO, (st), (free_func)) ++#define sk_BIO_shift(st) SKM_sk_shift(BIO, (st)) ++#define sk_BIO_pop(st) SKM_sk_pop(BIO, (st)) ++#define sk_BIO_sort(st) SKM_sk_sort(BIO, (st)) ++#define sk_BIO_is_sorted(st) SKM_sk_is_sorted(BIO, (st)) ++ ++#define sk_BY_DIR_ENTRY_new(cmp) SKM_sk_new(BY_DIR_ENTRY, (cmp)) ++#define sk_BY_DIR_ENTRY_new_null() SKM_sk_new_null(BY_DIR_ENTRY) ++#define sk_BY_DIR_ENTRY_free(st) SKM_sk_free(BY_DIR_ENTRY, (st)) ++#define sk_BY_DIR_ENTRY_num(st) SKM_sk_num(BY_DIR_ENTRY, (st)) ++#define sk_BY_DIR_ENTRY_value(st, i) SKM_sk_value(BY_DIR_ENTRY, (st), (i)) ++#define sk_BY_DIR_ENTRY_set(st, i, val) SKM_sk_set(BY_DIR_ENTRY, (st), (i), (val)) ++#define sk_BY_DIR_ENTRY_zero(st) SKM_sk_zero(BY_DIR_ENTRY, (st)) ++#define sk_BY_DIR_ENTRY_push(st, val) SKM_sk_push(BY_DIR_ENTRY, (st), (val)) ++#define sk_BY_DIR_ENTRY_unshift(st, val) SKM_sk_unshift(BY_DIR_ENTRY, (st), (val)) ++#define sk_BY_DIR_ENTRY_find(st, val) SKM_sk_find(BY_DIR_ENTRY, (st), (val)) ++#define sk_BY_DIR_ENTRY_find_ex(st, val) SKM_sk_find_ex(BY_DIR_ENTRY, (st), (val)) ++#define sk_BY_DIR_ENTRY_delete(st, i) SKM_sk_delete(BY_DIR_ENTRY, (st), (i)) ++#define sk_BY_DIR_ENTRY_delete_ptr(st, ptr) SKM_sk_delete_ptr(BY_DIR_ENTRY, (st), (ptr)) ++#define sk_BY_DIR_ENTRY_insert(st, val, i) SKM_sk_insert(BY_DIR_ENTRY, (st), (val), (i)) ++#define sk_BY_DIR_ENTRY_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(BY_DIR_ENTRY, (st), (cmp)) ++#define sk_BY_DIR_ENTRY_dup(st) SKM_sk_dup(BY_DIR_ENTRY, st) ++#define sk_BY_DIR_ENTRY_pop_free(st, free_func) SKM_sk_pop_free(BY_DIR_ENTRY, (st), (free_func)) ++#define sk_BY_DIR_ENTRY_shift(st) SKM_sk_shift(BY_DIR_ENTRY, (st)) ++#define sk_BY_DIR_ENTRY_pop(st) SKM_sk_pop(BY_DIR_ENTRY, (st)) ++#define sk_BY_DIR_ENTRY_sort(st) SKM_sk_sort(BY_DIR_ENTRY, (st)) ++#define sk_BY_DIR_ENTRY_is_sorted(st) SKM_sk_is_sorted(BY_DIR_ENTRY, (st)) ++ ++#define sk_BY_DIR_HASH_new(cmp) SKM_sk_new(BY_DIR_HASH, (cmp)) ++#define sk_BY_DIR_HASH_new_null() SKM_sk_new_null(BY_DIR_HASH) ++#define sk_BY_DIR_HASH_free(st) SKM_sk_free(BY_DIR_HASH, (st)) ++#define sk_BY_DIR_HASH_num(st) SKM_sk_num(BY_DIR_HASH, (st)) ++#define sk_BY_DIR_HASH_value(st, i) SKM_sk_value(BY_DIR_HASH, (st), (i)) ++#define sk_BY_DIR_HASH_set(st, i, val) SKM_sk_set(BY_DIR_HASH, (st), (i), (val)) ++#define sk_BY_DIR_HASH_zero(st) SKM_sk_zero(BY_DIR_HASH, (st)) ++#define sk_BY_DIR_HASH_push(st, val) SKM_sk_push(BY_DIR_HASH, (st), (val)) ++#define sk_BY_DIR_HASH_unshift(st, val) SKM_sk_unshift(BY_DIR_HASH, (st), (val)) ++#define sk_BY_DIR_HASH_find(st, val) SKM_sk_find(BY_DIR_HASH, (st), (val)) ++#define sk_BY_DIR_HASH_find_ex(st, val) SKM_sk_find_ex(BY_DIR_HASH, (st), (val)) ++#define sk_BY_DIR_HASH_delete(st, i) SKM_sk_delete(BY_DIR_HASH, (st), (i)) ++#define sk_BY_DIR_HASH_delete_ptr(st, ptr) SKM_sk_delete_ptr(BY_DIR_HASH, (st), (ptr)) ++#define sk_BY_DIR_HASH_insert(st, val, i) SKM_sk_insert(BY_DIR_HASH, (st), (val), (i)) ++#define sk_BY_DIR_HASH_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(BY_DIR_HASH, (st), (cmp)) ++#define sk_BY_DIR_HASH_dup(st) SKM_sk_dup(BY_DIR_HASH, st) ++#define sk_BY_DIR_HASH_pop_free(st, free_func) SKM_sk_pop_free(BY_DIR_HASH, (st), (free_func)) ++#define sk_BY_DIR_HASH_shift(st) SKM_sk_shift(BY_DIR_HASH, (st)) ++#define sk_BY_DIR_HASH_pop(st) SKM_sk_pop(BY_DIR_HASH, (st)) ++#define sk_BY_DIR_HASH_sort(st) SKM_sk_sort(BY_DIR_HASH, (st)) ++#define sk_BY_DIR_HASH_is_sorted(st) SKM_sk_is_sorted(BY_DIR_HASH, (st)) ++ ++#define sk_CMS_CertificateChoices_new(cmp) SKM_sk_new(CMS_CertificateChoices, (cmp)) ++#define sk_CMS_CertificateChoices_new_null() SKM_sk_new_null(CMS_CertificateChoices) ++#define sk_CMS_CertificateChoices_free(st) SKM_sk_free(CMS_CertificateChoices, (st)) ++#define sk_CMS_CertificateChoices_num(st) SKM_sk_num(CMS_CertificateChoices, (st)) ++#define sk_CMS_CertificateChoices_value(st, i) SKM_sk_value(CMS_CertificateChoices, (st), (i)) ++#define sk_CMS_CertificateChoices_set(st, i, val) SKM_sk_set(CMS_CertificateChoices, (st), (i), (val)) ++#define sk_CMS_CertificateChoices_zero(st) SKM_sk_zero(CMS_CertificateChoices, (st)) ++#define sk_CMS_CertificateChoices_push(st, val) SKM_sk_push(CMS_CertificateChoices, (st), (val)) ++#define sk_CMS_CertificateChoices_unshift(st, val) SKM_sk_unshift(CMS_CertificateChoices, (st), (val)) ++#define sk_CMS_CertificateChoices_find(st, val) SKM_sk_find(CMS_CertificateChoices, (st), (val)) ++#define sk_CMS_CertificateChoices_find_ex(st, val) SKM_sk_find_ex(CMS_CertificateChoices, (st), (val)) ++#define sk_CMS_CertificateChoices_delete(st, i) SKM_sk_delete(CMS_CertificateChoices, (st), (i)) ++#define sk_CMS_CertificateChoices_delete_ptr(st, ptr) SKM_sk_delete_ptr(CMS_CertificateChoices, (st), (ptr)) ++#define sk_CMS_CertificateChoices_insert(st, val, i) SKM_sk_insert(CMS_CertificateChoices, (st), (val), (i)) ++#define sk_CMS_CertificateChoices_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CMS_CertificateChoices, (st), (cmp)) ++#define sk_CMS_CertificateChoices_dup(st) SKM_sk_dup(CMS_CertificateChoices, st) ++#define sk_CMS_CertificateChoices_pop_free(st, free_func) SKM_sk_pop_free(CMS_CertificateChoices, (st), (free_func)) ++#define sk_CMS_CertificateChoices_shift(st) SKM_sk_shift(CMS_CertificateChoices, (st)) ++#define sk_CMS_CertificateChoices_pop(st) SKM_sk_pop(CMS_CertificateChoices, (st)) ++#define sk_CMS_CertificateChoices_sort(st) SKM_sk_sort(CMS_CertificateChoices, (st)) ++#define sk_CMS_CertificateChoices_is_sorted(st) SKM_sk_is_sorted(CMS_CertificateChoices, (st)) ++ ++#define sk_CMS_RecipientInfo_new(cmp) SKM_sk_new(CMS_RecipientInfo, (cmp)) ++#define sk_CMS_RecipientInfo_new_null() SKM_sk_new_null(CMS_RecipientInfo) ++#define sk_CMS_RecipientInfo_free(st) SKM_sk_free(CMS_RecipientInfo, (st)) ++#define sk_CMS_RecipientInfo_num(st) SKM_sk_num(CMS_RecipientInfo, (st)) ++#define sk_CMS_RecipientInfo_value(st, i) SKM_sk_value(CMS_RecipientInfo, (st), (i)) ++#define sk_CMS_RecipientInfo_set(st, i, val) SKM_sk_set(CMS_RecipientInfo, (st), (i), (val)) ++#define sk_CMS_RecipientInfo_zero(st) SKM_sk_zero(CMS_RecipientInfo, (st)) ++#define sk_CMS_RecipientInfo_push(st, val) SKM_sk_push(CMS_RecipientInfo, (st), (val)) ++#define sk_CMS_RecipientInfo_unshift(st, val) SKM_sk_unshift(CMS_RecipientInfo, (st), (val)) ++#define sk_CMS_RecipientInfo_find(st, val) SKM_sk_find(CMS_RecipientInfo, (st), (val)) ++#define sk_CMS_RecipientInfo_find_ex(st, val) SKM_sk_find_ex(CMS_RecipientInfo, (st), (val)) ++#define sk_CMS_RecipientInfo_delete(st, i) SKM_sk_delete(CMS_RecipientInfo, (st), (i)) ++#define sk_CMS_RecipientInfo_delete_ptr(st, ptr) SKM_sk_delete_ptr(CMS_RecipientInfo, (st), (ptr)) ++#define sk_CMS_RecipientInfo_insert(st, val, i) SKM_sk_insert(CMS_RecipientInfo, (st), (val), (i)) ++#define sk_CMS_RecipientInfo_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CMS_RecipientInfo, (st), (cmp)) ++#define sk_CMS_RecipientInfo_dup(st) SKM_sk_dup(CMS_RecipientInfo, st) ++#define sk_CMS_RecipientInfo_pop_free(st, free_func) SKM_sk_pop_free(CMS_RecipientInfo, (st), (free_func)) ++#define sk_CMS_RecipientInfo_shift(st) SKM_sk_shift(CMS_RecipientInfo, (st)) ++#define sk_CMS_RecipientInfo_pop(st) SKM_sk_pop(CMS_RecipientInfo, (st)) ++#define sk_CMS_RecipientInfo_sort(st) SKM_sk_sort(CMS_RecipientInfo, (st)) ++#define sk_CMS_RecipientInfo_is_sorted(st) SKM_sk_is_sorted(CMS_RecipientInfo, (st)) ++ ++#define sk_CMS_RevocationInfoChoice_new(cmp) SKM_sk_new(CMS_RevocationInfoChoice, (cmp)) ++#define sk_CMS_RevocationInfoChoice_new_null() SKM_sk_new_null(CMS_RevocationInfoChoice) ++#define sk_CMS_RevocationInfoChoice_free(st) SKM_sk_free(CMS_RevocationInfoChoice, (st)) ++#define sk_CMS_RevocationInfoChoice_num(st) SKM_sk_num(CMS_RevocationInfoChoice, (st)) ++#define sk_CMS_RevocationInfoChoice_value(st, i) SKM_sk_value(CMS_RevocationInfoChoice, (st), (i)) ++#define sk_CMS_RevocationInfoChoice_set(st, i, val) SKM_sk_set(CMS_RevocationInfoChoice, (st), (i), (val)) ++#define sk_CMS_RevocationInfoChoice_zero(st) SKM_sk_zero(CMS_RevocationInfoChoice, (st)) ++#define sk_CMS_RevocationInfoChoice_push(st, val) SKM_sk_push(CMS_RevocationInfoChoice, (st), (val)) ++#define sk_CMS_RevocationInfoChoice_unshift(st, val) SKM_sk_unshift(CMS_RevocationInfoChoice, (st), (val)) ++#define sk_CMS_RevocationInfoChoice_find(st, val) SKM_sk_find(CMS_RevocationInfoChoice, (st), (val)) ++#define sk_CMS_RevocationInfoChoice_find_ex(st, val) SKM_sk_find_ex(CMS_RevocationInfoChoice, (st), (val)) ++#define sk_CMS_RevocationInfoChoice_delete(st, i) SKM_sk_delete(CMS_RevocationInfoChoice, (st), (i)) ++#define sk_CMS_RevocationInfoChoice_delete_ptr(st, ptr) SKM_sk_delete_ptr(CMS_RevocationInfoChoice, (st), (ptr)) ++#define sk_CMS_RevocationInfoChoice_insert(st, val, i) SKM_sk_insert(CMS_RevocationInfoChoice, (st), (val), (i)) ++#define sk_CMS_RevocationInfoChoice_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CMS_RevocationInfoChoice, (st), (cmp)) ++#define sk_CMS_RevocationInfoChoice_dup(st) SKM_sk_dup(CMS_RevocationInfoChoice, st) ++#define sk_CMS_RevocationInfoChoice_pop_free(st, free_func) SKM_sk_pop_free(CMS_RevocationInfoChoice, (st), (free_func)) ++#define sk_CMS_RevocationInfoChoice_shift(st) SKM_sk_shift(CMS_RevocationInfoChoice, (st)) ++#define sk_CMS_RevocationInfoChoice_pop(st) SKM_sk_pop(CMS_RevocationInfoChoice, (st)) ++#define sk_CMS_RevocationInfoChoice_sort(st) SKM_sk_sort(CMS_RevocationInfoChoice, (st)) ++#define sk_CMS_RevocationInfoChoice_is_sorted(st) SKM_sk_is_sorted(CMS_RevocationInfoChoice, (st)) ++ ++#define sk_CMS_SignerInfo_new(cmp) SKM_sk_new(CMS_SignerInfo, (cmp)) ++#define sk_CMS_SignerInfo_new_null() SKM_sk_new_null(CMS_SignerInfo) ++#define sk_CMS_SignerInfo_free(st) SKM_sk_free(CMS_SignerInfo, (st)) ++#define sk_CMS_SignerInfo_num(st) SKM_sk_num(CMS_SignerInfo, (st)) ++#define sk_CMS_SignerInfo_value(st, i) SKM_sk_value(CMS_SignerInfo, (st), (i)) ++#define sk_CMS_SignerInfo_set(st, i, val) SKM_sk_set(CMS_SignerInfo, (st), (i), (val)) ++#define sk_CMS_SignerInfo_zero(st) SKM_sk_zero(CMS_SignerInfo, (st)) ++#define sk_CMS_SignerInfo_push(st, val) SKM_sk_push(CMS_SignerInfo, (st), (val)) ++#define sk_CMS_SignerInfo_unshift(st, val) SKM_sk_unshift(CMS_SignerInfo, (st), (val)) ++#define sk_CMS_SignerInfo_find(st, val) SKM_sk_find(CMS_SignerInfo, (st), (val)) ++#define sk_CMS_SignerInfo_find_ex(st, val) SKM_sk_find_ex(CMS_SignerInfo, (st), (val)) ++#define sk_CMS_SignerInfo_delete(st, i) SKM_sk_delete(CMS_SignerInfo, (st), (i)) ++#define sk_CMS_SignerInfo_delete_ptr(st, ptr) SKM_sk_delete_ptr(CMS_SignerInfo, (st), (ptr)) ++#define sk_CMS_SignerInfo_insert(st, val, i) SKM_sk_insert(CMS_SignerInfo, (st), (val), (i)) ++#define sk_CMS_SignerInfo_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CMS_SignerInfo, (st), (cmp)) ++#define sk_CMS_SignerInfo_dup(st) SKM_sk_dup(CMS_SignerInfo, st) ++#define sk_CMS_SignerInfo_pop_free(st, free_func) SKM_sk_pop_free(CMS_SignerInfo, (st), (free_func)) ++#define sk_CMS_SignerInfo_shift(st) SKM_sk_shift(CMS_SignerInfo, (st)) ++#define sk_CMS_SignerInfo_pop(st) SKM_sk_pop(CMS_SignerInfo, (st)) ++#define sk_CMS_SignerInfo_sort(st) SKM_sk_sort(CMS_SignerInfo, (st)) ++#define sk_CMS_SignerInfo_is_sorted(st) SKM_sk_is_sorted(CMS_SignerInfo, (st)) ++ ++#define sk_CONF_IMODULE_new(cmp) SKM_sk_new(CONF_IMODULE, (cmp)) ++#define sk_CONF_IMODULE_new_null() SKM_sk_new_null(CONF_IMODULE) ++#define sk_CONF_IMODULE_free(st) SKM_sk_free(CONF_IMODULE, (st)) ++#define sk_CONF_IMODULE_num(st) SKM_sk_num(CONF_IMODULE, (st)) ++#define sk_CONF_IMODULE_value(st, i) SKM_sk_value(CONF_IMODULE, (st), (i)) ++#define sk_CONF_IMODULE_set(st, i, val) SKM_sk_set(CONF_IMODULE, (st), (i), (val)) ++#define sk_CONF_IMODULE_zero(st) SKM_sk_zero(CONF_IMODULE, (st)) ++#define sk_CONF_IMODULE_push(st, val) SKM_sk_push(CONF_IMODULE, (st), (val)) ++#define sk_CONF_IMODULE_unshift(st, val) SKM_sk_unshift(CONF_IMODULE, (st), (val)) ++#define sk_CONF_IMODULE_find(st, val) SKM_sk_find(CONF_IMODULE, (st), (val)) ++#define sk_CONF_IMODULE_find_ex(st, val) SKM_sk_find_ex(CONF_IMODULE, (st), (val)) ++#define sk_CONF_IMODULE_delete(st, i) SKM_sk_delete(CONF_IMODULE, (st), (i)) ++#define sk_CONF_IMODULE_delete_ptr(st, ptr) SKM_sk_delete_ptr(CONF_IMODULE, (st), (ptr)) ++#define sk_CONF_IMODULE_insert(st, val, i) SKM_sk_insert(CONF_IMODULE, (st), (val), (i)) ++#define sk_CONF_IMODULE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CONF_IMODULE, (st), (cmp)) ++#define sk_CONF_IMODULE_dup(st) SKM_sk_dup(CONF_IMODULE, st) ++#define sk_CONF_IMODULE_pop_free(st, free_func) SKM_sk_pop_free(CONF_IMODULE, (st), (free_func)) ++#define sk_CONF_IMODULE_shift(st) SKM_sk_shift(CONF_IMODULE, (st)) ++#define sk_CONF_IMODULE_pop(st) SKM_sk_pop(CONF_IMODULE, (st)) ++#define sk_CONF_IMODULE_sort(st) SKM_sk_sort(CONF_IMODULE, (st)) ++#define sk_CONF_IMODULE_is_sorted(st) SKM_sk_is_sorted(CONF_IMODULE, (st)) ++ ++#define sk_CONF_MODULE_new(cmp) SKM_sk_new(CONF_MODULE, (cmp)) ++#define sk_CONF_MODULE_new_null() SKM_sk_new_null(CONF_MODULE) ++#define sk_CONF_MODULE_free(st) SKM_sk_free(CONF_MODULE, (st)) ++#define sk_CONF_MODULE_num(st) SKM_sk_num(CONF_MODULE, (st)) ++#define sk_CONF_MODULE_value(st, i) SKM_sk_value(CONF_MODULE, (st), (i)) ++#define sk_CONF_MODULE_set(st, i, val) SKM_sk_set(CONF_MODULE, (st), (i), (val)) ++#define sk_CONF_MODULE_zero(st) SKM_sk_zero(CONF_MODULE, (st)) ++#define sk_CONF_MODULE_push(st, val) SKM_sk_push(CONF_MODULE, (st), (val)) ++#define sk_CONF_MODULE_unshift(st, val) SKM_sk_unshift(CONF_MODULE, (st), (val)) ++#define sk_CONF_MODULE_find(st, val) SKM_sk_find(CONF_MODULE, (st), (val)) ++#define sk_CONF_MODULE_find_ex(st, val) SKM_sk_find_ex(CONF_MODULE, (st), (val)) ++#define sk_CONF_MODULE_delete(st, i) SKM_sk_delete(CONF_MODULE, (st), (i)) ++#define sk_CONF_MODULE_delete_ptr(st, ptr) SKM_sk_delete_ptr(CONF_MODULE, (st), (ptr)) ++#define sk_CONF_MODULE_insert(st, val, i) SKM_sk_insert(CONF_MODULE, (st), (val), (i)) ++#define sk_CONF_MODULE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CONF_MODULE, (st), (cmp)) ++#define sk_CONF_MODULE_dup(st) SKM_sk_dup(CONF_MODULE, st) ++#define sk_CONF_MODULE_pop_free(st, free_func) SKM_sk_pop_free(CONF_MODULE, (st), (free_func)) ++#define sk_CONF_MODULE_shift(st) SKM_sk_shift(CONF_MODULE, (st)) ++#define sk_CONF_MODULE_pop(st) SKM_sk_pop(CONF_MODULE, (st)) ++#define sk_CONF_MODULE_sort(st) SKM_sk_sort(CONF_MODULE, (st)) ++#define sk_CONF_MODULE_is_sorted(st) SKM_sk_is_sorted(CONF_MODULE, (st)) ++ ++#define sk_CONF_VALUE_new(cmp) SKM_sk_new(CONF_VALUE, (cmp)) ++#define sk_CONF_VALUE_new_null() SKM_sk_new_null(CONF_VALUE) ++#define sk_CONF_VALUE_free(st) SKM_sk_free(CONF_VALUE, (st)) ++#define sk_CONF_VALUE_num(st) SKM_sk_num(CONF_VALUE, (st)) ++#define sk_CONF_VALUE_value(st, i) SKM_sk_value(CONF_VALUE, (st), (i)) ++#define sk_CONF_VALUE_set(st, i, val) SKM_sk_set(CONF_VALUE, (st), (i), (val)) ++#define sk_CONF_VALUE_zero(st) SKM_sk_zero(CONF_VALUE, (st)) ++#define sk_CONF_VALUE_push(st, val) SKM_sk_push(CONF_VALUE, (st), (val)) ++#define sk_CONF_VALUE_unshift(st, val) SKM_sk_unshift(CONF_VALUE, (st), (val)) ++#define sk_CONF_VALUE_find(st, val) SKM_sk_find(CONF_VALUE, (st), (val)) ++#define sk_CONF_VALUE_find_ex(st, val) SKM_sk_find_ex(CONF_VALUE, (st), (val)) ++#define sk_CONF_VALUE_delete(st, i) SKM_sk_delete(CONF_VALUE, (st), (i)) ++#define sk_CONF_VALUE_delete_ptr(st, ptr) SKM_sk_delete_ptr(CONF_VALUE, (st), (ptr)) ++#define sk_CONF_VALUE_insert(st, val, i) SKM_sk_insert(CONF_VALUE, (st), (val), (i)) ++#define sk_CONF_VALUE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CONF_VALUE, (st), (cmp)) ++#define sk_CONF_VALUE_dup(st) SKM_sk_dup(CONF_VALUE, st) ++#define sk_CONF_VALUE_pop_free(st, free_func) SKM_sk_pop_free(CONF_VALUE, (st), (free_func)) ++#define sk_CONF_VALUE_shift(st) SKM_sk_shift(CONF_VALUE, (st)) ++#define sk_CONF_VALUE_pop(st) SKM_sk_pop(CONF_VALUE, (st)) ++#define sk_CONF_VALUE_sort(st) SKM_sk_sort(CONF_VALUE, (st)) ++#define sk_CONF_VALUE_is_sorted(st) SKM_sk_is_sorted(CONF_VALUE, (st)) ++ ++#define sk_CRYPTO_EX_DATA_FUNCS_new(cmp) SKM_sk_new(CRYPTO_EX_DATA_FUNCS, (cmp)) ++#define sk_CRYPTO_EX_DATA_FUNCS_new_null() SKM_sk_new_null(CRYPTO_EX_DATA_FUNCS) ++#define sk_CRYPTO_EX_DATA_FUNCS_free(st) SKM_sk_free(CRYPTO_EX_DATA_FUNCS, (st)) ++#define sk_CRYPTO_EX_DATA_FUNCS_num(st) SKM_sk_num(CRYPTO_EX_DATA_FUNCS, (st)) ++#define sk_CRYPTO_EX_DATA_FUNCS_value(st, i) SKM_sk_value(CRYPTO_EX_DATA_FUNCS, (st), (i)) ++#define sk_CRYPTO_EX_DATA_FUNCS_set(st, i, val) SKM_sk_set(CRYPTO_EX_DATA_FUNCS, (st), (i), (val)) ++#define sk_CRYPTO_EX_DATA_FUNCS_zero(st) SKM_sk_zero(CRYPTO_EX_DATA_FUNCS, (st)) ++#define sk_CRYPTO_EX_DATA_FUNCS_push(st, val) SKM_sk_push(CRYPTO_EX_DATA_FUNCS, (st), (val)) ++#define sk_CRYPTO_EX_DATA_FUNCS_unshift(st, val) SKM_sk_unshift(CRYPTO_EX_DATA_FUNCS, (st), (val)) ++#define sk_CRYPTO_EX_DATA_FUNCS_find(st, val) SKM_sk_find(CRYPTO_EX_DATA_FUNCS, (st), (val)) ++#define sk_CRYPTO_EX_DATA_FUNCS_find_ex(st, val) SKM_sk_find_ex(CRYPTO_EX_DATA_FUNCS, (st), (val)) ++#define sk_CRYPTO_EX_DATA_FUNCS_delete(st, i) SKM_sk_delete(CRYPTO_EX_DATA_FUNCS, (st), (i)) ++#define sk_CRYPTO_EX_DATA_FUNCS_delete_ptr(st, ptr) SKM_sk_delete_ptr(CRYPTO_EX_DATA_FUNCS, (st), (ptr)) ++#define sk_CRYPTO_EX_DATA_FUNCS_insert(st, val, i) SKM_sk_insert(CRYPTO_EX_DATA_FUNCS, (st), (val), (i)) ++#define sk_CRYPTO_EX_DATA_FUNCS_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CRYPTO_EX_DATA_FUNCS, (st), (cmp)) ++#define sk_CRYPTO_EX_DATA_FUNCS_dup(st) SKM_sk_dup(CRYPTO_EX_DATA_FUNCS, st) ++#define sk_CRYPTO_EX_DATA_FUNCS_pop_free(st, free_func) SKM_sk_pop_free(CRYPTO_EX_DATA_FUNCS, (st), (free_func)) ++#define sk_CRYPTO_EX_DATA_FUNCS_shift(st) SKM_sk_shift(CRYPTO_EX_DATA_FUNCS, (st)) ++#define sk_CRYPTO_EX_DATA_FUNCS_pop(st) SKM_sk_pop(CRYPTO_EX_DATA_FUNCS, (st)) ++#define sk_CRYPTO_EX_DATA_FUNCS_sort(st) SKM_sk_sort(CRYPTO_EX_DATA_FUNCS, (st)) ++#define sk_CRYPTO_EX_DATA_FUNCS_is_sorted(st) SKM_sk_is_sorted(CRYPTO_EX_DATA_FUNCS, (st)) ++ ++#define sk_CRYPTO_dynlock_new(cmp) SKM_sk_new(CRYPTO_dynlock, (cmp)) ++#define sk_CRYPTO_dynlock_new_null() SKM_sk_new_null(CRYPTO_dynlock) ++#define sk_CRYPTO_dynlock_free(st) SKM_sk_free(CRYPTO_dynlock, (st)) ++#define sk_CRYPTO_dynlock_num(st) SKM_sk_num(CRYPTO_dynlock, (st)) ++#define sk_CRYPTO_dynlock_value(st, i) SKM_sk_value(CRYPTO_dynlock, (st), (i)) ++#define sk_CRYPTO_dynlock_set(st, i, val) SKM_sk_set(CRYPTO_dynlock, (st), (i), (val)) ++#define sk_CRYPTO_dynlock_zero(st) SKM_sk_zero(CRYPTO_dynlock, (st)) ++#define sk_CRYPTO_dynlock_push(st, val) SKM_sk_push(CRYPTO_dynlock, (st), (val)) ++#define sk_CRYPTO_dynlock_unshift(st, val) SKM_sk_unshift(CRYPTO_dynlock, (st), (val)) ++#define sk_CRYPTO_dynlock_find(st, val) SKM_sk_find(CRYPTO_dynlock, (st), (val)) ++#define sk_CRYPTO_dynlock_find_ex(st, val) SKM_sk_find_ex(CRYPTO_dynlock, (st), (val)) ++#define sk_CRYPTO_dynlock_delete(st, i) SKM_sk_delete(CRYPTO_dynlock, (st), (i)) ++#define sk_CRYPTO_dynlock_delete_ptr(st, ptr) SKM_sk_delete_ptr(CRYPTO_dynlock, (st), (ptr)) ++#define sk_CRYPTO_dynlock_insert(st, val, i) SKM_sk_insert(CRYPTO_dynlock, (st), (val), (i)) ++#define sk_CRYPTO_dynlock_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(CRYPTO_dynlock, (st), (cmp)) ++#define sk_CRYPTO_dynlock_dup(st) SKM_sk_dup(CRYPTO_dynlock, st) ++#define sk_CRYPTO_dynlock_pop_free(st, free_func) SKM_sk_pop_free(CRYPTO_dynlock, (st), (free_func)) ++#define sk_CRYPTO_dynlock_shift(st) SKM_sk_shift(CRYPTO_dynlock, (st)) ++#define sk_CRYPTO_dynlock_pop(st) SKM_sk_pop(CRYPTO_dynlock, (st)) ++#define sk_CRYPTO_dynlock_sort(st) SKM_sk_sort(CRYPTO_dynlock, (st)) ++#define sk_CRYPTO_dynlock_is_sorted(st) SKM_sk_is_sorted(CRYPTO_dynlock, (st)) ++ ++#define sk_DIST_POINT_new(cmp) SKM_sk_new(DIST_POINT, (cmp)) ++#define sk_DIST_POINT_new_null() SKM_sk_new_null(DIST_POINT) ++#define sk_DIST_POINT_free(st) SKM_sk_free(DIST_POINT, (st)) ++#define sk_DIST_POINT_num(st) SKM_sk_num(DIST_POINT, (st)) ++#define sk_DIST_POINT_value(st, i) SKM_sk_value(DIST_POINT, (st), (i)) ++#define sk_DIST_POINT_set(st, i, val) SKM_sk_set(DIST_POINT, (st), (i), (val)) ++#define sk_DIST_POINT_zero(st) SKM_sk_zero(DIST_POINT, (st)) ++#define sk_DIST_POINT_push(st, val) SKM_sk_push(DIST_POINT, (st), (val)) ++#define sk_DIST_POINT_unshift(st, val) SKM_sk_unshift(DIST_POINT, (st), (val)) ++#define sk_DIST_POINT_find(st, val) SKM_sk_find(DIST_POINT, (st), (val)) ++#define sk_DIST_POINT_find_ex(st, val) SKM_sk_find_ex(DIST_POINT, (st), (val)) ++#define sk_DIST_POINT_delete(st, i) SKM_sk_delete(DIST_POINT, (st), (i)) ++#define sk_DIST_POINT_delete_ptr(st, ptr) SKM_sk_delete_ptr(DIST_POINT, (st), (ptr)) ++#define sk_DIST_POINT_insert(st, val, i) SKM_sk_insert(DIST_POINT, (st), (val), (i)) ++#define sk_DIST_POINT_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(DIST_POINT, (st), (cmp)) ++#define sk_DIST_POINT_dup(st) SKM_sk_dup(DIST_POINT, st) ++#define sk_DIST_POINT_pop_free(st, free_func) SKM_sk_pop_free(DIST_POINT, (st), (free_func)) ++#define sk_DIST_POINT_shift(st) SKM_sk_shift(DIST_POINT, (st)) ++#define sk_DIST_POINT_pop(st) SKM_sk_pop(DIST_POINT, (st)) ++#define sk_DIST_POINT_sort(st) SKM_sk_sort(DIST_POINT, (st)) ++#define sk_DIST_POINT_is_sorted(st) SKM_sk_is_sorted(DIST_POINT, (st)) ++ ++#define sk_ENGINE_new(cmp) SKM_sk_new(ENGINE, (cmp)) ++#define sk_ENGINE_new_null() SKM_sk_new_null(ENGINE) ++#define sk_ENGINE_free(st) SKM_sk_free(ENGINE, (st)) ++#define sk_ENGINE_num(st) SKM_sk_num(ENGINE, (st)) ++#define sk_ENGINE_value(st, i) SKM_sk_value(ENGINE, (st), (i)) ++#define sk_ENGINE_set(st, i, val) SKM_sk_set(ENGINE, (st), (i), (val)) ++#define sk_ENGINE_zero(st) SKM_sk_zero(ENGINE, (st)) ++#define sk_ENGINE_push(st, val) SKM_sk_push(ENGINE, (st), (val)) ++#define sk_ENGINE_unshift(st, val) SKM_sk_unshift(ENGINE, (st), (val)) ++#define sk_ENGINE_find(st, val) SKM_sk_find(ENGINE, (st), (val)) ++#define sk_ENGINE_find_ex(st, val) SKM_sk_find_ex(ENGINE, (st), (val)) ++#define sk_ENGINE_delete(st, i) SKM_sk_delete(ENGINE, (st), (i)) ++#define sk_ENGINE_delete_ptr(st, ptr) SKM_sk_delete_ptr(ENGINE, (st), (ptr)) ++#define sk_ENGINE_insert(st, val, i) SKM_sk_insert(ENGINE, (st), (val), (i)) ++#define sk_ENGINE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ENGINE, (st), (cmp)) ++#define sk_ENGINE_dup(st) SKM_sk_dup(ENGINE, st) ++#define sk_ENGINE_pop_free(st, free_func) SKM_sk_pop_free(ENGINE, (st), (free_func)) ++#define sk_ENGINE_shift(st) SKM_sk_shift(ENGINE, (st)) ++#define sk_ENGINE_pop(st) SKM_sk_pop(ENGINE, (st)) ++#define sk_ENGINE_sort(st) SKM_sk_sort(ENGINE, (st)) ++#define sk_ENGINE_is_sorted(st) SKM_sk_is_sorted(ENGINE, (st)) ++ ++#define sk_ENGINE_CLEANUP_ITEM_new(cmp) SKM_sk_new(ENGINE_CLEANUP_ITEM, (cmp)) ++#define sk_ENGINE_CLEANUP_ITEM_new_null() SKM_sk_new_null(ENGINE_CLEANUP_ITEM) ++#define sk_ENGINE_CLEANUP_ITEM_free(st) SKM_sk_free(ENGINE_CLEANUP_ITEM, (st)) ++#define sk_ENGINE_CLEANUP_ITEM_num(st) SKM_sk_num(ENGINE_CLEANUP_ITEM, (st)) ++#define sk_ENGINE_CLEANUP_ITEM_value(st, i) SKM_sk_value(ENGINE_CLEANUP_ITEM, (st), (i)) ++#define sk_ENGINE_CLEANUP_ITEM_set(st, i, val) SKM_sk_set(ENGINE_CLEANUP_ITEM, (st), (i), (val)) ++#define sk_ENGINE_CLEANUP_ITEM_zero(st) SKM_sk_zero(ENGINE_CLEANUP_ITEM, (st)) ++#define sk_ENGINE_CLEANUP_ITEM_push(st, val) SKM_sk_push(ENGINE_CLEANUP_ITEM, (st), (val)) ++#define sk_ENGINE_CLEANUP_ITEM_unshift(st, val) SKM_sk_unshift(ENGINE_CLEANUP_ITEM, (st), (val)) ++#define sk_ENGINE_CLEANUP_ITEM_find(st, val) SKM_sk_find(ENGINE_CLEANUP_ITEM, (st), (val)) ++#define sk_ENGINE_CLEANUP_ITEM_find_ex(st, val) SKM_sk_find_ex(ENGINE_CLEANUP_ITEM, (st), (val)) ++#define sk_ENGINE_CLEANUP_ITEM_delete(st, i) SKM_sk_delete(ENGINE_CLEANUP_ITEM, (st), (i)) ++#define sk_ENGINE_CLEANUP_ITEM_delete_ptr(st, ptr) SKM_sk_delete_ptr(ENGINE_CLEANUP_ITEM, (st), (ptr)) ++#define sk_ENGINE_CLEANUP_ITEM_insert(st, val, i) SKM_sk_insert(ENGINE_CLEANUP_ITEM, (st), (val), (i)) ++#define sk_ENGINE_CLEANUP_ITEM_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ENGINE_CLEANUP_ITEM, (st), (cmp)) ++#define sk_ENGINE_CLEANUP_ITEM_dup(st) SKM_sk_dup(ENGINE_CLEANUP_ITEM, st) ++#define sk_ENGINE_CLEANUP_ITEM_pop_free(st, free_func) SKM_sk_pop_free(ENGINE_CLEANUP_ITEM, (st), (free_func)) ++#define sk_ENGINE_CLEANUP_ITEM_shift(st) SKM_sk_shift(ENGINE_CLEANUP_ITEM, (st)) ++#define sk_ENGINE_CLEANUP_ITEM_pop(st) SKM_sk_pop(ENGINE_CLEANUP_ITEM, (st)) ++#define sk_ENGINE_CLEANUP_ITEM_sort(st) SKM_sk_sort(ENGINE_CLEANUP_ITEM, (st)) ++#define sk_ENGINE_CLEANUP_ITEM_is_sorted(st) SKM_sk_is_sorted(ENGINE_CLEANUP_ITEM, (st)) ++ ++#define sk_ESS_CERT_ID_new(cmp) SKM_sk_new(ESS_CERT_ID, (cmp)) ++#define sk_ESS_CERT_ID_new_null() SKM_sk_new_null(ESS_CERT_ID) ++#define sk_ESS_CERT_ID_free(st) SKM_sk_free(ESS_CERT_ID, (st)) ++#define sk_ESS_CERT_ID_num(st) SKM_sk_num(ESS_CERT_ID, (st)) ++#define sk_ESS_CERT_ID_value(st, i) SKM_sk_value(ESS_CERT_ID, (st), (i)) ++#define sk_ESS_CERT_ID_set(st, i, val) SKM_sk_set(ESS_CERT_ID, (st), (i), (val)) ++#define sk_ESS_CERT_ID_zero(st) SKM_sk_zero(ESS_CERT_ID, (st)) ++#define sk_ESS_CERT_ID_push(st, val) SKM_sk_push(ESS_CERT_ID, (st), (val)) ++#define sk_ESS_CERT_ID_unshift(st, val) SKM_sk_unshift(ESS_CERT_ID, (st), (val)) ++#define sk_ESS_CERT_ID_find(st, val) SKM_sk_find(ESS_CERT_ID, (st), (val)) ++#define sk_ESS_CERT_ID_find_ex(st, val) SKM_sk_find_ex(ESS_CERT_ID, (st), (val)) ++#define sk_ESS_CERT_ID_delete(st, i) SKM_sk_delete(ESS_CERT_ID, (st), (i)) ++#define sk_ESS_CERT_ID_delete_ptr(st, ptr) SKM_sk_delete_ptr(ESS_CERT_ID, (st), (ptr)) ++#define sk_ESS_CERT_ID_insert(st, val, i) SKM_sk_insert(ESS_CERT_ID, (st), (val), (i)) ++#define sk_ESS_CERT_ID_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(ESS_CERT_ID, (st), (cmp)) ++#define sk_ESS_CERT_ID_dup(st) SKM_sk_dup(ESS_CERT_ID, st) ++#define sk_ESS_CERT_ID_pop_free(st, free_func) SKM_sk_pop_free(ESS_CERT_ID, (st), (free_func)) ++#define sk_ESS_CERT_ID_shift(st) SKM_sk_shift(ESS_CERT_ID, (st)) ++#define sk_ESS_CERT_ID_pop(st) SKM_sk_pop(ESS_CERT_ID, (st)) ++#define sk_ESS_CERT_ID_sort(st) SKM_sk_sort(ESS_CERT_ID, (st)) ++#define sk_ESS_CERT_ID_is_sorted(st) SKM_sk_is_sorted(ESS_CERT_ID, (st)) ++ ++#define sk_EVP_MD_new(cmp) SKM_sk_new(EVP_MD, (cmp)) ++#define sk_EVP_MD_new_null() SKM_sk_new_null(EVP_MD) ++#define sk_EVP_MD_free(st) SKM_sk_free(EVP_MD, (st)) ++#define sk_EVP_MD_num(st) SKM_sk_num(EVP_MD, (st)) ++#define sk_EVP_MD_value(st, i) SKM_sk_value(EVP_MD, (st), (i)) ++#define sk_EVP_MD_set(st, i, val) SKM_sk_set(EVP_MD, (st), (i), (val)) ++#define sk_EVP_MD_zero(st) SKM_sk_zero(EVP_MD, (st)) ++#define sk_EVP_MD_push(st, val) SKM_sk_push(EVP_MD, (st), (val)) ++#define sk_EVP_MD_unshift(st, val) SKM_sk_unshift(EVP_MD, (st), (val)) ++#define sk_EVP_MD_find(st, val) SKM_sk_find(EVP_MD, (st), (val)) ++#define sk_EVP_MD_find_ex(st, val) SKM_sk_find_ex(EVP_MD, (st), (val)) ++#define sk_EVP_MD_delete(st, i) SKM_sk_delete(EVP_MD, (st), (i)) ++#define sk_EVP_MD_delete_ptr(st, ptr) SKM_sk_delete_ptr(EVP_MD, (st), (ptr)) ++#define sk_EVP_MD_insert(st, val, i) SKM_sk_insert(EVP_MD, (st), (val), (i)) ++#define sk_EVP_MD_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(EVP_MD, (st), (cmp)) ++#define sk_EVP_MD_dup(st) SKM_sk_dup(EVP_MD, st) ++#define sk_EVP_MD_pop_free(st, free_func) SKM_sk_pop_free(EVP_MD, (st), (free_func)) ++#define sk_EVP_MD_shift(st) SKM_sk_shift(EVP_MD, (st)) ++#define sk_EVP_MD_pop(st) SKM_sk_pop(EVP_MD, (st)) ++#define sk_EVP_MD_sort(st) SKM_sk_sort(EVP_MD, (st)) ++#define sk_EVP_MD_is_sorted(st) SKM_sk_is_sorted(EVP_MD, (st)) ++ ++#define sk_EVP_PBE_CTL_new(cmp) SKM_sk_new(EVP_PBE_CTL, (cmp)) ++#define sk_EVP_PBE_CTL_new_null() SKM_sk_new_null(EVP_PBE_CTL) ++#define sk_EVP_PBE_CTL_free(st) SKM_sk_free(EVP_PBE_CTL, (st)) ++#define sk_EVP_PBE_CTL_num(st) SKM_sk_num(EVP_PBE_CTL, (st)) ++#define sk_EVP_PBE_CTL_value(st, i) SKM_sk_value(EVP_PBE_CTL, (st), (i)) ++#define sk_EVP_PBE_CTL_set(st, i, val) SKM_sk_set(EVP_PBE_CTL, (st), (i), (val)) ++#define sk_EVP_PBE_CTL_zero(st) SKM_sk_zero(EVP_PBE_CTL, (st)) ++#define sk_EVP_PBE_CTL_push(st, val) SKM_sk_push(EVP_PBE_CTL, (st), (val)) ++#define sk_EVP_PBE_CTL_unshift(st, val) SKM_sk_unshift(EVP_PBE_CTL, (st), (val)) ++#define sk_EVP_PBE_CTL_find(st, val) SKM_sk_find(EVP_PBE_CTL, (st), (val)) ++#define sk_EVP_PBE_CTL_find_ex(st, val) SKM_sk_find_ex(EVP_PBE_CTL, (st), (val)) ++#define sk_EVP_PBE_CTL_delete(st, i) SKM_sk_delete(EVP_PBE_CTL, (st), (i)) ++#define sk_EVP_PBE_CTL_delete_ptr(st, ptr) SKM_sk_delete_ptr(EVP_PBE_CTL, (st), (ptr)) ++#define sk_EVP_PBE_CTL_insert(st, val, i) SKM_sk_insert(EVP_PBE_CTL, (st), (val), (i)) ++#define sk_EVP_PBE_CTL_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(EVP_PBE_CTL, (st), (cmp)) ++#define sk_EVP_PBE_CTL_dup(st) SKM_sk_dup(EVP_PBE_CTL, st) ++#define sk_EVP_PBE_CTL_pop_free(st, free_func) SKM_sk_pop_free(EVP_PBE_CTL, (st), (free_func)) ++#define sk_EVP_PBE_CTL_shift(st) SKM_sk_shift(EVP_PBE_CTL, (st)) ++#define sk_EVP_PBE_CTL_pop(st) SKM_sk_pop(EVP_PBE_CTL, (st)) ++#define sk_EVP_PBE_CTL_sort(st) SKM_sk_sort(EVP_PBE_CTL, (st)) ++#define sk_EVP_PBE_CTL_is_sorted(st) SKM_sk_is_sorted(EVP_PBE_CTL, (st)) ++ ++#define sk_EVP_PKEY_ASN1_METHOD_new(cmp) SKM_sk_new(EVP_PKEY_ASN1_METHOD, (cmp)) ++#define sk_EVP_PKEY_ASN1_METHOD_new_null() SKM_sk_new_null(EVP_PKEY_ASN1_METHOD) ++#define sk_EVP_PKEY_ASN1_METHOD_free(st) SKM_sk_free(EVP_PKEY_ASN1_METHOD, (st)) ++#define sk_EVP_PKEY_ASN1_METHOD_num(st) SKM_sk_num(EVP_PKEY_ASN1_METHOD, (st)) ++#define sk_EVP_PKEY_ASN1_METHOD_value(st, i) SKM_sk_value(EVP_PKEY_ASN1_METHOD, (st), (i)) ++#define sk_EVP_PKEY_ASN1_METHOD_set(st, i, val) SKM_sk_set(EVP_PKEY_ASN1_METHOD, (st), (i), (val)) ++#define sk_EVP_PKEY_ASN1_METHOD_zero(st) SKM_sk_zero(EVP_PKEY_ASN1_METHOD, (st)) ++#define sk_EVP_PKEY_ASN1_METHOD_push(st, val) SKM_sk_push(EVP_PKEY_ASN1_METHOD, (st), (val)) ++#define sk_EVP_PKEY_ASN1_METHOD_unshift(st, val) SKM_sk_unshift(EVP_PKEY_ASN1_METHOD, (st), (val)) ++#define sk_EVP_PKEY_ASN1_METHOD_find(st, val) SKM_sk_find(EVP_PKEY_ASN1_METHOD, (st), (val)) ++#define sk_EVP_PKEY_ASN1_METHOD_find_ex(st, val) SKM_sk_find_ex(EVP_PKEY_ASN1_METHOD, (st), (val)) ++#define sk_EVP_PKEY_ASN1_METHOD_delete(st, i) SKM_sk_delete(EVP_PKEY_ASN1_METHOD, (st), (i)) ++#define sk_EVP_PKEY_ASN1_METHOD_delete_ptr(st, ptr) SKM_sk_delete_ptr(EVP_PKEY_ASN1_METHOD, (st), (ptr)) ++#define sk_EVP_PKEY_ASN1_METHOD_insert(st, val, i) SKM_sk_insert(EVP_PKEY_ASN1_METHOD, (st), (val), (i)) ++#define sk_EVP_PKEY_ASN1_METHOD_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(EVP_PKEY_ASN1_METHOD, (st), (cmp)) ++#define sk_EVP_PKEY_ASN1_METHOD_dup(st) SKM_sk_dup(EVP_PKEY_ASN1_METHOD, st) ++#define sk_EVP_PKEY_ASN1_METHOD_pop_free(st, free_func) SKM_sk_pop_free(EVP_PKEY_ASN1_METHOD, (st), (free_func)) ++#define sk_EVP_PKEY_ASN1_METHOD_shift(st) SKM_sk_shift(EVP_PKEY_ASN1_METHOD, (st)) ++#define sk_EVP_PKEY_ASN1_METHOD_pop(st) SKM_sk_pop(EVP_PKEY_ASN1_METHOD, (st)) ++#define sk_EVP_PKEY_ASN1_METHOD_sort(st) SKM_sk_sort(EVP_PKEY_ASN1_METHOD, (st)) ++#define sk_EVP_PKEY_ASN1_METHOD_is_sorted(st) SKM_sk_is_sorted(EVP_PKEY_ASN1_METHOD, (st)) ++ ++#define sk_EVP_PKEY_METHOD_new(cmp) SKM_sk_new(EVP_PKEY_METHOD, (cmp)) ++#define sk_EVP_PKEY_METHOD_new_null() SKM_sk_new_null(EVP_PKEY_METHOD) ++#define sk_EVP_PKEY_METHOD_free(st) SKM_sk_free(EVP_PKEY_METHOD, (st)) ++#define sk_EVP_PKEY_METHOD_num(st) SKM_sk_num(EVP_PKEY_METHOD, (st)) ++#define sk_EVP_PKEY_METHOD_value(st, i) SKM_sk_value(EVP_PKEY_METHOD, (st), (i)) ++#define sk_EVP_PKEY_METHOD_set(st, i, val) SKM_sk_set(EVP_PKEY_METHOD, (st), (i), (val)) ++#define sk_EVP_PKEY_METHOD_zero(st) SKM_sk_zero(EVP_PKEY_METHOD, (st)) ++#define sk_EVP_PKEY_METHOD_push(st, val) SKM_sk_push(EVP_PKEY_METHOD, (st), (val)) ++#define sk_EVP_PKEY_METHOD_unshift(st, val) SKM_sk_unshift(EVP_PKEY_METHOD, (st), (val)) ++#define sk_EVP_PKEY_METHOD_find(st, val) SKM_sk_find(EVP_PKEY_METHOD, (st), (val)) ++#define sk_EVP_PKEY_METHOD_find_ex(st, val) SKM_sk_find_ex(EVP_PKEY_METHOD, (st), (val)) ++#define sk_EVP_PKEY_METHOD_delete(st, i) SKM_sk_delete(EVP_PKEY_METHOD, (st), (i)) ++#define sk_EVP_PKEY_METHOD_delete_ptr(st, ptr) SKM_sk_delete_ptr(EVP_PKEY_METHOD, (st), (ptr)) ++#define sk_EVP_PKEY_METHOD_insert(st, val, i) SKM_sk_insert(EVP_PKEY_METHOD, (st), (val), (i)) ++#define sk_EVP_PKEY_METHOD_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(EVP_PKEY_METHOD, (st), (cmp)) ++#define sk_EVP_PKEY_METHOD_dup(st) SKM_sk_dup(EVP_PKEY_METHOD, st) ++#define sk_EVP_PKEY_METHOD_pop_free(st, free_func) SKM_sk_pop_free(EVP_PKEY_METHOD, (st), (free_func)) ++#define sk_EVP_PKEY_METHOD_shift(st) SKM_sk_shift(EVP_PKEY_METHOD, (st)) ++#define sk_EVP_PKEY_METHOD_pop(st) SKM_sk_pop(EVP_PKEY_METHOD, (st)) ++#define sk_EVP_PKEY_METHOD_sort(st) SKM_sk_sort(EVP_PKEY_METHOD, (st)) ++#define sk_EVP_PKEY_METHOD_is_sorted(st) SKM_sk_is_sorted(EVP_PKEY_METHOD, (st)) ++ ++#define sk_GENERAL_NAME_new(cmp) SKM_sk_new(GENERAL_NAME, (cmp)) ++#define sk_GENERAL_NAME_new_null() SKM_sk_new_null(GENERAL_NAME) ++#define sk_GENERAL_NAME_free(st) SKM_sk_free(GENERAL_NAME, (st)) ++#define sk_GENERAL_NAME_num(st) SKM_sk_num(GENERAL_NAME, (st)) ++#define sk_GENERAL_NAME_value(st, i) SKM_sk_value(GENERAL_NAME, (st), (i)) ++#define sk_GENERAL_NAME_set(st, i, val) SKM_sk_set(GENERAL_NAME, (st), (i), (val)) ++#define sk_GENERAL_NAME_zero(st) SKM_sk_zero(GENERAL_NAME, (st)) ++#define sk_GENERAL_NAME_push(st, val) SKM_sk_push(GENERAL_NAME, (st), (val)) ++#define sk_GENERAL_NAME_unshift(st, val) SKM_sk_unshift(GENERAL_NAME, (st), (val)) ++#define sk_GENERAL_NAME_find(st, val) SKM_sk_find(GENERAL_NAME, (st), (val)) ++#define sk_GENERAL_NAME_find_ex(st, val) SKM_sk_find_ex(GENERAL_NAME, (st), (val)) ++#define sk_GENERAL_NAME_delete(st, i) SKM_sk_delete(GENERAL_NAME, (st), (i)) ++#define sk_GENERAL_NAME_delete_ptr(st, ptr) SKM_sk_delete_ptr(GENERAL_NAME, (st), (ptr)) ++#define sk_GENERAL_NAME_insert(st, val, i) SKM_sk_insert(GENERAL_NAME, (st), (val), (i)) ++#define sk_GENERAL_NAME_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(GENERAL_NAME, (st), (cmp)) ++#define sk_GENERAL_NAME_dup(st) SKM_sk_dup(GENERAL_NAME, st) ++#define sk_GENERAL_NAME_pop_free(st, free_func) SKM_sk_pop_free(GENERAL_NAME, (st), (free_func)) ++#define sk_GENERAL_NAME_shift(st) SKM_sk_shift(GENERAL_NAME, (st)) ++#define sk_GENERAL_NAME_pop(st) SKM_sk_pop(GENERAL_NAME, (st)) ++#define sk_GENERAL_NAME_sort(st) SKM_sk_sort(GENERAL_NAME, (st)) ++#define sk_GENERAL_NAME_is_sorted(st) SKM_sk_is_sorted(GENERAL_NAME, (st)) ++ ++#define sk_GENERAL_NAMES_new(cmp) SKM_sk_new(GENERAL_NAMES, (cmp)) ++#define sk_GENERAL_NAMES_new_null() SKM_sk_new_null(GENERAL_NAMES) ++#define sk_GENERAL_NAMES_free(st) SKM_sk_free(GENERAL_NAMES, (st)) ++#define sk_GENERAL_NAMES_num(st) SKM_sk_num(GENERAL_NAMES, (st)) ++#define sk_GENERAL_NAMES_value(st, i) SKM_sk_value(GENERAL_NAMES, (st), (i)) ++#define sk_GENERAL_NAMES_set(st, i, val) SKM_sk_set(GENERAL_NAMES, (st), (i), (val)) ++#define sk_GENERAL_NAMES_zero(st) SKM_sk_zero(GENERAL_NAMES, (st)) ++#define sk_GENERAL_NAMES_push(st, val) SKM_sk_push(GENERAL_NAMES, (st), (val)) ++#define sk_GENERAL_NAMES_unshift(st, val) SKM_sk_unshift(GENERAL_NAMES, (st), (val)) ++#define sk_GENERAL_NAMES_find(st, val) SKM_sk_find(GENERAL_NAMES, (st), (val)) ++#define sk_GENERAL_NAMES_find_ex(st, val) SKM_sk_find_ex(GENERAL_NAMES, (st), (val)) ++#define sk_GENERAL_NAMES_delete(st, i) SKM_sk_delete(GENERAL_NAMES, (st), (i)) ++#define sk_GENERAL_NAMES_delete_ptr(st, ptr) SKM_sk_delete_ptr(GENERAL_NAMES, (st), (ptr)) ++#define sk_GENERAL_NAMES_insert(st, val, i) SKM_sk_insert(GENERAL_NAMES, (st), (val), (i)) ++#define sk_GENERAL_NAMES_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(GENERAL_NAMES, (st), (cmp)) ++#define sk_GENERAL_NAMES_dup(st) SKM_sk_dup(GENERAL_NAMES, st) ++#define sk_GENERAL_NAMES_pop_free(st, free_func) SKM_sk_pop_free(GENERAL_NAMES, (st), (free_func)) ++#define sk_GENERAL_NAMES_shift(st) SKM_sk_shift(GENERAL_NAMES, (st)) ++#define sk_GENERAL_NAMES_pop(st) SKM_sk_pop(GENERAL_NAMES, (st)) ++#define sk_GENERAL_NAMES_sort(st) SKM_sk_sort(GENERAL_NAMES, (st)) ++#define sk_GENERAL_NAMES_is_sorted(st) SKM_sk_is_sorted(GENERAL_NAMES, (st)) ++ ++#define sk_GENERAL_SUBTREE_new(cmp) SKM_sk_new(GENERAL_SUBTREE, (cmp)) ++#define sk_GENERAL_SUBTREE_new_null() SKM_sk_new_null(GENERAL_SUBTREE) ++#define sk_GENERAL_SUBTREE_free(st) SKM_sk_free(GENERAL_SUBTREE, (st)) ++#define sk_GENERAL_SUBTREE_num(st) SKM_sk_num(GENERAL_SUBTREE, (st)) ++#define sk_GENERAL_SUBTREE_value(st, i) SKM_sk_value(GENERAL_SUBTREE, (st), (i)) ++#define sk_GENERAL_SUBTREE_set(st, i, val) SKM_sk_set(GENERAL_SUBTREE, (st), (i), (val)) ++#define sk_GENERAL_SUBTREE_zero(st) SKM_sk_zero(GENERAL_SUBTREE, (st)) ++#define sk_GENERAL_SUBTREE_push(st, val) SKM_sk_push(GENERAL_SUBTREE, (st), (val)) ++#define sk_GENERAL_SUBTREE_unshift(st, val) SKM_sk_unshift(GENERAL_SUBTREE, (st), (val)) ++#define sk_GENERAL_SUBTREE_find(st, val) SKM_sk_find(GENERAL_SUBTREE, (st), (val)) ++#define sk_GENERAL_SUBTREE_find_ex(st, val) SKM_sk_find_ex(GENERAL_SUBTREE, (st), (val)) ++#define sk_GENERAL_SUBTREE_delete(st, i) SKM_sk_delete(GENERAL_SUBTREE, (st), (i)) ++#define sk_GENERAL_SUBTREE_delete_ptr(st, ptr) SKM_sk_delete_ptr(GENERAL_SUBTREE, (st), (ptr)) ++#define sk_GENERAL_SUBTREE_insert(st, val, i) SKM_sk_insert(GENERAL_SUBTREE, (st), (val), (i)) ++#define sk_GENERAL_SUBTREE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(GENERAL_SUBTREE, (st), (cmp)) ++#define sk_GENERAL_SUBTREE_dup(st) SKM_sk_dup(GENERAL_SUBTREE, st) ++#define sk_GENERAL_SUBTREE_pop_free(st, free_func) SKM_sk_pop_free(GENERAL_SUBTREE, (st), (free_func)) ++#define sk_GENERAL_SUBTREE_shift(st) SKM_sk_shift(GENERAL_SUBTREE, (st)) ++#define sk_GENERAL_SUBTREE_pop(st) SKM_sk_pop(GENERAL_SUBTREE, (st)) ++#define sk_GENERAL_SUBTREE_sort(st) SKM_sk_sort(GENERAL_SUBTREE, (st)) ++#define sk_GENERAL_SUBTREE_is_sorted(st) SKM_sk_is_sorted(GENERAL_SUBTREE, (st)) ++ ++#define sk_IPAddressFamily_new(cmp) SKM_sk_new(IPAddressFamily, (cmp)) ++#define sk_IPAddressFamily_new_null() SKM_sk_new_null(IPAddressFamily) ++#define sk_IPAddressFamily_free(st) SKM_sk_free(IPAddressFamily, (st)) ++#define sk_IPAddressFamily_num(st) SKM_sk_num(IPAddressFamily, (st)) ++#define sk_IPAddressFamily_value(st, i) SKM_sk_value(IPAddressFamily, (st), (i)) ++#define sk_IPAddressFamily_set(st, i, val) SKM_sk_set(IPAddressFamily, (st), (i), (val)) ++#define sk_IPAddressFamily_zero(st) SKM_sk_zero(IPAddressFamily, (st)) ++#define sk_IPAddressFamily_push(st, val) SKM_sk_push(IPAddressFamily, (st), (val)) ++#define sk_IPAddressFamily_unshift(st, val) SKM_sk_unshift(IPAddressFamily, (st), (val)) ++#define sk_IPAddressFamily_find(st, val) SKM_sk_find(IPAddressFamily, (st), (val)) ++#define sk_IPAddressFamily_find_ex(st, val) SKM_sk_find_ex(IPAddressFamily, (st), (val)) ++#define sk_IPAddressFamily_delete(st, i) SKM_sk_delete(IPAddressFamily, (st), (i)) ++#define sk_IPAddressFamily_delete_ptr(st, ptr) SKM_sk_delete_ptr(IPAddressFamily, (st), (ptr)) ++#define sk_IPAddressFamily_insert(st, val, i) SKM_sk_insert(IPAddressFamily, (st), (val), (i)) ++#define sk_IPAddressFamily_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(IPAddressFamily, (st), (cmp)) ++#define sk_IPAddressFamily_dup(st) SKM_sk_dup(IPAddressFamily, st) ++#define sk_IPAddressFamily_pop_free(st, free_func) SKM_sk_pop_free(IPAddressFamily, (st), (free_func)) ++#define sk_IPAddressFamily_shift(st) SKM_sk_shift(IPAddressFamily, (st)) ++#define sk_IPAddressFamily_pop(st) SKM_sk_pop(IPAddressFamily, (st)) ++#define sk_IPAddressFamily_sort(st) SKM_sk_sort(IPAddressFamily, (st)) ++#define sk_IPAddressFamily_is_sorted(st) SKM_sk_is_sorted(IPAddressFamily, (st)) ++ ++#define sk_IPAddressOrRange_new(cmp) SKM_sk_new(IPAddressOrRange, (cmp)) ++#define sk_IPAddressOrRange_new_null() SKM_sk_new_null(IPAddressOrRange) ++#define sk_IPAddressOrRange_free(st) SKM_sk_free(IPAddressOrRange, (st)) ++#define sk_IPAddressOrRange_num(st) SKM_sk_num(IPAddressOrRange, (st)) ++#define sk_IPAddressOrRange_value(st, i) SKM_sk_value(IPAddressOrRange, (st), (i)) ++#define sk_IPAddressOrRange_set(st, i, val) SKM_sk_set(IPAddressOrRange, (st), (i), (val)) ++#define sk_IPAddressOrRange_zero(st) SKM_sk_zero(IPAddressOrRange, (st)) ++#define sk_IPAddressOrRange_push(st, val) SKM_sk_push(IPAddressOrRange, (st), (val)) ++#define sk_IPAddressOrRange_unshift(st, val) SKM_sk_unshift(IPAddressOrRange, (st), (val)) ++#define sk_IPAddressOrRange_find(st, val) SKM_sk_find(IPAddressOrRange, (st), (val)) ++#define sk_IPAddressOrRange_find_ex(st, val) SKM_sk_find_ex(IPAddressOrRange, (st), (val)) ++#define sk_IPAddressOrRange_delete(st, i) SKM_sk_delete(IPAddressOrRange, (st), (i)) ++#define sk_IPAddressOrRange_delete_ptr(st, ptr) SKM_sk_delete_ptr(IPAddressOrRange, (st), (ptr)) ++#define sk_IPAddressOrRange_insert(st, val, i) SKM_sk_insert(IPAddressOrRange, (st), (val), (i)) ++#define sk_IPAddressOrRange_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(IPAddressOrRange, (st), (cmp)) ++#define sk_IPAddressOrRange_dup(st) SKM_sk_dup(IPAddressOrRange, st) ++#define sk_IPAddressOrRange_pop_free(st, free_func) SKM_sk_pop_free(IPAddressOrRange, (st), (free_func)) ++#define sk_IPAddressOrRange_shift(st) SKM_sk_shift(IPAddressOrRange, (st)) ++#define sk_IPAddressOrRange_pop(st) SKM_sk_pop(IPAddressOrRange, (st)) ++#define sk_IPAddressOrRange_sort(st) SKM_sk_sort(IPAddressOrRange, (st)) ++#define sk_IPAddressOrRange_is_sorted(st) SKM_sk_is_sorted(IPAddressOrRange, (st)) ++ ++#define sk_KRB5_APREQBODY_new(cmp) SKM_sk_new(KRB5_APREQBODY, (cmp)) ++#define sk_KRB5_APREQBODY_new_null() SKM_sk_new_null(KRB5_APREQBODY) ++#define sk_KRB5_APREQBODY_free(st) SKM_sk_free(KRB5_APREQBODY, (st)) ++#define sk_KRB5_APREQBODY_num(st) SKM_sk_num(KRB5_APREQBODY, (st)) ++#define sk_KRB5_APREQBODY_value(st, i) SKM_sk_value(KRB5_APREQBODY, (st), (i)) ++#define sk_KRB5_APREQBODY_set(st, i, val) SKM_sk_set(KRB5_APREQBODY, (st), (i), (val)) ++#define sk_KRB5_APREQBODY_zero(st) SKM_sk_zero(KRB5_APREQBODY, (st)) ++#define sk_KRB5_APREQBODY_push(st, val) SKM_sk_push(KRB5_APREQBODY, (st), (val)) ++#define sk_KRB5_APREQBODY_unshift(st, val) SKM_sk_unshift(KRB5_APREQBODY, (st), (val)) ++#define sk_KRB5_APREQBODY_find(st, val) SKM_sk_find(KRB5_APREQBODY, (st), (val)) ++#define sk_KRB5_APREQBODY_find_ex(st, val) SKM_sk_find_ex(KRB5_APREQBODY, (st), (val)) ++#define sk_KRB5_APREQBODY_delete(st, i) SKM_sk_delete(KRB5_APREQBODY, (st), (i)) ++#define sk_KRB5_APREQBODY_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_APREQBODY, (st), (ptr)) ++#define sk_KRB5_APREQBODY_insert(st, val, i) SKM_sk_insert(KRB5_APREQBODY, (st), (val), (i)) ++#define sk_KRB5_APREQBODY_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_APREQBODY, (st), (cmp)) ++#define sk_KRB5_APREQBODY_dup(st) SKM_sk_dup(KRB5_APREQBODY, st) ++#define sk_KRB5_APREQBODY_pop_free(st, free_func) SKM_sk_pop_free(KRB5_APREQBODY, (st), (free_func)) ++#define sk_KRB5_APREQBODY_shift(st) SKM_sk_shift(KRB5_APREQBODY, (st)) ++#define sk_KRB5_APREQBODY_pop(st) SKM_sk_pop(KRB5_APREQBODY, (st)) ++#define sk_KRB5_APREQBODY_sort(st) SKM_sk_sort(KRB5_APREQBODY, (st)) ++#define sk_KRB5_APREQBODY_is_sorted(st) SKM_sk_is_sorted(KRB5_APREQBODY, (st)) ++ ++#define sk_KRB5_AUTHDATA_new(cmp) SKM_sk_new(KRB5_AUTHDATA, (cmp)) ++#define sk_KRB5_AUTHDATA_new_null() SKM_sk_new_null(KRB5_AUTHDATA) ++#define sk_KRB5_AUTHDATA_free(st) SKM_sk_free(KRB5_AUTHDATA, (st)) ++#define sk_KRB5_AUTHDATA_num(st) SKM_sk_num(KRB5_AUTHDATA, (st)) ++#define sk_KRB5_AUTHDATA_value(st, i) SKM_sk_value(KRB5_AUTHDATA, (st), (i)) ++#define sk_KRB5_AUTHDATA_set(st, i, val) SKM_sk_set(KRB5_AUTHDATA, (st), (i), (val)) ++#define sk_KRB5_AUTHDATA_zero(st) SKM_sk_zero(KRB5_AUTHDATA, (st)) ++#define sk_KRB5_AUTHDATA_push(st, val) SKM_sk_push(KRB5_AUTHDATA, (st), (val)) ++#define sk_KRB5_AUTHDATA_unshift(st, val) SKM_sk_unshift(KRB5_AUTHDATA, (st), (val)) ++#define sk_KRB5_AUTHDATA_find(st, val) SKM_sk_find(KRB5_AUTHDATA, (st), (val)) ++#define sk_KRB5_AUTHDATA_find_ex(st, val) SKM_sk_find_ex(KRB5_AUTHDATA, (st), (val)) ++#define sk_KRB5_AUTHDATA_delete(st, i) SKM_sk_delete(KRB5_AUTHDATA, (st), (i)) ++#define sk_KRB5_AUTHDATA_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_AUTHDATA, (st), (ptr)) ++#define sk_KRB5_AUTHDATA_insert(st, val, i) SKM_sk_insert(KRB5_AUTHDATA, (st), (val), (i)) ++#define sk_KRB5_AUTHDATA_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_AUTHDATA, (st), (cmp)) ++#define sk_KRB5_AUTHDATA_dup(st) SKM_sk_dup(KRB5_AUTHDATA, st) ++#define sk_KRB5_AUTHDATA_pop_free(st, free_func) SKM_sk_pop_free(KRB5_AUTHDATA, (st), (free_func)) ++#define sk_KRB5_AUTHDATA_shift(st) SKM_sk_shift(KRB5_AUTHDATA, (st)) ++#define sk_KRB5_AUTHDATA_pop(st) SKM_sk_pop(KRB5_AUTHDATA, (st)) ++#define sk_KRB5_AUTHDATA_sort(st) SKM_sk_sort(KRB5_AUTHDATA, (st)) ++#define sk_KRB5_AUTHDATA_is_sorted(st) SKM_sk_is_sorted(KRB5_AUTHDATA, (st)) ++ ++#define sk_KRB5_AUTHENTBODY_new(cmp) SKM_sk_new(KRB5_AUTHENTBODY, (cmp)) ++#define sk_KRB5_AUTHENTBODY_new_null() SKM_sk_new_null(KRB5_AUTHENTBODY) ++#define sk_KRB5_AUTHENTBODY_free(st) SKM_sk_free(KRB5_AUTHENTBODY, (st)) ++#define sk_KRB5_AUTHENTBODY_num(st) SKM_sk_num(KRB5_AUTHENTBODY, (st)) ++#define sk_KRB5_AUTHENTBODY_value(st, i) SKM_sk_value(KRB5_AUTHENTBODY, (st), (i)) ++#define sk_KRB5_AUTHENTBODY_set(st, i, val) SKM_sk_set(KRB5_AUTHENTBODY, (st), (i), (val)) ++#define sk_KRB5_AUTHENTBODY_zero(st) SKM_sk_zero(KRB5_AUTHENTBODY, (st)) ++#define sk_KRB5_AUTHENTBODY_push(st, val) SKM_sk_push(KRB5_AUTHENTBODY, (st), (val)) ++#define sk_KRB5_AUTHENTBODY_unshift(st, val) SKM_sk_unshift(KRB5_AUTHENTBODY, (st), (val)) ++#define sk_KRB5_AUTHENTBODY_find(st, val) SKM_sk_find(KRB5_AUTHENTBODY, (st), (val)) ++#define sk_KRB5_AUTHENTBODY_find_ex(st, val) SKM_sk_find_ex(KRB5_AUTHENTBODY, (st), (val)) ++#define sk_KRB5_AUTHENTBODY_delete(st, i) SKM_sk_delete(KRB5_AUTHENTBODY, (st), (i)) ++#define sk_KRB5_AUTHENTBODY_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_AUTHENTBODY, (st), (ptr)) ++#define sk_KRB5_AUTHENTBODY_insert(st, val, i) SKM_sk_insert(KRB5_AUTHENTBODY, (st), (val), (i)) ++#define sk_KRB5_AUTHENTBODY_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_AUTHENTBODY, (st), (cmp)) ++#define sk_KRB5_AUTHENTBODY_dup(st) SKM_sk_dup(KRB5_AUTHENTBODY, st) ++#define sk_KRB5_AUTHENTBODY_pop_free(st, free_func) SKM_sk_pop_free(KRB5_AUTHENTBODY, (st), (free_func)) ++#define sk_KRB5_AUTHENTBODY_shift(st) SKM_sk_shift(KRB5_AUTHENTBODY, (st)) ++#define sk_KRB5_AUTHENTBODY_pop(st) SKM_sk_pop(KRB5_AUTHENTBODY, (st)) ++#define sk_KRB5_AUTHENTBODY_sort(st) SKM_sk_sort(KRB5_AUTHENTBODY, (st)) ++#define sk_KRB5_AUTHENTBODY_is_sorted(st) SKM_sk_is_sorted(KRB5_AUTHENTBODY, (st)) ++ ++#define sk_KRB5_CHECKSUM_new(cmp) SKM_sk_new(KRB5_CHECKSUM, (cmp)) ++#define sk_KRB5_CHECKSUM_new_null() SKM_sk_new_null(KRB5_CHECKSUM) ++#define sk_KRB5_CHECKSUM_free(st) SKM_sk_free(KRB5_CHECKSUM, (st)) ++#define sk_KRB5_CHECKSUM_num(st) SKM_sk_num(KRB5_CHECKSUM, (st)) ++#define sk_KRB5_CHECKSUM_value(st, i) SKM_sk_value(KRB5_CHECKSUM, (st), (i)) ++#define sk_KRB5_CHECKSUM_set(st, i, val) SKM_sk_set(KRB5_CHECKSUM, (st), (i), (val)) ++#define sk_KRB5_CHECKSUM_zero(st) SKM_sk_zero(KRB5_CHECKSUM, (st)) ++#define sk_KRB5_CHECKSUM_push(st, val) SKM_sk_push(KRB5_CHECKSUM, (st), (val)) ++#define sk_KRB5_CHECKSUM_unshift(st, val) SKM_sk_unshift(KRB5_CHECKSUM, (st), (val)) ++#define sk_KRB5_CHECKSUM_find(st, val) SKM_sk_find(KRB5_CHECKSUM, (st), (val)) ++#define sk_KRB5_CHECKSUM_find_ex(st, val) SKM_sk_find_ex(KRB5_CHECKSUM, (st), (val)) ++#define sk_KRB5_CHECKSUM_delete(st, i) SKM_sk_delete(KRB5_CHECKSUM, (st), (i)) ++#define sk_KRB5_CHECKSUM_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_CHECKSUM, (st), (ptr)) ++#define sk_KRB5_CHECKSUM_insert(st, val, i) SKM_sk_insert(KRB5_CHECKSUM, (st), (val), (i)) ++#define sk_KRB5_CHECKSUM_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_CHECKSUM, (st), (cmp)) ++#define sk_KRB5_CHECKSUM_dup(st) SKM_sk_dup(KRB5_CHECKSUM, st) ++#define sk_KRB5_CHECKSUM_pop_free(st, free_func) SKM_sk_pop_free(KRB5_CHECKSUM, (st), (free_func)) ++#define sk_KRB5_CHECKSUM_shift(st) SKM_sk_shift(KRB5_CHECKSUM, (st)) ++#define sk_KRB5_CHECKSUM_pop(st) SKM_sk_pop(KRB5_CHECKSUM, (st)) ++#define sk_KRB5_CHECKSUM_sort(st) SKM_sk_sort(KRB5_CHECKSUM, (st)) ++#define sk_KRB5_CHECKSUM_is_sorted(st) SKM_sk_is_sorted(KRB5_CHECKSUM, (st)) ++ ++#define sk_KRB5_ENCDATA_new(cmp) SKM_sk_new(KRB5_ENCDATA, (cmp)) ++#define sk_KRB5_ENCDATA_new_null() SKM_sk_new_null(KRB5_ENCDATA) ++#define sk_KRB5_ENCDATA_free(st) SKM_sk_free(KRB5_ENCDATA, (st)) ++#define sk_KRB5_ENCDATA_num(st) SKM_sk_num(KRB5_ENCDATA, (st)) ++#define sk_KRB5_ENCDATA_value(st, i) SKM_sk_value(KRB5_ENCDATA, (st), (i)) ++#define sk_KRB5_ENCDATA_set(st, i, val) SKM_sk_set(KRB5_ENCDATA, (st), (i), (val)) ++#define sk_KRB5_ENCDATA_zero(st) SKM_sk_zero(KRB5_ENCDATA, (st)) ++#define sk_KRB5_ENCDATA_push(st, val) SKM_sk_push(KRB5_ENCDATA, (st), (val)) ++#define sk_KRB5_ENCDATA_unshift(st, val) SKM_sk_unshift(KRB5_ENCDATA, (st), (val)) ++#define sk_KRB5_ENCDATA_find(st, val) SKM_sk_find(KRB5_ENCDATA, (st), (val)) ++#define sk_KRB5_ENCDATA_find_ex(st, val) SKM_sk_find_ex(KRB5_ENCDATA, (st), (val)) ++#define sk_KRB5_ENCDATA_delete(st, i) SKM_sk_delete(KRB5_ENCDATA, (st), (i)) ++#define sk_KRB5_ENCDATA_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_ENCDATA, (st), (ptr)) ++#define sk_KRB5_ENCDATA_insert(st, val, i) SKM_sk_insert(KRB5_ENCDATA, (st), (val), (i)) ++#define sk_KRB5_ENCDATA_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_ENCDATA, (st), (cmp)) ++#define sk_KRB5_ENCDATA_dup(st) SKM_sk_dup(KRB5_ENCDATA, st) ++#define sk_KRB5_ENCDATA_pop_free(st, free_func) SKM_sk_pop_free(KRB5_ENCDATA, (st), (free_func)) ++#define sk_KRB5_ENCDATA_shift(st) SKM_sk_shift(KRB5_ENCDATA, (st)) ++#define sk_KRB5_ENCDATA_pop(st) SKM_sk_pop(KRB5_ENCDATA, (st)) ++#define sk_KRB5_ENCDATA_sort(st) SKM_sk_sort(KRB5_ENCDATA, (st)) ++#define sk_KRB5_ENCDATA_is_sorted(st) SKM_sk_is_sorted(KRB5_ENCDATA, (st)) ++ ++#define sk_KRB5_ENCKEY_new(cmp) SKM_sk_new(KRB5_ENCKEY, (cmp)) ++#define sk_KRB5_ENCKEY_new_null() SKM_sk_new_null(KRB5_ENCKEY) ++#define sk_KRB5_ENCKEY_free(st) SKM_sk_free(KRB5_ENCKEY, (st)) ++#define sk_KRB5_ENCKEY_num(st) SKM_sk_num(KRB5_ENCKEY, (st)) ++#define sk_KRB5_ENCKEY_value(st, i) SKM_sk_value(KRB5_ENCKEY, (st), (i)) ++#define sk_KRB5_ENCKEY_set(st, i, val) SKM_sk_set(KRB5_ENCKEY, (st), (i), (val)) ++#define sk_KRB5_ENCKEY_zero(st) SKM_sk_zero(KRB5_ENCKEY, (st)) ++#define sk_KRB5_ENCKEY_push(st, val) SKM_sk_push(KRB5_ENCKEY, (st), (val)) ++#define sk_KRB5_ENCKEY_unshift(st, val) SKM_sk_unshift(KRB5_ENCKEY, (st), (val)) ++#define sk_KRB5_ENCKEY_find(st, val) SKM_sk_find(KRB5_ENCKEY, (st), (val)) ++#define sk_KRB5_ENCKEY_find_ex(st, val) SKM_sk_find_ex(KRB5_ENCKEY, (st), (val)) ++#define sk_KRB5_ENCKEY_delete(st, i) SKM_sk_delete(KRB5_ENCKEY, (st), (i)) ++#define sk_KRB5_ENCKEY_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_ENCKEY, (st), (ptr)) ++#define sk_KRB5_ENCKEY_insert(st, val, i) SKM_sk_insert(KRB5_ENCKEY, (st), (val), (i)) ++#define sk_KRB5_ENCKEY_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_ENCKEY, (st), (cmp)) ++#define sk_KRB5_ENCKEY_dup(st) SKM_sk_dup(KRB5_ENCKEY, st) ++#define sk_KRB5_ENCKEY_pop_free(st, free_func) SKM_sk_pop_free(KRB5_ENCKEY, (st), (free_func)) ++#define sk_KRB5_ENCKEY_shift(st) SKM_sk_shift(KRB5_ENCKEY, (st)) ++#define sk_KRB5_ENCKEY_pop(st) SKM_sk_pop(KRB5_ENCKEY, (st)) ++#define sk_KRB5_ENCKEY_sort(st) SKM_sk_sort(KRB5_ENCKEY, (st)) ++#define sk_KRB5_ENCKEY_is_sorted(st) SKM_sk_is_sorted(KRB5_ENCKEY, (st)) ++ ++#define sk_KRB5_PRINCNAME_new(cmp) SKM_sk_new(KRB5_PRINCNAME, (cmp)) ++#define sk_KRB5_PRINCNAME_new_null() SKM_sk_new_null(KRB5_PRINCNAME) ++#define sk_KRB5_PRINCNAME_free(st) SKM_sk_free(KRB5_PRINCNAME, (st)) ++#define sk_KRB5_PRINCNAME_num(st) SKM_sk_num(KRB5_PRINCNAME, (st)) ++#define sk_KRB5_PRINCNAME_value(st, i) SKM_sk_value(KRB5_PRINCNAME, (st), (i)) ++#define sk_KRB5_PRINCNAME_set(st, i, val) SKM_sk_set(KRB5_PRINCNAME, (st), (i), (val)) ++#define sk_KRB5_PRINCNAME_zero(st) SKM_sk_zero(KRB5_PRINCNAME, (st)) ++#define sk_KRB5_PRINCNAME_push(st, val) SKM_sk_push(KRB5_PRINCNAME, (st), (val)) ++#define sk_KRB5_PRINCNAME_unshift(st, val) SKM_sk_unshift(KRB5_PRINCNAME, (st), (val)) ++#define sk_KRB5_PRINCNAME_find(st, val) SKM_sk_find(KRB5_PRINCNAME, (st), (val)) ++#define sk_KRB5_PRINCNAME_find_ex(st, val) SKM_sk_find_ex(KRB5_PRINCNAME, (st), (val)) ++#define sk_KRB5_PRINCNAME_delete(st, i) SKM_sk_delete(KRB5_PRINCNAME, (st), (i)) ++#define sk_KRB5_PRINCNAME_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_PRINCNAME, (st), (ptr)) ++#define sk_KRB5_PRINCNAME_insert(st, val, i) SKM_sk_insert(KRB5_PRINCNAME, (st), (val), (i)) ++#define sk_KRB5_PRINCNAME_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_PRINCNAME, (st), (cmp)) ++#define sk_KRB5_PRINCNAME_dup(st) SKM_sk_dup(KRB5_PRINCNAME, st) ++#define sk_KRB5_PRINCNAME_pop_free(st, free_func) SKM_sk_pop_free(KRB5_PRINCNAME, (st), (free_func)) ++#define sk_KRB5_PRINCNAME_shift(st) SKM_sk_shift(KRB5_PRINCNAME, (st)) ++#define sk_KRB5_PRINCNAME_pop(st) SKM_sk_pop(KRB5_PRINCNAME, (st)) ++#define sk_KRB5_PRINCNAME_sort(st) SKM_sk_sort(KRB5_PRINCNAME, (st)) ++#define sk_KRB5_PRINCNAME_is_sorted(st) SKM_sk_is_sorted(KRB5_PRINCNAME, (st)) ++ ++#define sk_KRB5_TKTBODY_new(cmp) SKM_sk_new(KRB5_TKTBODY, (cmp)) ++#define sk_KRB5_TKTBODY_new_null() SKM_sk_new_null(KRB5_TKTBODY) ++#define sk_KRB5_TKTBODY_free(st) SKM_sk_free(KRB5_TKTBODY, (st)) ++#define sk_KRB5_TKTBODY_num(st) SKM_sk_num(KRB5_TKTBODY, (st)) ++#define sk_KRB5_TKTBODY_value(st, i) SKM_sk_value(KRB5_TKTBODY, (st), (i)) ++#define sk_KRB5_TKTBODY_set(st, i, val) SKM_sk_set(KRB5_TKTBODY, (st), (i), (val)) ++#define sk_KRB5_TKTBODY_zero(st) SKM_sk_zero(KRB5_TKTBODY, (st)) ++#define sk_KRB5_TKTBODY_push(st, val) SKM_sk_push(KRB5_TKTBODY, (st), (val)) ++#define sk_KRB5_TKTBODY_unshift(st, val) SKM_sk_unshift(KRB5_TKTBODY, (st), (val)) ++#define sk_KRB5_TKTBODY_find(st, val) SKM_sk_find(KRB5_TKTBODY, (st), (val)) ++#define sk_KRB5_TKTBODY_find_ex(st, val) SKM_sk_find_ex(KRB5_TKTBODY, (st), (val)) ++#define sk_KRB5_TKTBODY_delete(st, i) SKM_sk_delete(KRB5_TKTBODY, (st), (i)) ++#define sk_KRB5_TKTBODY_delete_ptr(st, ptr) SKM_sk_delete_ptr(KRB5_TKTBODY, (st), (ptr)) ++#define sk_KRB5_TKTBODY_insert(st, val, i) SKM_sk_insert(KRB5_TKTBODY, (st), (val), (i)) ++#define sk_KRB5_TKTBODY_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(KRB5_TKTBODY, (st), (cmp)) ++#define sk_KRB5_TKTBODY_dup(st) SKM_sk_dup(KRB5_TKTBODY, st) ++#define sk_KRB5_TKTBODY_pop_free(st, free_func) SKM_sk_pop_free(KRB5_TKTBODY, (st), (free_func)) ++#define sk_KRB5_TKTBODY_shift(st) SKM_sk_shift(KRB5_TKTBODY, (st)) ++#define sk_KRB5_TKTBODY_pop(st) SKM_sk_pop(KRB5_TKTBODY, (st)) ++#define sk_KRB5_TKTBODY_sort(st) SKM_sk_sort(KRB5_TKTBODY, (st)) ++#define sk_KRB5_TKTBODY_is_sorted(st) SKM_sk_is_sorted(KRB5_TKTBODY, (st)) ++ ++#define sk_MEM_OBJECT_DATA_new(cmp) SKM_sk_new(MEM_OBJECT_DATA, (cmp)) ++#define sk_MEM_OBJECT_DATA_new_null() SKM_sk_new_null(MEM_OBJECT_DATA) ++#define sk_MEM_OBJECT_DATA_free(st) SKM_sk_free(MEM_OBJECT_DATA, (st)) ++#define sk_MEM_OBJECT_DATA_num(st) SKM_sk_num(MEM_OBJECT_DATA, (st)) ++#define sk_MEM_OBJECT_DATA_value(st, i) SKM_sk_value(MEM_OBJECT_DATA, (st), (i)) ++#define sk_MEM_OBJECT_DATA_set(st, i, val) SKM_sk_set(MEM_OBJECT_DATA, (st), (i), (val)) ++#define sk_MEM_OBJECT_DATA_zero(st) SKM_sk_zero(MEM_OBJECT_DATA, (st)) ++#define sk_MEM_OBJECT_DATA_push(st, val) SKM_sk_push(MEM_OBJECT_DATA, (st), (val)) ++#define sk_MEM_OBJECT_DATA_unshift(st, val) SKM_sk_unshift(MEM_OBJECT_DATA, (st), (val)) ++#define sk_MEM_OBJECT_DATA_find(st, val) SKM_sk_find(MEM_OBJECT_DATA, (st), (val)) ++#define sk_MEM_OBJECT_DATA_find_ex(st, val) SKM_sk_find_ex(MEM_OBJECT_DATA, (st), (val)) ++#define sk_MEM_OBJECT_DATA_delete(st, i) SKM_sk_delete(MEM_OBJECT_DATA, (st), (i)) ++#define sk_MEM_OBJECT_DATA_delete_ptr(st, ptr) SKM_sk_delete_ptr(MEM_OBJECT_DATA, (st), (ptr)) ++#define sk_MEM_OBJECT_DATA_insert(st, val, i) SKM_sk_insert(MEM_OBJECT_DATA, (st), (val), (i)) ++#define sk_MEM_OBJECT_DATA_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(MEM_OBJECT_DATA, (st), (cmp)) ++#define sk_MEM_OBJECT_DATA_dup(st) SKM_sk_dup(MEM_OBJECT_DATA, st) ++#define sk_MEM_OBJECT_DATA_pop_free(st, free_func) SKM_sk_pop_free(MEM_OBJECT_DATA, (st), (free_func)) ++#define sk_MEM_OBJECT_DATA_shift(st) SKM_sk_shift(MEM_OBJECT_DATA, (st)) ++#define sk_MEM_OBJECT_DATA_pop(st) SKM_sk_pop(MEM_OBJECT_DATA, (st)) ++#define sk_MEM_OBJECT_DATA_sort(st) SKM_sk_sort(MEM_OBJECT_DATA, (st)) ++#define sk_MEM_OBJECT_DATA_is_sorted(st) SKM_sk_is_sorted(MEM_OBJECT_DATA, (st)) ++ ++#define sk_MIME_HEADER_new(cmp) SKM_sk_new(MIME_HEADER, (cmp)) ++#define sk_MIME_HEADER_new_null() SKM_sk_new_null(MIME_HEADER) ++#define sk_MIME_HEADER_free(st) SKM_sk_free(MIME_HEADER, (st)) ++#define sk_MIME_HEADER_num(st) SKM_sk_num(MIME_HEADER, (st)) ++#define sk_MIME_HEADER_value(st, i) SKM_sk_value(MIME_HEADER, (st), (i)) ++#define sk_MIME_HEADER_set(st, i, val) SKM_sk_set(MIME_HEADER, (st), (i), (val)) ++#define sk_MIME_HEADER_zero(st) SKM_sk_zero(MIME_HEADER, (st)) ++#define sk_MIME_HEADER_push(st, val) SKM_sk_push(MIME_HEADER, (st), (val)) ++#define sk_MIME_HEADER_unshift(st, val) SKM_sk_unshift(MIME_HEADER, (st), (val)) ++#define sk_MIME_HEADER_find(st, val) SKM_sk_find(MIME_HEADER, (st), (val)) ++#define sk_MIME_HEADER_find_ex(st, val) SKM_sk_find_ex(MIME_HEADER, (st), (val)) ++#define sk_MIME_HEADER_delete(st, i) SKM_sk_delete(MIME_HEADER, (st), (i)) ++#define sk_MIME_HEADER_delete_ptr(st, ptr) SKM_sk_delete_ptr(MIME_HEADER, (st), (ptr)) ++#define sk_MIME_HEADER_insert(st, val, i) SKM_sk_insert(MIME_HEADER, (st), (val), (i)) ++#define sk_MIME_HEADER_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(MIME_HEADER, (st), (cmp)) ++#define sk_MIME_HEADER_dup(st) SKM_sk_dup(MIME_HEADER, st) ++#define sk_MIME_HEADER_pop_free(st, free_func) SKM_sk_pop_free(MIME_HEADER, (st), (free_func)) ++#define sk_MIME_HEADER_shift(st) SKM_sk_shift(MIME_HEADER, (st)) ++#define sk_MIME_HEADER_pop(st) SKM_sk_pop(MIME_HEADER, (st)) ++#define sk_MIME_HEADER_sort(st) SKM_sk_sort(MIME_HEADER, (st)) ++#define sk_MIME_HEADER_is_sorted(st) SKM_sk_is_sorted(MIME_HEADER, (st)) ++ ++#define sk_MIME_PARAM_new(cmp) SKM_sk_new(MIME_PARAM, (cmp)) ++#define sk_MIME_PARAM_new_null() SKM_sk_new_null(MIME_PARAM) ++#define sk_MIME_PARAM_free(st) SKM_sk_free(MIME_PARAM, (st)) ++#define sk_MIME_PARAM_num(st) SKM_sk_num(MIME_PARAM, (st)) ++#define sk_MIME_PARAM_value(st, i) SKM_sk_value(MIME_PARAM, (st), (i)) ++#define sk_MIME_PARAM_set(st, i, val) SKM_sk_set(MIME_PARAM, (st), (i), (val)) ++#define sk_MIME_PARAM_zero(st) SKM_sk_zero(MIME_PARAM, (st)) ++#define sk_MIME_PARAM_push(st, val) SKM_sk_push(MIME_PARAM, (st), (val)) ++#define sk_MIME_PARAM_unshift(st, val) SKM_sk_unshift(MIME_PARAM, (st), (val)) ++#define sk_MIME_PARAM_find(st, val) SKM_sk_find(MIME_PARAM, (st), (val)) ++#define sk_MIME_PARAM_find_ex(st, val) SKM_sk_find_ex(MIME_PARAM, (st), (val)) ++#define sk_MIME_PARAM_delete(st, i) SKM_sk_delete(MIME_PARAM, (st), (i)) ++#define sk_MIME_PARAM_delete_ptr(st, ptr) SKM_sk_delete_ptr(MIME_PARAM, (st), (ptr)) ++#define sk_MIME_PARAM_insert(st, val, i) SKM_sk_insert(MIME_PARAM, (st), (val), (i)) ++#define sk_MIME_PARAM_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(MIME_PARAM, (st), (cmp)) ++#define sk_MIME_PARAM_dup(st) SKM_sk_dup(MIME_PARAM, st) ++#define sk_MIME_PARAM_pop_free(st, free_func) SKM_sk_pop_free(MIME_PARAM, (st), (free_func)) ++#define sk_MIME_PARAM_shift(st) SKM_sk_shift(MIME_PARAM, (st)) ++#define sk_MIME_PARAM_pop(st) SKM_sk_pop(MIME_PARAM, (st)) ++#define sk_MIME_PARAM_sort(st) SKM_sk_sort(MIME_PARAM, (st)) ++#define sk_MIME_PARAM_is_sorted(st) SKM_sk_is_sorted(MIME_PARAM, (st)) ++ ++#define sk_NAME_FUNCS_new(cmp) SKM_sk_new(NAME_FUNCS, (cmp)) ++#define sk_NAME_FUNCS_new_null() SKM_sk_new_null(NAME_FUNCS) ++#define sk_NAME_FUNCS_free(st) SKM_sk_free(NAME_FUNCS, (st)) ++#define sk_NAME_FUNCS_num(st) SKM_sk_num(NAME_FUNCS, (st)) ++#define sk_NAME_FUNCS_value(st, i) SKM_sk_value(NAME_FUNCS, (st), (i)) ++#define sk_NAME_FUNCS_set(st, i, val) SKM_sk_set(NAME_FUNCS, (st), (i), (val)) ++#define sk_NAME_FUNCS_zero(st) SKM_sk_zero(NAME_FUNCS, (st)) ++#define sk_NAME_FUNCS_push(st, val) SKM_sk_push(NAME_FUNCS, (st), (val)) ++#define sk_NAME_FUNCS_unshift(st, val) SKM_sk_unshift(NAME_FUNCS, (st), (val)) ++#define sk_NAME_FUNCS_find(st, val) SKM_sk_find(NAME_FUNCS, (st), (val)) ++#define sk_NAME_FUNCS_find_ex(st, val) SKM_sk_find_ex(NAME_FUNCS, (st), (val)) ++#define sk_NAME_FUNCS_delete(st, i) SKM_sk_delete(NAME_FUNCS, (st), (i)) ++#define sk_NAME_FUNCS_delete_ptr(st, ptr) SKM_sk_delete_ptr(NAME_FUNCS, (st), (ptr)) ++#define sk_NAME_FUNCS_insert(st, val, i) SKM_sk_insert(NAME_FUNCS, (st), (val), (i)) ++#define sk_NAME_FUNCS_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(NAME_FUNCS, (st), (cmp)) ++#define sk_NAME_FUNCS_dup(st) SKM_sk_dup(NAME_FUNCS, st) ++#define sk_NAME_FUNCS_pop_free(st, free_func) SKM_sk_pop_free(NAME_FUNCS, (st), (free_func)) ++#define sk_NAME_FUNCS_shift(st) SKM_sk_shift(NAME_FUNCS, (st)) ++#define sk_NAME_FUNCS_pop(st) SKM_sk_pop(NAME_FUNCS, (st)) ++#define sk_NAME_FUNCS_sort(st) SKM_sk_sort(NAME_FUNCS, (st)) ++#define sk_NAME_FUNCS_is_sorted(st) SKM_sk_is_sorted(NAME_FUNCS, (st)) ++ ++#define sk_OCSP_CERTID_new(cmp) SKM_sk_new(OCSP_CERTID, (cmp)) ++#define sk_OCSP_CERTID_new_null() SKM_sk_new_null(OCSP_CERTID) ++#define sk_OCSP_CERTID_free(st) SKM_sk_free(OCSP_CERTID, (st)) ++#define sk_OCSP_CERTID_num(st) SKM_sk_num(OCSP_CERTID, (st)) ++#define sk_OCSP_CERTID_value(st, i) SKM_sk_value(OCSP_CERTID, (st), (i)) ++#define sk_OCSP_CERTID_set(st, i, val) SKM_sk_set(OCSP_CERTID, (st), (i), (val)) ++#define sk_OCSP_CERTID_zero(st) SKM_sk_zero(OCSP_CERTID, (st)) ++#define sk_OCSP_CERTID_push(st, val) SKM_sk_push(OCSP_CERTID, (st), (val)) ++#define sk_OCSP_CERTID_unshift(st, val) SKM_sk_unshift(OCSP_CERTID, (st), (val)) ++#define sk_OCSP_CERTID_find(st, val) SKM_sk_find(OCSP_CERTID, (st), (val)) ++#define sk_OCSP_CERTID_find_ex(st, val) SKM_sk_find_ex(OCSP_CERTID, (st), (val)) ++#define sk_OCSP_CERTID_delete(st, i) SKM_sk_delete(OCSP_CERTID, (st), (i)) ++#define sk_OCSP_CERTID_delete_ptr(st, ptr) SKM_sk_delete_ptr(OCSP_CERTID, (st), (ptr)) ++#define sk_OCSP_CERTID_insert(st, val, i) SKM_sk_insert(OCSP_CERTID, (st), (val), (i)) ++#define sk_OCSP_CERTID_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(OCSP_CERTID, (st), (cmp)) ++#define sk_OCSP_CERTID_dup(st) SKM_sk_dup(OCSP_CERTID, st) ++#define sk_OCSP_CERTID_pop_free(st, free_func) SKM_sk_pop_free(OCSP_CERTID, (st), (free_func)) ++#define sk_OCSP_CERTID_shift(st) SKM_sk_shift(OCSP_CERTID, (st)) ++#define sk_OCSP_CERTID_pop(st) SKM_sk_pop(OCSP_CERTID, (st)) ++#define sk_OCSP_CERTID_sort(st) SKM_sk_sort(OCSP_CERTID, (st)) ++#define sk_OCSP_CERTID_is_sorted(st) SKM_sk_is_sorted(OCSP_CERTID, (st)) ++ ++#define sk_OCSP_ONEREQ_new(cmp) SKM_sk_new(OCSP_ONEREQ, (cmp)) ++#define sk_OCSP_ONEREQ_new_null() SKM_sk_new_null(OCSP_ONEREQ) ++#define sk_OCSP_ONEREQ_free(st) SKM_sk_free(OCSP_ONEREQ, (st)) ++#define sk_OCSP_ONEREQ_num(st) SKM_sk_num(OCSP_ONEREQ, (st)) ++#define sk_OCSP_ONEREQ_value(st, i) SKM_sk_value(OCSP_ONEREQ, (st), (i)) ++#define sk_OCSP_ONEREQ_set(st, i, val) SKM_sk_set(OCSP_ONEREQ, (st), (i), (val)) ++#define sk_OCSP_ONEREQ_zero(st) SKM_sk_zero(OCSP_ONEREQ, (st)) ++#define sk_OCSP_ONEREQ_push(st, val) SKM_sk_push(OCSP_ONEREQ, (st), (val)) ++#define sk_OCSP_ONEREQ_unshift(st, val) SKM_sk_unshift(OCSP_ONEREQ, (st), (val)) ++#define sk_OCSP_ONEREQ_find(st, val) SKM_sk_find(OCSP_ONEREQ, (st), (val)) ++#define sk_OCSP_ONEREQ_find_ex(st, val) SKM_sk_find_ex(OCSP_ONEREQ, (st), (val)) ++#define sk_OCSP_ONEREQ_delete(st, i) SKM_sk_delete(OCSP_ONEREQ, (st), (i)) ++#define sk_OCSP_ONEREQ_delete_ptr(st, ptr) SKM_sk_delete_ptr(OCSP_ONEREQ, (st), (ptr)) ++#define sk_OCSP_ONEREQ_insert(st, val, i) SKM_sk_insert(OCSP_ONEREQ, (st), (val), (i)) ++#define sk_OCSP_ONEREQ_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(OCSP_ONEREQ, (st), (cmp)) ++#define sk_OCSP_ONEREQ_dup(st) SKM_sk_dup(OCSP_ONEREQ, st) ++#define sk_OCSP_ONEREQ_pop_free(st, free_func) SKM_sk_pop_free(OCSP_ONEREQ, (st), (free_func)) ++#define sk_OCSP_ONEREQ_shift(st) SKM_sk_shift(OCSP_ONEREQ, (st)) ++#define sk_OCSP_ONEREQ_pop(st) SKM_sk_pop(OCSP_ONEREQ, (st)) ++#define sk_OCSP_ONEREQ_sort(st) SKM_sk_sort(OCSP_ONEREQ, (st)) ++#define sk_OCSP_ONEREQ_is_sorted(st) SKM_sk_is_sorted(OCSP_ONEREQ, (st)) ++ ++#define sk_OCSP_RESPID_new(cmp) SKM_sk_new(OCSP_RESPID, (cmp)) ++#define sk_OCSP_RESPID_new_null() SKM_sk_new_null(OCSP_RESPID) ++#define sk_OCSP_RESPID_free(st) SKM_sk_free(OCSP_RESPID, (st)) ++#define sk_OCSP_RESPID_num(st) SKM_sk_num(OCSP_RESPID, (st)) ++#define sk_OCSP_RESPID_value(st, i) SKM_sk_value(OCSP_RESPID, (st), (i)) ++#define sk_OCSP_RESPID_set(st, i, val) SKM_sk_set(OCSP_RESPID, (st), (i), (val)) ++#define sk_OCSP_RESPID_zero(st) SKM_sk_zero(OCSP_RESPID, (st)) ++#define sk_OCSP_RESPID_push(st, val) SKM_sk_push(OCSP_RESPID, (st), (val)) ++#define sk_OCSP_RESPID_unshift(st, val) SKM_sk_unshift(OCSP_RESPID, (st), (val)) ++#define sk_OCSP_RESPID_find(st, val) SKM_sk_find(OCSP_RESPID, (st), (val)) ++#define sk_OCSP_RESPID_find_ex(st, val) SKM_sk_find_ex(OCSP_RESPID, (st), (val)) ++#define sk_OCSP_RESPID_delete(st, i) SKM_sk_delete(OCSP_RESPID, (st), (i)) ++#define sk_OCSP_RESPID_delete_ptr(st, ptr) SKM_sk_delete_ptr(OCSP_RESPID, (st), (ptr)) ++#define sk_OCSP_RESPID_insert(st, val, i) SKM_sk_insert(OCSP_RESPID, (st), (val), (i)) ++#define sk_OCSP_RESPID_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(OCSP_RESPID, (st), (cmp)) ++#define sk_OCSP_RESPID_dup(st) SKM_sk_dup(OCSP_RESPID, st) ++#define sk_OCSP_RESPID_pop_free(st, free_func) SKM_sk_pop_free(OCSP_RESPID, (st), (free_func)) ++#define sk_OCSP_RESPID_shift(st) SKM_sk_shift(OCSP_RESPID, (st)) ++#define sk_OCSP_RESPID_pop(st) SKM_sk_pop(OCSP_RESPID, (st)) ++#define sk_OCSP_RESPID_sort(st) SKM_sk_sort(OCSP_RESPID, (st)) ++#define sk_OCSP_RESPID_is_sorted(st) SKM_sk_is_sorted(OCSP_RESPID, (st)) ++ ++#define sk_OCSP_SINGLERESP_new(cmp) SKM_sk_new(OCSP_SINGLERESP, (cmp)) ++#define sk_OCSP_SINGLERESP_new_null() SKM_sk_new_null(OCSP_SINGLERESP) ++#define sk_OCSP_SINGLERESP_free(st) SKM_sk_free(OCSP_SINGLERESP, (st)) ++#define sk_OCSP_SINGLERESP_num(st) SKM_sk_num(OCSP_SINGLERESP, (st)) ++#define sk_OCSP_SINGLERESP_value(st, i) SKM_sk_value(OCSP_SINGLERESP, (st), (i)) ++#define sk_OCSP_SINGLERESP_set(st, i, val) SKM_sk_set(OCSP_SINGLERESP, (st), (i), (val)) ++#define sk_OCSP_SINGLERESP_zero(st) SKM_sk_zero(OCSP_SINGLERESP, (st)) ++#define sk_OCSP_SINGLERESP_push(st, val) SKM_sk_push(OCSP_SINGLERESP, (st), (val)) ++#define sk_OCSP_SINGLERESP_unshift(st, val) SKM_sk_unshift(OCSP_SINGLERESP, (st), (val)) ++#define sk_OCSP_SINGLERESP_find(st, val) SKM_sk_find(OCSP_SINGLERESP, (st), (val)) ++#define sk_OCSP_SINGLERESP_find_ex(st, val) SKM_sk_find_ex(OCSP_SINGLERESP, (st), (val)) ++#define sk_OCSP_SINGLERESP_delete(st, i) SKM_sk_delete(OCSP_SINGLERESP, (st), (i)) ++#define sk_OCSP_SINGLERESP_delete_ptr(st, ptr) SKM_sk_delete_ptr(OCSP_SINGLERESP, (st), (ptr)) ++#define sk_OCSP_SINGLERESP_insert(st, val, i) SKM_sk_insert(OCSP_SINGLERESP, (st), (val), (i)) ++#define sk_OCSP_SINGLERESP_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(OCSP_SINGLERESP, (st), (cmp)) ++#define sk_OCSP_SINGLERESP_dup(st) SKM_sk_dup(OCSP_SINGLERESP, st) ++#define sk_OCSP_SINGLERESP_pop_free(st, free_func) SKM_sk_pop_free(OCSP_SINGLERESP, (st), (free_func)) ++#define sk_OCSP_SINGLERESP_shift(st) SKM_sk_shift(OCSP_SINGLERESP, (st)) ++#define sk_OCSP_SINGLERESP_pop(st) SKM_sk_pop(OCSP_SINGLERESP, (st)) ++#define sk_OCSP_SINGLERESP_sort(st) SKM_sk_sort(OCSP_SINGLERESP, (st)) ++#define sk_OCSP_SINGLERESP_is_sorted(st) SKM_sk_is_sorted(OCSP_SINGLERESP, (st)) ++ ++#define sk_PKCS12_SAFEBAG_new(cmp) SKM_sk_new(PKCS12_SAFEBAG, (cmp)) ++#define sk_PKCS12_SAFEBAG_new_null() SKM_sk_new_null(PKCS12_SAFEBAG) ++#define sk_PKCS12_SAFEBAG_free(st) SKM_sk_free(PKCS12_SAFEBAG, (st)) ++#define sk_PKCS12_SAFEBAG_num(st) SKM_sk_num(PKCS12_SAFEBAG, (st)) ++#define sk_PKCS12_SAFEBAG_value(st, i) SKM_sk_value(PKCS12_SAFEBAG, (st), (i)) ++#define sk_PKCS12_SAFEBAG_set(st, i, val) SKM_sk_set(PKCS12_SAFEBAG, (st), (i), (val)) ++#define sk_PKCS12_SAFEBAG_zero(st) SKM_sk_zero(PKCS12_SAFEBAG, (st)) ++#define sk_PKCS12_SAFEBAG_push(st, val) SKM_sk_push(PKCS12_SAFEBAG, (st), (val)) ++#define sk_PKCS12_SAFEBAG_unshift(st, val) SKM_sk_unshift(PKCS12_SAFEBAG, (st), (val)) ++#define sk_PKCS12_SAFEBAG_find(st, val) SKM_sk_find(PKCS12_SAFEBAG, (st), (val)) ++#define sk_PKCS12_SAFEBAG_find_ex(st, val) SKM_sk_find_ex(PKCS12_SAFEBAG, (st), (val)) ++#define sk_PKCS12_SAFEBAG_delete(st, i) SKM_sk_delete(PKCS12_SAFEBAG, (st), (i)) ++#define sk_PKCS12_SAFEBAG_delete_ptr(st, ptr) SKM_sk_delete_ptr(PKCS12_SAFEBAG, (st), (ptr)) ++#define sk_PKCS12_SAFEBAG_insert(st, val, i) SKM_sk_insert(PKCS12_SAFEBAG, (st), (val), (i)) ++#define sk_PKCS12_SAFEBAG_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(PKCS12_SAFEBAG, (st), (cmp)) ++#define sk_PKCS12_SAFEBAG_dup(st) SKM_sk_dup(PKCS12_SAFEBAG, st) ++#define sk_PKCS12_SAFEBAG_pop_free(st, free_func) SKM_sk_pop_free(PKCS12_SAFEBAG, (st), (free_func)) ++#define sk_PKCS12_SAFEBAG_shift(st) SKM_sk_shift(PKCS12_SAFEBAG, (st)) ++#define sk_PKCS12_SAFEBAG_pop(st) SKM_sk_pop(PKCS12_SAFEBAG, (st)) ++#define sk_PKCS12_SAFEBAG_sort(st) SKM_sk_sort(PKCS12_SAFEBAG, (st)) ++#define sk_PKCS12_SAFEBAG_is_sorted(st) SKM_sk_is_sorted(PKCS12_SAFEBAG, (st)) ++ ++#define sk_PKCS7_new(cmp) SKM_sk_new(PKCS7, (cmp)) ++#define sk_PKCS7_new_null() SKM_sk_new_null(PKCS7) ++#define sk_PKCS7_free(st) SKM_sk_free(PKCS7, (st)) ++#define sk_PKCS7_num(st) SKM_sk_num(PKCS7, (st)) ++#define sk_PKCS7_value(st, i) SKM_sk_value(PKCS7, (st), (i)) ++#define sk_PKCS7_set(st, i, val) SKM_sk_set(PKCS7, (st), (i), (val)) ++#define sk_PKCS7_zero(st) SKM_sk_zero(PKCS7, (st)) ++#define sk_PKCS7_push(st, val) SKM_sk_push(PKCS7, (st), (val)) ++#define sk_PKCS7_unshift(st, val) SKM_sk_unshift(PKCS7, (st), (val)) ++#define sk_PKCS7_find(st, val) SKM_sk_find(PKCS7, (st), (val)) ++#define sk_PKCS7_find_ex(st, val) SKM_sk_find_ex(PKCS7, (st), (val)) ++#define sk_PKCS7_delete(st, i) SKM_sk_delete(PKCS7, (st), (i)) ++#define sk_PKCS7_delete_ptr(st, ptr) SKM_sk_delete_ptr(PKCS7, (st), (ptr)) ++#define sk_PKCS7_insert(st, val, i) SKM_sk_insert(PKCS7, (st), (val), (i)) ++#define sk_PKCS7_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(PKCS7, (st), (cmp)) ++#define sk_PKCS7_dup(st) SKM_sk_dup(PKCS7, st) ++#define sk_PKCS7_pop_free(st, free_func) SKM_sk_pop_free(PKCS7, (st), (free_func)) ++#define sk_PKCS7_shift(st) SKM_sk_shift(PKCS7, (st)) ++#define sk_PKCS7_pop(st) SKM_sk_pop(PKCS7, (st)) ++#define sk_PKCS7_sort(st) SKM_sk_sort(PKCS7, (st)) ++#define sk_PKCS7_is_sorted(st) SKM_sk_is_sorted(PKCS7, (st)) ++ ++#define sk_PKCS7_RECIP_INFO_new(cmp) SKM_sk_new(PKCS7_RECIP_INFO, (cmp)) ++#define sk_PKCS7_RECIP_INFO_new_null() SKM_sk_new_null(PKCS7_RECIP_INFO) ++#define sk_PKCS7_RECIP_INFO_free(st) SKM_sk_free(PKCS7_RECIP_INFO, (st)) ++#define sk_PKCS7_RECIP_INFO_num(st) SKM_sk_num(PKCS7_RECIP_INFO, (st)) ++#define sk_PKCS7_RECIP_INFO_value(st, i) SKM_sk_value(PKCS7_RECIP_INFO, (st), (i)) ++#define sk_PKCS7_RECIP_INFO_set(st, i, val) SKM_sk_set(PKCS7_RECIP_INFO, (st), (i), (val)) ++#define sk_PKCS7_RECIP_INFO_zero(st) SKM_sk_zero(PKCS7_RECIP_INFO, (st)) ++#define sk_PKCS7_RECIP_INFO_push(st, val) SKM_sk_push(PKCS7_RECIP_INFO, (st), (val)) ++#define sk_PKCS7_RECIP_INFO_unshift(st, val) SKM_sk_unshift(PKCS7_RECIP_INFO, (st), (val)) ++#define sk_PKCS7_RECIP_INFO_find(st, val) SKM_sk_find(PKCS7_RECIP_INFO, (st), (val)) ++#define sk_PKCS7_RECIP_INFO_find_ex(st, val) SKM_sk_find_ex(PKCS7_RECIP_INFO, (st), (val)) ++#define sk_PKCS7_RECIP_INFO_delete(st, i) SKM_sk_delete(PKCS7_RECIP_INFO, (st), (i)) ++#define sk_PKCS7_RECIP_INFO_delete_ptr(st, ptr) SKM_sk_delete_ptr(PKCS7_RECIP_INFO, (st), (ptr)) ++#define sk_PKCS7_RECIP_INFO_insert(st, val, i) SKM_sk_insert(PKCS7_RECIP_INFO, (st), (val), (i)) ++#define sk_PKCS7_RECIP_INFO_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(PKCS7_RECIP_INFO, (st), (cmp)) ++#define sk_PKCS7_RECIP_INFO_dup(st) SKM_sk_dup(PKCS7_RECIP_INFO, st) ++#define sk_PKCS7_RECIP_INFO_pop_free(st, free_func) SKM_sk_pop_free(PKCS7_RECIP_INFO, (st), (free_func)) ++#define sk_PKCS7_RECIP_INFO_shift(st) SKM_sk_shift(PKCS7_RECIP_INFO, (st)) ++#define sk_PKCS7_RECIP_INFO_pop(st) SKM_sk_pop(PKCS7_RECIP_INFO, (st)) ++#define sk_PKCS7_RECIP_INFO_sort(st) SKM_sk_sort(PKCS7_RECIP_INFO, (st)) ++#define sk_PKCS7_RECIP_INFO_is_sorted(st) SKM_sk_is_sorted(PKCS7_RECIP_INFO, (st)) ++ ++#define sk_PKCS7_SIGNER_INFO_new(cmp) SKM_sk_new(PKCS7_SIGNER_INFO, (cmp)) ++#define sk_PKCS7_SIGNER_INFO_new_null() SKM_sk_new_null(PKCS7_SIGNER_INFO) ++#define sk_PKCS7_SIGNER_INFO_free(st) SKM_sk_free(PKCS7_SIGNER_INFO, (st)) ++#define sk_PKCS7_SIGNER_INFO_num(st) SKM_sk_num(PKCS7_SIGNER_INFO, (st)) ++#define sk_PKCS7_SIGNER_INFO_value(st, i) SKM_sk_value(PKCS7_SIGNER_INFO, (st), (i)) ++#define sk_PKCS7_SIGNER_INFO_set(st, i, val) SKM_sk_set(PKCS7_SIGNER_INFO, (st), (i), (val)) ++#define sk_PKCS7_SIGNER_INFO_zero(st) SKM_sk_zero(PKCS7_SIGNER_INFO, (st)) ++#define sk_PKCS7_SIGNER_INFO_push(st, val) SKM_sk_push(PKCS7_SIGNER_INFO, (st), (val)) ++#define sk_PKCS7_SIGNER_INFO_unshift(st, val) SKM_sk_unshift(PKCS7_SIGNER_INFO, (st), (val)) ++#define sk_PKCS7_SIGNER_INFO_find(st, val) SKM_sk_find(PKCS7_SIGNER_INFO, (st), (val)) ++#define sk_PKCS7_SIGNER_INFO_find_ex(st, val) SKM_sk_find_ex(PKCS7_SIGNER_INFO, (st), (val)) ++#define sk_PKCS7_SIGNER_INFO_delete(st, i) SKM_sk_delete(PKCS7_SIGNER_INFO, (st), (i)) ++#define sk_PKCS7_SIGNER_INFO_delete_ptr(st, ptr) SKM_sk_delete_ptr(PKCS7_SIGNER_INFO, (st), (ptr)) ++#define sk_PKCS7_SIGNER_INFO_insert(st, val, i) SKM_sk_insert(PKCS7_SIGNER_INFO, (st), (val), (i)) ++#define sk_PKCS7_SIGNER_INFO_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(PKCS7_SIGNER_INFO, (st), (cmp)) ++#define sk_PKCS7_SIGNER_INFO_dup(st) SKM_sk_dup(PKCS7_SIGNER_INFO, st) ++#define sk_PKCS7_SIGNER_INFO_pop_free(st, free_func) SKM_sk_pop_free(PKCS7_SIGNER_INFO, (st), (free_func)) ++#define sk_PKCS7_SIGNER_INFO_shift(st) SKM_sk_shift(PKCS7_SIGNER_INFO, (st)) ++#define sk_PKCS7_SIGNER_INFO_pop(st) SKM_sk_pop(PKCS7_SIGNER_INFO, (st)) ++#define sk_PKCS7_SIGNER_INFO_sort(st) SKM_sk_sort(PKCS7_SIGNER_INFO, (st)) ++#define sk_PKCS7_SIGNER_INFO_is_sorted(st) SKM_sk_is_sorted(PKCS7_SIGNER_INFO, (st)) ++ ++#define sk_POLICYINFO_new(cmp) SKM_sk_new(POLICYINFO, (cmp)) ++#define sk_POLICYINFO_new_null() SKM_sk_new_null(POLICYINFO) ++#define sk_POLICYINFO_free(st) SKM_sk_free(POLICYINFO, (st)) ++#define sk_POLICYINFO_num(st) SKM_sk_num(POLICYINFO, (st)) ++#define sk_POLICYINFO_value(st, i) SKM_sk_value(POLICYINFO, (st), (i)) ++#define sk_POLICYINFO_set(st, i, val) SKM_sk_set(POLICYINFO, (st), (i), (val)) ++#define sk_POLICYINFO_zero(st) SKM_sk_zero(POLICYINFO, (st)) ++#define sk_POLICYINFO_push(st, val) SKM_sk_push(POLICYINFO, (st), (val)) ++#define sk_POLICYINFO_unshift(st, val) SKM_sk_unshift(POLICYINFO, (st), (val)) ++#define sk_POLICYINFO_find(st, val) SKM_sk_find(POLICYINFO, (st), (val)) ++#define sk_POLICYINFO_find_ex(st, val) SKM_sk_find_ex(POLICYINFO, (st), (val)) ++#define sk_POLICYINFO_delete(st, i) SKM_sk_delete(POLICYINFO, (st), (i)) ++#define sk_POLICYINFO_delete_ptr(st, ptr) SKM_sk_delete_ptr(POLICYINFO, (st), (ptr)) ++#define sk_POLICYINFO_insert(st, val, i) SKM_sk_insert(POLICYINFO, (st), (val), (i)) ++#define sk_POLICYINFO_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(POLICYINFO, (st), (cmp)) ++#define sk_POLICYINFO_dup(st) SKM_sk_dup(POLICYINFO, st) ++#define sk_POLICYINFO_pop_free(st, free_func) SKM_sk_pop_free(POLICYINFO, (st), (free_func)) ++#define sk_POLICYINFO_shift(st) SKM_sk_shift(POLICYINFO, (st)) ++#define sk_POLICYINFO_pop(st) SKM_sk_pop(POLICYINFO, (st)) ++#define sk_POLICYINFO_sort(st) SKM_sk_sort(POLICYINFO, (st)) ++#define sk_POLICYINFO_is_sorted(st) SKM_sk_is_sorted(POLICYINFO, (st)) ++ ++#define sk_POLICYQUALINFO_new(cmp) SKM_sk_new(POLICYQUALINFO, (cmp)) ++#define sk_POLICYQUALINFO_new_null() SKM_sk_new_null(POLICYQUALINFO) ++#define sk_POLICYQUALINFO_free(st) SKM_sk_free(POLICYQUALINFO, (st)) ++#define sk_POLICYQUALINFO_num(st) SKM_sk_num(POLICYQUALINFO, (st)) ++#define sk_POLICYQUALINFO_value(st, i) SKM_sk_value(POLICYQUALINFO, (st), (i)) ++#define sk_POLICYQUALINFO_set(st, i, val) SKM_sk_set(POLICYQUALINFO, (st), (i), (val)) ++#define sk_POLICYQUALINFO_zero(st) SKM_sk_zero(POLICYQUALINFO, (st)) ++#define sk_POLICYQUALINFO_push(st, val) SKM_sk_push(POLICYQUALINFO, (st), (val)) ++#define sk_POLICYQUALINFO_unshift(st, val) SKM_sk_unshift(POLICYQUALINFO, (st), (val)) ++#define sk_POLICYQUALINFO_find(st, val) SKM_sk_find(POLICYQUALINFO, (st), (val)) ++#define sk_POLICYQUALINFO_find_ex(st, val) SKM_sk_find_ex(POLICYQUALINFO, (st), (val)) ++#define sk_POLICYQUALINFO_delete(st, i) SKM_sk_delete(POLICYQUALINFO, (st), (i)) ++#define sk_POLICYQUALINFO_delete_ptr(st, ptr) SKM_sk_delete_ptr(POLICYQUALINFO, (st), (ptr)) ++#define sk_POLICYQUALINFO_insert(st, val, i) SKM_sk_insert(POLICYQUALINFO, (st), (val), (i)) ++#define sk_POLICYQUALINFO_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(POLICYQUALINFO, (st), (cmp)) ++#define sk_POLICYQUALINFO_dup(st) SKM_sk_dup(POLICYQUALINFO, st) ++#define sk_POLICYQUALINFO_pop_free(st, free_func) SKM_sk_pop_free(POLICYQUALINFO, (st), (free_func)) ++#define sk_POLICYQUALINFO_shift(st) SKM_sk_shift(POLICYQUALINFO, (st)) ++#define sk_POLICYQUALINFO_pop(st) SKM_sk_pop(POLICYQUALINFO, (st)) ++#define sk_POLICYQUALINFO_sort(st) SKM_sk_sort(POLICYQUALINFO, (st)) ++#define sk_POLICYQUALINFO_is_sorted(st) SKM_sk_is_sorted(POLICYQUALINFO, (st)) ++ ++#define sk_POLICY_MAPPING_new(cmp) SKM_sk_new(POLICY_MAPPING, (cmp)) ++#define sk_POLICY_MAPPING_new_null() SKM_sk_new_null(POLICY_MAPPING) ++#define sk_POLICY_MAPPING_free(st) SKM_sk_free(POLICY_MAPPING, (st)) ++#define sk_POLICY_MAPPING_num(st) SKM_sk_num(POLICY_MAPPING, (st)) ++#define sk_POLICY_MAPPING_value(st, i) SKM_sk_value(POLICY_MAPPING, (st), (i)) ++#define sk_POLICY_MAPPING_set(st, i, val) SKM_sk_set(POLICY_MAPPING, (st), (i), (val)) ++#define sk_POLICY_MAPPING_zero(st) SKM_sk_zero(POLICY_MAPPING, (st)) ++#define sk_POLICY_MAPPING_push(st, val) SKM_sk_push(POLICY_MAPPING, (st), (val)) ++#define sk_POLICY_MAPPING_unshift(st, val) SKM_sk_unshift(POLICY_MAPPING, (st), (val)) ++#define sk_POLICY_MAPPING_find(st, val) SKM_sk_find(POLICY_MAPPING, (st), (val)) ++#define sk_POLICY_MAPPING_find_ex(st, val) SKM_sk_find_ex(POLICY_MAPPING, (st), (val)) ++#define sk_POLICY_MAPPING_delete(st, i) SKM_sk_delete(POLICY_MAPPING, (st), (i)) ++#define sk_POLICY_MAPPING_delete_ptr(st, ptr) SKM_sk_delete_ptr(POLICY_MAPPING, (st), (ptr)) ++#define sk_POLICY_MAPPING_insert(st, val, i) SKM_sk_insert(POLICY_MAPPING, (st), (val), (i)) ++#define sk_POLICY_MAPPING_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(POLICY_MAPPING, (st), (cmp)) ++#define sk_POLICY_MAPPING_dup(st) SKM_sk_dup(POLICY_MAPPING, st) ++#define sk_POLICY_MAPPING_pop_free(st, free_func) SKM_sk_pop_free(POLICY_MAPPING, (st), (free_func)) ++#define sk_POLICY_MAPPING_shift(st) SKM_sk_shift(POLICY_MAPPING, (st)) ++#define sk_POLICY_MAPPING_pop(st) SKM_sk_pop(POLICY_MAPPING, (st)) ++#define sk_POLICY_MAPPING_sort(st) SKM_sk_sort(POLICY_MAPPING, (st)) ++#define sk_POLICY_MAPPING_is_sorted(st) SKM_sk_is_sorted(POLICY_MAPPING, (st)) ++ ++#define sk_SSL_CIPHER_new(cmp) SKM_sk_new(SSL_CIPHER, (cmp)) ++#define sk_SSL_CIPHER_new_null() SKM_sk_new_null(SSL_CIPHER) ++#define sk_SSL_CIPHER_free(st) SKM_sk_free(SSL_CIPHER, (st)) ++#define sk_SSL_CIPHER_num(st) SKM_sk_num(SSL_CIPHER, (st)) ++#define sk_SSL_CIPHER_value(st, i) SKM_sk_value(SSL_CIPHER, (st), (i)) ++#define sk_SSL_CIPHER_set(st, i, val) SKM_sk_set(SSL_CIPHER, (st), (i), (val)) ++#define sk_SSL_CIPHER_zero(st) SKM_sk_zero(SSL_CIPHER, (st)) ++#define sk_SSL_CIPHER_push(st, val) SKM_sk_push(SSL_CIPHER, (st), (val)) ++#define sk_SSL_CIPHER_unshift(st, val) SKM_sk_unshift(SSL_CIPHER, (st), (val)) ++#define sk_SSL_CIPHER_find(st, val) SKM_sk_find(SSL_CIPHER, (st), (val)) ++#define sk_SSL_CIPHER_find_ex(st, val) SKM_sk_find_ex(SSL_CIPHER, (st), (val)) ++#define sk_SSL_CIPHER_delete(st, i) SKM_sk_delete(SSL_CIPHER, (st), (i)) ++#define sk_SSL_CIPHER_delete_ptr(st, ptr) SKM_sk_delete_ptr(SSL_CIPHER, (st), (ptr)) ++#define sk_SSL_CIPHER_insert(st, val, i) SKM_sk_insert(SSL_CIPHER, (st), (val), (i)) ++#define sk_SSL_CIPHER_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(SSL_CIPHER, (st), (cmp)) ++#define sk_SSL_CIPHER_dup(st) SKM_sk_dup(SSL_CIPHER, st) ++#define sk_SSL_CIPHER_pop_free(st, free_func) SKM_sk_pop_free(SSL_CIPHER, (st), (free_func)) ++#define sk_SSL_CIPHER_shift(st) SKM_sk_shift(SSL_CIPHER, (st)) ++#define sk_SSL_CIPHER_pop(st) SKM_sk_pop(SSL_CIPHER, (st)) ++#define sk_SSL_CIPHER_sort(st) SKM_sk_sort(SSL_CIPHER, (st)) ++#define sk_SSL_CIPHER_is_sorted(st) SKM_sk_is_sorted(SSL_CIPHER, (st)) ++ ++#define sk_SSL_COMP_new(cmp) SKM_sk_new(SSL_COMP, (cmp)) ++#define sk_SSL_COMP_new_null() SKM_sk_new_null(SSL_COMP) ++#define sk_SSL_COMP_free(st) SKM_sk_free(SSL_COMP, (st)) ++#define sk_SSL_COMP_num(st) SKM_sk_num(SSL_COMP, (st)) ++#define sk_SSL_COMP_value(st, i) SKM_sk_value(SSL_COMP, (st), (i)) ++#define sk_SSL_COMP_set(st, i, val) SKM_sk_set(SSL_COMP, (st), (i), (val)) ++#define sk_SSL_COMP_zero(st) SKM_sk_zero(SSL_COMP, (st)) ++#define sk_SSL_COMP_push(st, val) SKM_sk_push(SSL_COMP, (st), (val)) ++#define sk_SSL_COMP_unshift(st, val) SKM_sk_unshift(SSL_COMP, (st), (val)) ++#define sk_SSL_COMP_find(st, val) SKM_sk_find(SSL_COMP, (st), (val)) ++#define sk_SSL_COMP_find_ex(st, val) SKM_sk_find_ex(SSL_COMP, (st), (val)) ++#define sk_SSL_COMP_delete(st, i) SKM_sk_delete(SSL_COMP, (st), (i)) ++#define sk_SSL_COMP_delete_ptr(st, ptr) SKM_sk_delete_ptr(SSL_COMP, (st), (ptr)) ++#define sk_SSL_COMP_insert(st, val, i) SKM_sk_insert(SSL_COMP, (st), (val), (i)) ++#define sk_SSL_COMP_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(SSL_COMP, (st), (cmp)) ++#define sk_SSL_COMP_dup(st) SKM_sk_dup(SSL_COMP, st) ++#define sk_SSL_COMP_pop_free(st, free_func) SKM_sk_pop_free(SSL_COMP, (st), (free_func)) ++#define sk_SSL_COMP_shift(st) SKM_sk_shift(SSL_COMP, (st)) ++#define sk_SSL_COMP_pop(st) SKM_sk_pop(SSL_COMP, (st)) ++#define sk_SSL_COMP_sort(st) SKM_sk_sort(SSL_COMP, (st)) ++#define sk_SSL_COMP_is_sorted(st) SKM_sk_is_sorted(SSL_COMP, (st)) ++ ++#define sk_STACK_OF_X509_NAME_ENTRY_new(cmp) SKM_sk_new(STACK_OF_X509_NAME_ENTRY, (cmp)) ++#define sk_STACK_OF_X509_NAME_ENTRY_new_null() SKM_sk_new_null(STACK_OF_X509_NAME_ENTRY) ++#define sk_STACK_OF_X509_NAME_ENTRY_free(st) SKM_sk_free(STACK_OF_X509_NAME_ENTRY, (st)) ++#define sk_STACK_OF_X509_NAME_ENTRY_num(st) SKM_sk_num(STACK_OF_X509_NAME_ENTRY, (st)) ++#define sk_STACK_OF_X509_NAME_ENTRY_value(st, i) SKM_sk_value(STACK_OF_X509_NAME_ENTRY, (st), (i)) ++#define sk_STACK_OF_X509_NAME_ENTRY_set(st, i, val) SKM_sk_set(STACK_OF_X509_NAME_ENTRY, (st), (i), (val)) ++#define sk_STACK_OF_X509_NAME_ENTRY_zero(st) SKM_sk_zero(STACK_OF_X509_NAME_ENTRY, (st)) ++#define sk_STACK_OF_X509_NAME_ENTRY_push(st, val) SKM_sk_push(STACK_OF_X509_NAME_ENTRY, (st), (val)) ++#define sk_STACK_OF_X509_NAME_ENTRY_unshift(st, val) SKM_sk_unshift(STACK_OF_X509_NAME_ENTRY, (st), (val)) ++#define sk_STACK_OF_X509_NAME_ENTRY_find(st, val) SKM_sk_find(STACK_OF_X509_NAME_ENTRY, (st), (val)) ++#define sk_STACK_OF_X509_NAME_ENTRY_find_ex(st, val) SKM_sk_find_ex(STACK_OF_X509_NAME_ENTRY, (st), (val)) ++#define sk_STACK_OF_X509_NAME_ENTRY_delete(st, i) SKM_sk_delete(STACK_OF_X509_NAME_ENTRY, (st), (i)) ++#define sk_STACK_OF_X509_NAME_ENTRY_delete_ptr(st, ptr) SKM_sk_delete_ptr(STACK_OF_X509_NAME_ENTRY, (st), (ptr)) ++#define sk_STACK_OF_X509_NAME_ENTRY_insert(st, val, i) SKM_sk_insert(STACK_OF_X509_NAME_ENTRY, (st), (val), (i)) ++#define sk_STACK_OF_X509_NAME_ENTRY_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(STACK_OF_X509_NAME_ENTRY, (st), (cmp)) ++#define sk_STACK_OF_X509_NAME_ENTRY_dup(st) SKM_sk_dup(STACK_OF_X509_NAME_ENTRY, st) ++#define sk_STACK_OF_X509_NAME_ENTRY_pop_free(st, free_func) SKM_sk_pop_free(STACK_OF_X509_NAME_ENTRY, (st), (free_func)) ++#define sk_STACK_OF_X509_NAME_ENTRY_shift(st) SKM_sk_shift(STACK_OF_X509_NAME_ENTRY, (st)) ++#define sk_STACK_OF_X509_NAME_ENTRY_pop(st) SKM_sk_pop(STACK_OF_X509_NAME_ENTRY, (st)) ++#define sk_STACK_OF_X509_NAME_ENTRY_sort(st) SKM_sk_sort(STACK_OF_X509_NAME_ENTRY, (st)) ++#define sk_STACK_OF_X509_NAME_ENTRY_is_sorted(st) SKM_sk_is_sorted(STACK_OF_X509_NAME_ENTRY, (st)) ++ ++#define sk_STORE_ATTR_INFO_new(cmp) SKM_sk_new(STORE_ATTR_INFO, (cmp)) ++#define sk_STORE_ATTR_INFO_new_null() SKM_sk_new_null(STORE_ATTR_INFO) ++#define sk_STORE_ATTR_INFO_free(st) SKM_sk_free(STORE_ATTR_INFO, (st)) ++#define sk_STORE_ATTR_INFO_num(st) SKM_sk_num(STORE_ATTR_INFO, (st)) ++#define sk_STORE_ATTR_INFO_value(st, i) SKM_sk_value(STORE_ATTR_INFO, (st), (i)) ++#define sk_STORE_ATTR_INFO_set(st, i, val) SKM_sk_set(STORE_ATTR_INFO, (st), (i), (val)) ++#define sk_STORE_ATTR_INFO_zero(st) SKM_sk_zero(STORE_ATTR_INFO, (st)) ++#define sk_STORE_ATTR_INFO_push(st, val) SKM_sk_push(STORE_ATTR_INFO, (st), (val)) ++#define sk_STORE_ATTR_INFO_unshift(st, val) SKM_sk_unshift(STORE_ATTR_INFO, (st), (val)) ++#define sk_STORE_ATTR_INFO_find(st, val) SKM_sk_find(STORE_ATTR_INFO, (st), (val)) ++#define sk_STORE_ATTR_INFO_find_ex(st, val) SKM_sk_find_ex(STORE_ATTR_INFO, (st), (val)) ++#define sk_STORE_ATTR_INFO_delete(st, i) SKM_sk_delete(STORE_ATTR_INFO, (st), (i)) ++#define sk_STORE_ATTR_INFO_delete_ptr(st, ptr) SKM_sk_delete_ptr(STORE_ATTR_INFO, (st), (ptr)) ++#define sk_STORE_ATTR_INFO_insert(st, val, i) SKM_sk_insert(STORE_ATTR_INFO, (st), (val), (i)) ++#define sk_STORE_ATTR_INFO_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(STORE_ATTR_INFO, (st), (cmp)) ++#define sk_STORE_ATTR_INFO_dup(st) SKM_sk_dup(STORE_ATTR_INFO, st) ++#define sk_STORE_ATTR_INFO_pop_free(st, free_func) SKM_sk_pop_free(STORE_ATTR_INFO, (st), (free_func)) ++#define sk_STORE_ATTR_INFO_shift(st) SKM_sk_shift(STORE_ATTR_INFO, (st)) ++#define sk_STORE_ATTR_INFO_pop(st) SKM_sk_pop(STORE_ATTR_INFO, (st)) ++#define sk_STORE_ATTR_INFO_sort(st) SKM_sk_sort(STORE_ATTR_INFO, (st)) ++#define sk_STORE_ATTR_INFO_is_sorted(st) SKM_sk_is_sorted(STORE_ATTR_INFO, (st)) ++ ++#define sk_STORE_OBJECT_new(cmp) SKM_sk_new(STORE_OBJECT, (cmp)) ++#define sk_STORE_OBJECT_new_null() SKM_sk_new_null(STORE_OBJECT) ++#define sk_STORE_OBJECT_free(st) SKM_sk_free(STORE_OBJECT, (st)) ++#define sk_STORE_OBJECT_num(st) SKM_sk_num(STORE_OBJECT, (st)) ++#define sk_STORE_OBJECT_value(st, i) SKM_sk_value(STORE_OBJECT, (st), (i)) ++#define sk_STORE_OBJECT_set(st, i, val) SKM_sk_set(STORE_OBJECT, (st), (i), (val)) ++#define sk_STORE_OBJECT_zero(st) SKM_sk_zero(STORE_OBJECT, (st)) ++#define sk_STORE_OBJECT_push(st, val) SKM_sk_push(STORE_OBJECT, (st), (val)) ++#define sk_STORE_OBJECT_unshift(st, val) SKM_sk_unshift(STORE_OBJECT, (st), (val)) ++#define sk_STORE_OBJECT_find(st, val) SKM_sk_find(STORE_OBJECT, (st), (val)) ++#define sk_STORE_OBJECT_find_ex(st, val) SKM_sk_find_ex(STORE_OBJECT, (st), (val)) ++#define sk_STORE_OBJECT_delete(st, i) SKM_sk_delete(STORE_OBJECT, (st), (i)) ++#define sk_STORE_OBJECT_delete_ptr(st, ptr) SKM_sk_delete_ptr(STORE_OBJECT, (st), (ptr)) ++#define sk_STORE_OBJECT_insert(st, val, i) SKM_sk_insert(STORE_OBJECT, (st), (val), (i)) ++#define sk_STORE_OBJECT_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(STORE_OBJECT, (st), (cmp)) ++#define sk_STORE_OBJECT_dup(st) SKM_sk_dup(STORE_OBJECT, st) ++#define sk_STORE_OBJECT_pop_free(st, free_func) SKM_sk_pop_free(STORE_OBJECT, (st), (free_func)) ++#define sk_STORE_OBJECT_shift(st) SKM_sk_shift(STORE_OBJECT, (st)) ++#define sk_STORE_OBJECT_pop(st) SKM_sk_pop(STORE_OBJECT, (st)) ++#define sk_STORE_OBJECT_sort(st) SKM_sk_sort(STORE_OBJECT, (st)) ++#define sk_STORE_OBJECT_is_sorted(st) SKM_sk_is_sorted(STORE_OBJECT, (st)) ++ ++#define sk_SXNETID_new(cmp) SKM_sk_new(SXNETID, (cmp)) ++#define sk_SXNETID_new_null() SKM_sk_new_null(SXNETID) ++#define sk_SXNETID_free(st) SKM_sk_free(SXNETID, (st)) ++#define sk_SXNETID_num(st) SKM_sk_num(SXNETID, (st)) ++#define sk_SXNETID_value(st, i) SKM_sk_value(SXNETID, (st), (i)) ++#define sk_SXNETID_set(st, i, val) SKM_sk_set(SXNETID, (st), (i), (val)) ++#define sk_SXNETID_zero(st) SKM_sk_zero(SXNETID, (st)) ++#define sk_SXNETID_push(st, val) SKM_sk_push(SXNETID, (st), (val)) ++#define sk_SXNETID_unshift(st, val) SKM_sk_unshift(SXNETID, (st), (val)) ++#define sk_SXNETID_find(st, val) SKM_sk_find(SXNETID, (st), (val)) ++#define sk_SXNETID_find_ex(st, val) SKM_sk_find_ex(SXNETID, (st), (val)) ++#define sk_SXNETID_delete(st, i) SKM_sk_delete(SXNETID, (st), (i)) ++#define sk_SXNETID_delete_ptr(st, ptr) SKM_sk_delete_ptr(SXNETID, (st), (ptr)) ++#define sk_SXNETID_insert(st, val, i) SKM_sk_insert(SXNETID, (st), (val), (i)) ++#define sk_SXNETID_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(SXNETID, (st), (cmp)) ++#define sk_SXNETID_dup(st) SKM_sk_dup(SXNETID, st) ++#define sk_SXNETID_pop_free(st, free_func) SKM_sk_pop_free(SXNETID, (st), (free_func)) ++#define sk_SXNETID_shift(st) SKM_sk_shift(SXNETID, (st)) ++#define sk_SXNETID_pop(st) SKM_sk_pop(SXNETID, (st)) ++#define sk_SXNETID_sort(st) SKM_sk_sort(SXNETID, (st)) ++#define sk_SXNETID_is_sorted(st) SKM_sk_is_sorted(SXNETID, (st)) ++ ++#define sk_UI_STRING_new(cmp) SKM_sk_new(UI_STRING, (cmp)) ++#define sk_UI_STRING_new_null() SKM_sk_new_null(UI_STRING) ++#define sk_UI_STRING_free(st) SKM_sk_free(UI_STRING, (st)) ++#define sk_UI_STRING_num(st) SKM_sk_num(UI_STRING, (st)) ++#define sk_UI_STRING_value(st, i) SKM_sk_value(UI_STRING, (st), (i)) ++#define sk_UI_STRING_set(st, i, val) SKM_sk_set(UI_STRING, (st), (i), (val)) ++#define sk_UI_STRING_zero(st) SKM_sk_zero(UI_STRING, (st)) ++#define sk_UI_STRING_push(st, val) SKM_sk_push(UI_STRING, (st), (val)) ++#define sk_UI_STRING_unshift(st, val) SKM_sk_unshift(UI_STRING, (st), (val)) ++#define sk_UI_STRING_find(st, val) SKM_sk_find(UI_STRING, (st), (val)) ++#define sk_UI_STRING_find_ex(st, val) SKM_sk_find_ex(UI_STRING, (st), (val)) ++#define sk_UI_STRING_delete(st, i) SKM_sk_delete(UI_STRING, (st), (i)) ++#define sk_UI_STRING_delete_ptr(st, ptr) SKM_sk_delete_ptr(UI_STRING, (st), (ptr)) ++#define sk_UI_STRING_insert(st, val, i) SKM_sk_insert(UI_STRING, (st), (val), (i)) ++#define sk_UI_STRING_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(UI_STRING, (st), (cmp)) ++#define sk_UI_STRING_dup(st) SKM_sk_dup(UI_STRING, st) ++#define sk_UI_STRING_pop_free(st, free_func) SKM_sk_pop_free(UI_STRING, (st), (free_func)) ++#define sk_UI_STRING_shift(st) SKM_sk_shift(UI_STRING, (st)) ++#define sk_UI_STRING_pop(st) SKM_sk_pop(UI_STRING, (st)) ++#define sk_UI_STRING_sort(st) SKM_sk_sort(UI_STRING, (st)) ++#define sk_UI_STRING_is_sorted(st) SKM_sk_is_sorted(UI_STRING, (st)) ++ ++#define sk_X509_new(cmp) SKM_sk_new(X509, (cmp)) ++#define sk_X509_new_null() SKM_sk_new_null(X509) ++#define sk_X509_free(st) SKM_sk_free(X509, (st)) ++#define sk_X509_num(st) SKM_sk_num(X509, (st)) ++#define sk_X509_value(st, i) SKM_sk_value(X509, (st), (i)) ++#define sk_X509_set(st, i, val) SKM_sk_set(X509, (st), (i), (val)) ++#define sk_X509_zero(st) SKM_sk_zero(X509, (st)) ++#define sk_X509_push(st, val) SKM_sk_push(X509, (st), (val)) ++#define sk_X509_unshift(st, val) SKM_sk_unshift(X509, (st), (val)) ++#define sk_X509_find(st, val) SKM_sk_find(X509, (st), (val)) ++#define sk_X509_find_ex(st, val) SKM_sk_find_ex(X509, (st), (val)) ++#define sk_X509_delete(st, i) SKM_sk_delete(X509, (st), (i)) ++#define sk_X509_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509, (st), (ptr)) ++#define sk_X509_insert(st, val, i) SKM_sk_insert(X509, (st), (val), (i)) ++#define sk_X509_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509, (st), (cmp)) ++#define sk_X509_dup(st) SKM_sk_dup(X509, st) ++#define sk_X509_pop_free(st, free_func) SKM_sk_pop_free(X509, (st), (free_func)) ++#define sk_X509_shift(st) SKM_sk_shift(X509, (st)) ++#define sk_X509_pop(st) SKM_sk_pop(X509, (st)) ++#define sk_X509_sort(st) SKM_sk_sort(X509, (st)) ++#define sk_X509_is_sorted(st) SKM_sk_is_sorted(X509, (st)) ++ ++#define sk_X509V3_EXT_METHOD_new(cmp) SKM_sk_new(X509V3_EXT_METHOD, (cmp)) ++#define sk_X509V3_EXT_METHOD_new_null() SKM_sk_new_null(X509V3_EXT_METHOD) ++#define sk_X509V3_EXT_METHOD_free(st) SKM_sk_free(X509V3_EXT_METHOD, (st)) ++#define sk_X509V3_EXT_METHOD_num(st) SKM_sk_num(X509V3_EXT_METHOD, (st)) ++#define sk_X509V3_EXT_METHOD_value(st, i) SKM_sk_value(X509V3_EXT_METHOD, (st), (i)) ++#define sk_X509V3_EXT_METHOD_set(st, i, val) SKM_sk_set(X509V3_EXT_METHOD, (st), (i), (val)) ++#define sk_X509V3_EXT_METHOD_zero(st) SKM_sk_zero(X509V3_EXT_METHOD, (st)) ++#define sk_X509V3_EXT_METHOD_push(st, val) SKM_sk_push(X509V3_EXT_METHOD, (st), (val)) ++#define sk_X509V3_EXT_METHOD_unshift(st, val) SKM_sk_unshift(X509V3_EXT_METHOD, (st), (val)) ++#define sk_X509V3_EXT_METHOD_find(st, val) SKM_sk_find(X509V3_EXT_METHOD, (st), (val)) ++#define sk_X509V3_EXT_METHOD_find_ex(st, val) SKM_sk_find_ex(X509V3_EXT_METHOD, (st), (val)) ++#define sk_X509V3_EXT_METHOD_delete(st, i) SKM_sk_delete(X509V3_EXT_METHOD, (st), (i)) ++#define sk_X509V3_EXT_METHOD_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509V3_EXT_METHOD, (st), (ptr)) ++#define sk_X509V3_EXT_METHOD_insert(st, val, i) SKM_sk_insert(X509V3_EXT_METHOD, (st), (val), (i)) ++#define sk_X509V3_EXT_METHOD_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509V3_EXT_METHOD, (st), (cmp)) ++#define sk_X509V3_EXT_METHOD_dup(st) SKM_sk_dup(X509V3_EXT_METHOD, st) ++#define sk_X509V3_EXT_METHOD_pop_free(st, free_func) SKM_sk_pop_free(X509V3_EXT_METHOD, (st), (free_func)) ++#define sk_X509V3_EXT_METHOD_shift(st) SKM_sk_shift(X509V3_EXT_METHOD, (st)) ++#define sk_X509V3_EXT_METHOD_pop(st) SKM_sk_pop(X509V3_EXT_METHOD, (st)) ++#define sk_X509V3_EXT_METHOD_sort(st) SKM_sk_sort(X509V3_EXT_METHOD, (st)) ++#define sk_X509V3_EXT_METHOD_is_sorted(st) SKM_sk_is_sorted(X509V3_EXT_METHOD, (st)) ++ ++#define sk_X509_ALGOR_new(cmp) SKM_sk_new(X509_ALGOR, (cmp)) ++#define sk_X509_ALGOR_new_null() SKM_sk_new_null(X509_ALGOR) ++#define sk_X509_ALGOR_free(st) SKM_sk_free(X509_ALGOR, (st)) ++#define sk_X509_ALGOR_num(st) SKM_sk_num(X509_ALGOR, (st)) ++#define sk_X509_ALGOR_value(st, i) SKM_sk_value(X509_ALGOR, (st), (i)) ++#define sk_X509_ALGOR_set(st, i, val) SKM_sk_set(X509_ALGOR, (st), (i), (val)) ++#define sk_X509_ALGOR_zero(st) SKM_sk_zero(X509_ALGOR, (st)) ++#define sk_X509_ALGOR_push(st, val) SKM_sk_push(X509_ALGOR, (st), (val)) ++#define sk_X509_ALGOR_unshift(st, val) SKM_sk_unshift(X509_ALGOR, (st), (val)) ++#define sk_X509_ALGOR_find(st, val) SKM_sk_find(X509_ALGOR, (st), (val)) ++#define sk_X509_ALGOR_find_ex(st, val) SKM_sk_find_ex(X509_ALGOR, (st), (val)) ++#define sk_X509_ALGOR_delete(st, i) SKM_sk_delete(X509_ALGOR, (st), (i)) ++#define sk_X509_ALGOR_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_ALGOR, (st), (ptr)) ++#define sk_X509_ALGOR_insert(st, val, i) SKM_sk_insert(X509_ALGOR, (st), (val), (i)) ++#define sk_X509_ALGOR_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_ALGOR, (st), (cmp)) ++#define sk_X509_ALGOR_dup(st) SKM_sk_dup(X509_ALGOR, st) ++#define sk_X509_ALGOR_pop_free(st, free_func) SKM_sk_pop_free(X509_ALGOR, (st), (free_func)) ++#define sk_X509_ALGOR_shift(st) SKM_sk_shift(X509_ALGOR, (st)) ++#define sk_X509_ALGOR_pop(st) SKM_sk_pop(X509_ALGOR, (st)) ++#define sk_X509_ALGOR_sort(st) SKM_sk_sort(X509_ALGOR, (st)) ++#define sk_X509_ALGOR_is_sorted(st) SKM_sk_is_sorted(X509_ALGOR, (st)) ++ ++#define sk_X509_ATTRIBUTE_new(cmp) SKM_sk_new(X509_ATTRIBUTE, (cmp)) ++#define sk_X509_ATTRIBUTE_new_null() SKM_sk_new_null(X509_ATTRIBUTE) ++#define sk_X509_ATTRIBUTE_free(st) SKM_sk_free(X509_ATTRIBUTE, (st)) ++#define sk_X509_ATTRIBUTE_num(st) SKM_sk_num(X509_ATTRIBUTE, (st)) ++#define sk_X509_ATTRIBUTE_value(st, i) SKM_sk_value(X509_ATTRIBUTE, (st), (i)) ++#define sk_X509_ATTRIBUTE_set(st, i, val) SKM_sk_set(X509_ATTRIBUTE, (st), (i), (val)) ++#define sk_X509_ATTRIBUTE_zero(st) SKM_sk_zero(X509_ATTRIBUTE, (st)) ++#define sk_X509_ATTRIBUTE_push(st, val) SKM_sk_push(X509_ATTRIBUTE, (st), (val)) ++#define sk_X509_ATTRIBUTE_unshift(st, val) SKM_sk_unshift(X509_ATTRIBUTE, (st), (val)) ++#define sk_X509_ATTRIBUTE_find(st, val) SKM_sk_find(X509_ATTRIBUTE, (st), (val)) ++#define sk_X509_ATTRIBUTE_find_ex(st, val) SKM_sk_find_ex(X509_ATTRIBUTE, (st), (val)) ++#define sk_X509_ATTRIBUTE_delete(st, i) SKM_sk_delete(X509_ATTRIBUTE, (st), (i)) ++#define sk_X509_ATTRIBUTE_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_ATTRIBUTE, (st), (ptr)) ++#define sk_X509_ATTRIBUTE_insert(st, val, i) SKM_sk_insert(X509_ATTRIBUTE, (st), (val), (i)) ++#define sk_X509_ATTRIBUTE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_ATTRIBUTE, (st), (cmp)) ++#define sk_X509_ATTRIBUTE_dup(st) SKM_sk_dup(X509_ATTRIBUTE, st) ++#define sk_X509_ATTRIBUTE_pop_free(st, free_func) SKM_sk_pop_free(X509_ATTRIBUTE, (st), (free_func)) ++#define sk_X509_ATTRIBUTE_shift(st) SKM_sk_shift(X509_ATTRIBUTE, (st)) ++#define sk_X509_ATTRIBUTE_pop(st) SKM_sk_pop(X509_ATTRIBUTE, (st)) ++#define sk_X509_ATTRIBUTE_sort(st) SKM_sk_sort(X509_ATTRIBUTE, (st)) ++#define sk_X509_ATTRIBUTE_is_sorted(st) SKM_sk_is_sorted(X509_ATTRIBUTE, (st)) ++ ++#define sk_X509_CRL_new(cmp) SKM_sk_new(X509_CRL, (cmp)) ++#define sk_X509_CRL_new_null() SKM_sk_new_null(X509_CRL) ++#define sk_X509_CRL_free(st) SKM_sk_free(X509_CRL, (st)) ++#define sk_X509_CRL_num(st) SKM_sk_num(X509_CRL, (st)) ++#define sk_X509_CRL_value(st, i) SKM_sk_value(X509_CRL, (st), (i)) ++#define sk_X509_CRL_set(st, i, val) SKM_sk_set(X509_CRL, (st), (i), (val)) ++#define sk_X509_CRL_zero(st) SKM_sk_zero(X509_CRL, (st)) ++#define sk_X509_CRL_push(st, val) SKM_sk_push(X509_CRL, (st), (val)) ++#define sk_X509_CRL_unshift(st, val) SKM_sk_unshift(X509_CRL, (st), (val)) ++#define sk_X509_CRL_find(st, val) SKM_sk_find(X509_CRL, (st), (val)) ++#define sk_X509_CRL_find_ex(st, val) SKM_sk_find_ex(X509_CRL, (st), (val)) ++#define sk_X509_CRL_delete(st, i) SKM_sk_delete(X509_CRL, (st), (i)) ++#define sk_X509_CRL_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_CRL, (st), (ptr)) ++#define sk_X509_CRL_insert(st, val, i) SKM_sk_insert(X509_CRL, (st), (val), (i)) ++#define sk_X509_CRL_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_CRL, (st), (cmp)) ++#define sk_X509_CRL_dup(st) SKM_sk_dup(X509_CRL, st) ++#define sk_X509_CRL_pop_free(st, free_func) SKM_sk_pop_free(X509_CRL, (st), (free_func)) ++#define sk_X509_CRL_shift(st) SKM_sk_shift(X509_CRL, (st)) ++#define sk_X509_CRL_pop(st) SKM_sk_pop(X509_CRL, (st)) ++#define sk_X509_CRL_sort(st) SKM_sk_sort(X509_CRL, (st)) ++#define sk_X509_CRL_is_sorted(st) SKM_sk_is_sorted(X509_CRL, (st)) ++ ++#define sk_X509_EXTENSION_new(cmp) SKM_sk_new(X509_EXTENSION, (cmp)) ++#define sk_X509_EXTENSION_new_null() SKM_sk_new_null(X509_EXTENSION) ++#define sk_X509_EXTENSION_free(st) SKM_sk_free(X509_EXTENSION, (st)) ++#define sk_X509_EXTENSION_num(st) SKM_sk_num(X509_EXTENSION, (st)) ++#define sk_X509_EXTENSION_value(st, i) SKM_sk_value(X509_EXTENSION, (st), (i)) ++#define sk_X509_EXTENSION_set(st, i, val) SKM_sk_set(X509_EXTENSION, (st), (i), (val)) ++#define sk_X509_EXTENSION_zero(st) SKM_sk_zero(X509_EXTENSION, (st)) ++#define sk_X509_EXTENSION_push(st, val) SKM_sk_push(X509_EXTENSION, (st), (val)) ++#define sk_X509_EXTENSION_unshift(st, val) SKM_sk_unshift(X509_EXTENSION, (st), (val)) ++#define sk_X509_EXTENSION_find(st, val) SKM_sk_find(X509_EXTENSION, (st), (val)) ++#define sk_X509_EXTENSION_find_ex(st, val) SKM_sk_find_ex(X509_EXTENSION, (st), (val)) ++#define sk_X509_EXTENSION_delete(st, i) SKM_sk_delete(X509_EXTENSION, (st), (i)) ++#define sk_X509_EXTENSION_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_EXTENSION, (st), (ptr)) ++#define sk_X509_EXTENSION_insert(st, val, i) SKM_sk_insert(X509_EXTENSION, (st), (val), (i)) ++#define sk_X509_EXTENSION_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_EXTENSION, (st), (cmp)) ++#define sk_X509_EXTENSION_dup(st) SKM_sk_dup(X509_EXTENSION, st) ++#define sk_X509_EXTENSION_pop_free(st, free_func) SKM_sk_pop_free(X509_EXTENSION, (st), (free_func)) ++#define sk_X509_EXTENSION_shift(st) SKM_sk_shift(X509_EXTENSION, (st)) ++#define sk_X509_EXTENSION_pop(st) SKM_sk_pop(X509_EXTENSION, (st)) ++#define sk_X509_EXTENSION_sort(st) SKM_sk_sort(X509_EXTENSION, (st)) ++#define sk_X509_EXTENSION_is_sorted(st) SKM_sk_is_sorted(X509_EXTENSION, (st)) ++ ++#define sk_X509_INFO_new(cmp) SKM_sk_new(X509_INFO, (cmp)) ++#define sk_X509_INFO_new_null() SKM_sk_new_null(X509_INFO) ++#define sk_X509_INFO_free(st) SKM_sk_free(X509_INFO, (st)) ++#define sk_X509_INFO_num(st) SKM_sk_num(X509_INFO, (st)) ++#define sk_X509_INFO_value(st, i) SKM_sk_value(X509_INFO, (st), (i)) ++#define sk_X509_INFO_set(st, i, val) SKM_sk_set(X509_INFO, (st), (i), (val)) ++#define sk_X509_INFO_zero(st) SKM_sk_zero(X509_INFO, (st)) ++#define sk_X509_INFO_push(st, val) SKM_sk_push(X509_INFO, (st), (val)) ++#define sk_X509_INFO_unshift(st, val) SKM_sk_unshift(X509_INFO, (st), (val)) ++#define sk_X509_INFO_find(st, val) SKM_sk_find(X509_INFO, (st), (val)) ++#define sk_X509_INFO_find_ex(st, val) SKM_sk_find_ex(X509_INFO, (st), (val)) ++#define sk_X509_INFO_delete(st, i) SKM_sk_delete(X509_INFO, (st), (i)) ++#define sk_X509_INFO_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_INFO, (st), (ptr)) ++#define sk_X509_INFO_insert(st, val, i) SKM_sk_insert(X509_INFO, (st), (val), (i)) ++#define sk_X509_INFO_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_INFO, (st), (cmp)) ++#define sk_X509_INFO_dup(st) SKM_sk_dup(X509_INFO, st) ++#define sk_X509_INFO_pop_free(st, free_func) SKM_sk_pop_free(X509_INFO, (st), (free_func)) ++#define sk_X509_INFO_shift(st) SKM_sk_shift(X509_INFO, (st)) ++#define sk_X509_INFO_pop(st) SKM_sk_pop(X509_INFO, (st)) ++#define sk_X509_INFO_sort(st) SKM_sk_sort(X509_INFO, (st)) ++#define sk_X509_INFO_is_sorted(st) SKM_sk_is_sorted(X509_INFO, (st)) ++ ++#define sk_X509_LOOKUP_new(cmp) SKM_sk_new(X509_LOOKUP, (cmp)) ++#define sk_X509_LOOKUP_new_null() SKM_sk_new_null(X509_LOOKUP) ++#define sk_X509_LOOKUP_free(st) SKM_sk_free(X509_LOOKUP, (st)) ++#define sk_X509_LOOKUP_num(st) SKM_sk_num(X509_LOOKUP, (st)) ++#define sk_X509_LOOKUP_value(st, i) SKM_sk_value(X509_LOOKUP, (st), (i)) ++#define sk_X509_LOOKUP_set(st, i, val) SKM_sk_set(X509_LOOKUP, (st), (i), (val)) ++#define sk_X509_LOOKUP_zero(st) SKM_sk_zero(X509_LOOKUP, (st)) ++#define sk_X509_LOOKUP_push(st, val) SKM_sk_push(X509_LOOKUP, (st), (val)) ++#define sk_X509_LOOKUP_unshift(st, val) SKM_sk_unshift(X509_LOOKUP, (st), (val)) ++#define sk_X509_LOOKUP_find(st, val) SKM_sk_find(X509_LOOKUP, (st), (val)) ++#define sk_X509_LOOKUP_find_ex(st, val) SKM_sk_find_ex(X509_LOOKUP, (st), (val)) ++#define sk_X509_LOOKUP_delete(st, i) SKM_sk_delete(X509_LOOKUP, (st), (i)) ++#define sk_X509_LOOKUP_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_LOOKUP, (st), (ptr)) ++#define sk_X509_LOOKUP_insert(st, val, i) SKM_sk_insert(X509_LOOKUP, (st), (val), (i)) ++#define sk_X509_LOOKUP_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_LOOKUP, (st), (cmp)) ++#define sk_X509_LOOKUP_dup(st) SKM_sk_dup(X509_LOOKUP, st) ++#define sk_X509_LOOKUP_pop_free(st, free_func) SKM_sk_pop_free(X509_LOOKUP, (st), (free_func)) ++#define sk_X509_LOOKUP_shift(st) SKM_sk_shift(X509_LOOKUP, (st)) ++#define sk_X509_LOOKUP_pop(st) SKM_sk_pop(X509_LOOKUP, (st)) ++#define sk_X509_LOOKUP_sort(st) SKM_sk_sort(X509_LOOKUP, (st)) ++#define sk_X509_LOOKUP_is_sorted(st) SKM_sk_is_sorted(X509_LOOKUP, (st)) ++ ++#define sk_X509_NAME_new(cmp) SKM_sk_new(X509_NAME, (cmp)) ++#define sk_X509_NAME_new_null() SKM_sk_new_null(X509_NAME) ++#define sk_X509_NAME_free(st) SKM_sk_free(X509_NAME, (st)) ++#define sk_X509_NAME_num(st) SKM_sk_num(X509_NAME, (st)) ++#define sk_X509_NAME_value(st, i) SKM_sk_value(X509_NAME, (st), (i)) ++#define sk_X509_NAME_set(st, i, val) SKM_sk_set(X509_NAME, (st), (i), (val)) ++#define sk_X509_NAME_zero(st) SKM_sk_zero(X509_NAME, (st)) ++#define sk_X509_NAME_push(st, val) SKM_sk_push(X509_NAME, (st), (val)) ++#define sk_X509_NAME_unshift(st, val) SKM_sk_unshift(X509_NAME, (st), (val)) ++#define sk_X509_NAME_find(st, val) SKM_sk_find(X509_NAME, (st), (val)) ++#define sk_X509_NAME_find_ex(st, val) SKM_sk_find_ex(X509_NAME, (st), (val)) ++#define sk_X509_NAME_delete(st, i) SKM_sk_delete(X509_NAME, (st), (i)) ++#define sk_X509_NAME_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_NAME, (st), (ptr)) ++#define sk_X509_NAME_insert(st, val, i) SKM_sk_insert(X509_NAME, (st), (val), (i)) ++#define sk_X509_NAME_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_NAME, (st), (cmp)) ++#define sk_X509_NAME_dup(st) SKM_sk_dup(X509_NAME, st) ++#define sk_X509_NAME_pop_free(st, free_func) SKM_sk_pop_free(X509_NAME, (st), (free_func)) ++#define sk_X509_NAME_shift(st) SKM_sk_shift(X509_NAME, (st)) ++#define sk_X509_NAME_pop(st) SKM_sk_pop(X509_NAME, (st)) ++#define sk_X509_NAME_sort(st) SKM_sk_sort(X509_NAME, (st)) ++#define sk_X509_NAME_is_sorted(st) SKM_sk_is_sorted(X509_NAME, (st)) ++ ++#define sk_X509_NAME_ENTRY_new(cmp) SKM_sk_new(X509_NAME_ENTRY, (cmp)) ++#define sk_X509_NAME_ENTRY_new_null() SKM_sk_new_null(X509_NAME_ENTRY) ++#define sk_X509_NAME_ENTRY_free(st) SKM_sk_free(X509_NAME_ENTRY, (st)) ++#define sk_X509_NAME_ENTRY_num(st) SKM_sk_num(X509_NAME_ENTRY, (st)) ++#define sk_X509_NAME_ENTRY_value(st, i) SKM_sk_value(X509_NAME_ENTRY, (st), (i)) ++#define sk_X509_NAME_ENTRY_set(st, i, val) SKM_sk_set(X509_NAME_ENTRY, (st), (i), (val)) ++#define sk_X509_NAME_ENTRY_zero(st) SKM_sk_zero(X509_NAME_ENTRY, (st)) ++#define sk_X509_NAME_ENTRY_push(st, val) SKM_sk_push(X509_NAME_ENTRY, (st), (val)) ++#define sk_X509_NAME_ENTRY_unshift(st, val) SKM_sk_unshift(X509_NAME_ENTRY, (st), (val)) ++#define sk_X509_NAME_ENTRY_find(st, val) SKM_sk_find(X509_NAME_ENTRY, (st), (val)) ++#define sk_X509_NAME_ENTRY_find_ex(st, val) SKM_sk_find_ex(X509_NAME_ENTRY, (st), (val)) ++#define sk_X509_NAME_ENTRY_delete(st, i) SKM_sk_delete(X509_NAME_ENTRY, (st), (i)) ++#define sk_X509_NAME_ENTRY_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_NAME_ENTRY, (st), (ptr)) ++#define sk_X509_NAME_ENTRY_insert(st, val, i) SKM_sk_insert(X509_NAME_ENTRY, (st), (val), (i)) ++#define sk_X509_NAME_ENTRY_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_NAME_ENTRY, (st), (cmp)) ++#define sk_X509_NAME_ENTRY_dup(st) SKM_sk_dup(X509_NAME_ENTRY, st) ++#define sk_X509_NAME_ENTRY_pop_free(st, free_func) SKM_sk_pop_free(X509_NAME_ENTRY, (st), (free_func)) ++#define sk_X509_NAME_ENTRY_shift(st) SKM_sk_shift(X509_NAME_ENTRY, (st)) ++#define sk_X509_NAME_ENTRY_pop(st) SKM_sk_pop(X509_NAME_ENTRY, (st)) ++#define sk_X509_NAME_ENTRY_sort(st) SKM_sk_sort(X509_NAME_ENTRY, (st)) ++#define sk_X509_NAME_ENTRY_is_sorted(st) SKM_sk_is_sorted(X509_NAME_ENTRY, (st)) ++ ++#define sk_X509_OBJECT_new(cmp) SKM_sk_new(X509_OBJECT, (cmp)) ++#define sk_X509_OBJECT_new_null() SKM_sk_new_null(X509_OBJECT) ++#define sk_X509_OBJECT_free(st) SKM_sk_free(X509_OBJECT, (st)) ++#define sk_X509_OBJECT_num(st) SKM_sk_num(X509_OBJECT, (st)) ++#define sk_X509_OBJECT_value(st, i) SKM_sk_value(X509_OBJECT, (st), (i)) ++#define sk_X509_OBJECT_set(st, i, val) SKM_sk_set(X509_OBJECT, (st), (i), (val)) ++#define sk_X509_OBJECT_zero(st) SKM_sk_zero(X509_OBJECT, (st)) ++#define sk_X509_OBJECT_push(st, val) SKM_sk_push(X509_OBJECT, (st), (val)) ++#define sk_X509_OBJECT_unshift(st, val) SKM_sk_unshift(X509_OBJECT, (st), (val)) ++#define sk_X509_OBJECT_find(st, val) SKM_sk_find(X509_OBJECT, (st), (val)) ++#define sk_X509_OBJECT_find_ex(st, val) SKM_sk_find_ex(X509_OBJECT, (st), (val)) ++#define sk_X509_OBJECT_delete(st, i) SKM_sk_delete(X509_OBJECT, (st), (i)) ++#define sk_X509_OBJECT_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_OBJECT, (st), (ptr)) ++#define sk_X509_OBJECT_insert(st, val, i) SKM_sk_insert(X509_OBJECT, (st), (val), (i)) ++#define sk_X509_OBJECT_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_OBJECT, (st), (cmp)) ++#define sk_X509_OBJECT_dup(st) SKM_sk_dup(X509_OBJECT, st) ++#define sk_X509_OBJECT_pop_free(st, free_func) SKM_sk_pop_free(X509_OBJECT, (st), (free_func)) ++#define sk_X509_OBJECT_shift(st) SKM_sk_shift(X509_OBJECT, (st)) ++#define sk_X509_OBJECT_pop(st) SKM_sk_pop(X509_OBJECT, (st)) ++#define sk_X509_OBJECT_sort(st) SKM_sk_sort(X509_OBJECT, (st)) ++#define sk_X509_OBJECT_is_sorted(st) SKM_sk_is_sorted(X509_OBJECT, (st)) ++ ++#define sk_X509_POLICY_DATA_new(cmp) SKM_sk_new(X509_POLICY_DATA, (cmp)) ++#define sk_X509_POLICY_DATA_new_null() SKM_sk_new_null(X509_POLICY_DATA) ++#define sk_X509_POLICY_DATA_free(st) SKM_sk_free(X509_POLICY_DATA, (st)) ++#define sk_X509_POLICY_DATA_num(st) SKM_sk_num(X509_POLICY_DATA, (st)) ++#define sk_X509_POLICY_DATA_value(st, i) SKM_sk_value(X509_POLICY_DATA, (st), (i)) ++#define sk_X509_POLICY_DATA_set(st, i, val) SKM_sk_set(X509_POLICY_DATA, (st), (i), (val)) ++#define sk_X509_POLICY_DATA_zero(st) SKM_sk_zero(X509_POLICY_DATA, (st)) ++#define sk_X509_POLICY_DATA_push(st, val) SKM_sk_push(X509_POLICY_DATA, (st), (val)) ++#define sk_X509_POLICY_DATA_unshift(st, val) SKM_sk_unshift(X509_POLICY_DATA, (st), (val)) ++#define sk_X509_POLICY_DATA_find(st, val) SKM_sk_find(X509_POLICY_DATA, (st), (val)) ++#define sk_X509_POLICY_DATA_find_ex(st, val) SKM_sk_find_ex(X509_POLICY_DATA, (st), (val)) ++#define sk_X509_POLICY_DATA_delete(st, i) SKM_sk_delete(X509_POLICY_DATA, (st), (i)) ++#define sk_X509_POLICY_DATA_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_POLICY_DATA, (st), (ptr)) ++#define sk_X509_POLICY_DATA_insert(st, val, i) SKM_sk_insert(X509_POLICY_DATA, (st), (val), (i)) ++#define sk_X509_POLICY_DATA_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_POLICY_DATA, (st), (cmp)) ++#define sk_X509_POLICY_DATA_dup(st) SKM_sk_dup(X509_POLICY_DATA, st) ++#define sk_X509_POLICY_DATA_pop_free(st, free_func) SKM_sk_pop_free(X509_POLICY_DATA, (st), (free_func)) ++#define sk_X509_POLICY_DATA_shift(st) SKM_sk_shift(X509_POLICY_DATA, (st)) ++#define sk_X509_POLICY_DATA_pop(st) SKM_sk_pop(X509_POLICY_DATA, (st)) ++#define sk_X509_POLICY_DATA_sort(st) SKM_sk_sort(X509_POLICY_DATA, (st)) ++#define sk_X509_POLICY_DATA_is_sorted(st) SKM_sk_is_sorted(X509_POLICY_DATA, (st)) ++ ++#define sk_X509_POLICY_NODE_new(cmp) SKM_sk_new(X509_POLICY_NODE, (cmp)) ++#define sk_X509_POLICY_NODE_new_null() SKM_sk_new_null(X509_POLICY_NODE) ++#define sk_X509_POLICY_NODE_free(st) SKM_sk_free(X509_POLICY_NODE, (st)) ++#define sk_X509_POLICY_NODE_num(st) SKM_sk_num(X509_POLICY_NODE, (st)) ++#define sk_X509_POLICY_NODE_value(st, i) SKM_sk_value(X509_POLICY_NODE, (st), (i)) ++#define sk_X509_POLICY_NODE_set(st, i, val) SKM_sk_set(X509_POLICY_NODE, (st), (i), (val)) ++#define sk_X509_POLICY_NODE_zero(st) SKM_sk_zero(X509_POLICY_NODE, (st)) ++#define sk_X509_POLICY_NODE_push(st, val) SKM_sk_push(X509_POLICY_NODE, (st), (val)) ++#define sk_X509_POLICY_NODE_unshift(st, val) SKM_sk_unshift(X509_POLICY_NODE, (st), (val)) ++#define sk_X509_POLICY_NODE_find(st, val) SKM_sk_find(X509_POLICY_NODE, (st), (val)) ++#define sk_X509_POLICY_NODE_find_ex(st, val) SKM_sk_find_ex(X509_POLICY_NODE, (st), (val)) ++#define sk_X509_POLICY_NODE_delete(st, i) SKM_sk_delete(X509_POLICY_NODE, (st), (i)) ++#define sk_X509_POLICY_NODE_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_POLICY_NODE, (st), (ptr)) ++#define sk_X509_POLICY_NODE_insert(st, val, i) SKM_sk_insert(X509_POLICY_NODE, (st), (val), (i)) ++#define sk_X509_POLICY_NODE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_POLICY_NODE, (st), (cmp)) ++#define sk_X509_POLICY_NODE_dup(st) SKM_sk_dup(X509_POLICY_NODE, st) ++#define sk_X509_POLICY_NODE_pop_free(st, free_func) SKM_sk_pop_free(X509_POLICY_NODE, (st), (free_func)) ++#define sk_X509_POLICY_NODE_shift(st) SKM_sk_shift(X509_POLICY_NODE, (st)) ++#define sk_X509_POLICY_NODE_pop(st) SKM_sk_pop(X509_POLICY_NODE, (st)) ++#define sk_X509_POLICY_NODE_sort(st) SKM_sk_sort(X509_POLICY_NODE, (st)) ++#define sk_X509_POLICY_NODE_is_sorted(st) SKM_sk_is_sorted(X509_POLICY_NODE, (st)) ++ ++#define sk_X509_PURPOSE_new(cmp) SKM_sk_new(X509_PURPOSE, (cmp)) ++#define sk_X509_PURPOSE_new_null() SKM_sk_new_null(X509_PURPOSE) ++#define sk_X509_PURPOSE_free(st) SKM_sk_free(X509_PURPOSE, (st)) ++#define sk_X509_PURPOSE_num(st) SKM_sk_num(X509_PURPOSE, (st)) ++#define sk_X509_PURPOSE_value(st, i) SKM_sk_value(X509_PURPOSE, (st), (i)) ++#define sk_X509_PURPOSE_set(st, i, val) SKM_sk_set(X509_PURPOSE, (st), (i), (val)) ++#define sk_X509_PURPOSE_zero(st) SKM_sk_zero(X509_PURPOSE, (st)) ++#define sk_X509_PURPOSE_push(st, val) SKM_sk_push(X509_PURPOSE, (st), (val)) ++#define sk_X509_PURPOSE_unshift(st, val) SKM_sk_unshift(X509_PURPOSE, (st), (val)) ++#define sk_X509_PURPOSE_find(st, val) SKM_sk_find(X509_PURPOSE, (st), (val)) ++#define sk_X509_PURPOSE_find_ex(st, val) SKM_sk_find_ex(X509_PURPOSE, (st), (val)) ++#define sk_X509_PURPOSE_delete(st, i) SKM_sk_delete(X509_PURPOSE, (st), (i)) ++#define sk_X509_PURPOSE_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_PURPOSE, (st), (ptr)) ++#define sk_X509_PURPOSE_insert(st, val, i) SKM_sk_insert(X509_PURPOSE, (st), (val), (i)) ++#define sk_X509_PURPOSE_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_PURPOSE, (st), (cmp)) ++#define sk_X509_PURPOSE_dup(st) SKM_sk_dup(X509_PURPOSE, st) ++#define sk_X509_PURPOSE_pop_free(st, free_func) SKM_sk_pop_free(X509_PURPOSE, (st), (free_func)) ++#define sk_X509_PURPOSE_shift(st) SKM_sk_shift(X509_PURPOSE, (st)) ++#define sk_X509_PURPOSE_pop(st) SKM_sk_pop(X509_PURPOSE, (st)) ++#define sk_X509_PURPOSE_sort(st) SKM_sk_sort(X509_PURPOSE, (st)) ++#define sk_X509_PURPOSE_is_sorted(st) SKM_sk_is_sorted(X509_PURPOSE, (st)) ++ ++#define sk_X509_REVOKED_new(cmp) SKM_sk_new(X509_REVOKED, (cmp)) ++#define sk_X509_REVOKED_new_null() SKM_sk_new_null(X509_REVOKED) ++#define sk_X509_REVOKED_free(st) SKM_sk_free(X509_REVOKED, (st)) ++#define sk_X509_REVOKED_num(st) SKM_sk_num(X509_REVOKED, (st)) ++#define sk_X509_REVOKED_value(st, i) SKM_sk_value(X509_REVOKED, (st), (i)) ++#define sk_X509_REVOKED_set(st, i, val) SKM_sk_set(X509_REVOKED, (st), (i), (val)) ++#define sk_X509_REVOKED_zero(st) SKM_sk_zero(X509_REVOKED, (st)) ++#define sk_X509_REVOKED_push(st, val) SKM_sk_push(X509_REVOKED, (st), (val)) ++#define sk_X509_REVOKED_unshift(st, val) SKM_sk_unshift(X509_REVOKED, (st), (val)) ++#define sk_X509_REVOKED_find(st, val) SKM_sk_find(X509_REVOKED, (st), (val)) ++#define sk_X509_REVOKED_find_ex(st, val) SKM_sk_find_ex(X509_REVOKED, (st), (val)) ++#define sk_X509_REVOKED_delete(st, i) SKM_sk_delete(X509_REVOKED, (st), (i)) ++#define sk_X509_REVOKED_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_REVOKED, (st), (ptr)) ++#define sk_X509_REVOKED_insert(st, val, i) SKM_sk_insert(X509_REVOKED, (st), (val), (i)) ++#define sk_X509_REVOKED_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_REVOKED, (st), (cmp)) ++#define sk_X509_REVOKED_dup(st) SKM_sk_dup(X509_REVOKED, st) ++#define sk_X509_REVOKED_pop_free(st, free_func) SKM_sk_pop_free(X509_REVOKED, (st), (free_func)) ++#define sk_X509_REVOKED_shift(st) SKM_sk_shift(X509_REVOKED, (st)) ++#define sk_X509_REVOKED_pop(st) SKM_sk_pop(X509_REVOKED, (st)) ++#define sk_X509_REVOKED_sort(st) SKM_sk_sort(X509_REVOKED, (st)) ++#define sk_X509_REVOKED_is_sorted(st) SKM_sk_is_sorted(X509_REVOKED, (st)) ++ ++#define sk_X509_TRUST_new(cmp) SKM_sk_new(X509_TRUST, (cmp)) ++#define sk_X509_TRUST_new_null() SKM_sk_new_null(X509_TRUST) ++#define sk_X509_TRUST_free(st) SKM_sk_free(X509_TRUST, (st)) ++#define sk_X509_TRUST_num(st) SKM_sk_num(X509_TRUST, (st)) ++#define sk_X509_TRUST_value(st, i) SKM_sk_value(X509_TRUST, (st), (i)) ++#define sk_X509_TRUST_set(st, i, val) SKM_sk_set(X509_TRUST, (st), (i), (val)) ++#define sk_X509_TRUST_zero(st) SKM_sk_zero(X509_TRUST, (st)) ++#define sk_X509_TRUST_push(st, val) SKM_sk_push(X509_TRUST, (st), (val)) ++#define sk_X509_TRUST_unshift(st, val) SKM_sk_unshift(X509_TRUST, (st), (val)) ++#define sk_X509_TRUST_find(st, val) SKM_sk_find(X509_TRUST, (st), (val)) ++#define sk_X509_TRUST_find_ex(st, val) SKM_sk_find_ex(X509_TRUST, (st), (val)) ++#define sk_X509_TRUST_delete(st, i) SKM_sk_delete(X509_TRUST, (st), (i)) ++#define sk_X509_TRUST_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_TRUST, (st), (ptr)) ++#define sk_X509_TRUST_insert(st, val, i) SKM_sk_insert(X509_TRUST, (st), (val), (i)) ++#define sk_X509_TRUST_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_TRUST, (st), (cmp)) ++#define sk_X509_TRUST_dup(st) SKM_sk_dup(X509_TRUST, st) ++#define sk_X509_TRUST_pop_free(st, free_func) SKM_sk_pop_free(X509_TRUST, (st), (free_func)) ++#define sk_X509_TRUST_shift(st) SKM_sk_shift(X509_TRUST, (st)) ++#define sk_X509_TRUST_pop(st) SKM_sk_pop(X509_TRUST, (st)) ++#define sk_X509_TRUST_sort(st) SKM_sk_sort(X509_TRUST, (st)) ++#define sk_X509_TRUST_is_sorted(st) SKM_sk_is_sorted(X509_TRUST, (st)) ++ ++#define sk_X509_VERIFY_PARAM_new(cmp) SKM_sk_new(X509_VERIFY_PARAM, (cmp)) ++#define sk_X509_VERIFY_PARAM_new_null() SKM_sk_new_null(X509_VERIFY_PARAM) ++#define sk_X509_VERIFY_PARAM_free(st) SKM_sk_free(X509_VERIFY_PARAM, (st)) ++#define sk_X509_VERIFY_PARAM_num(st) SKM_sk_num(X509_VERIFY_PARAM, (st)) ++#define sk_X509_VERIFY_PARAM_value(st, i) SKM_sk_value(X509_VERIFY_PARAM, (st), (i)) ++#define sk_X509_VERIFY_PARAM_set(st, i, val) SKM_sk_set(X509_VERIFY_PARAM, (st), (i), (val)) ++#define sk_X509_VERIFY_PARAM_zero(st) SKM_sk_zero(X509_VERIFY_PARAM, (st)) ++#define sk_X509_VERIFY_PARAM_push(st, val) SKM_sk_push(X509_VERIFY_PARAM, (st), (val)) ++#define sk_X509_VERIFY_PARAM_unshift(st, val) SKM_sk_unshift(X509_VERIFY_PARAM, (st), (val)) ++#define sk_X509_VERIFY_PARAM_find(st, val) SKM_sk_find(X509_VERIFY_PARAM, (st), (val)) ++#define sk_X509_VERIFY_PARAM_find_ex(st, val) SKM_sk_find_ex(X509_VERIFY_PARAM, (st), (val)) ++#define sk_X509_VERIFY_PARAM_delete(st, i) SKM_sk_delete(X509_VERIFY_PARAM, (st), (i)) ++#define sk_X509_VERIFY_PARAM_delete_ptr(st, ptr) SKM_sk_delete_ptr(X509_VERIFY_PARAM, (st), (ptr)) ++#define sk_X509_VERIFY_PARAM_insert(st, val, i) SKM_sk_insert(X509_VERIFY_PARAM, (st), (val), (i)) ++#define sk_X509_VERIFY_PARAM_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(X509_VERIFY_PARAM, (st), (cmp)) ++#define sk_X509_VERIFY_PARAM_dup(st) SKM_sk_dup(X509_VERIFY_PARAM, st) ++#define sk_X509_VERIFY_PARAM_pop_free(st, free_func) SKM_sk_pop_free(X509_VERIFY_PARAM, (st), (free_func)) ++#define sk_X509_VERIFY_PARAM_shift(st) SKM_sk_shift(X509_VERIFY_PARAM, (st)) ++#define sk_X509_VERIFY_PARAM_pop(st) SKM_sk_pop(X509_VERIFY_PARAM, (st)) ++#define sk_X509_VERIFY_PARAM_sort(st) SKM_sk_sort(X509_VERIFY_PARAM, (st)) ++#define sk_X509_VERIFY_PARAM_is_sorted(st) SKM_sk_is_sorted(X509_VERIFY_PARAM, (st)) ++ ++#define sk_nid_triple_new(cmp) SKM_sk_new(nid_triple, (cmp)) ++#define sk_nid_triple_new_null() SKM_sk_new_null(nid_triple) ++#define sk_nid_triple_free(st) SKM_sk_free(nid_triple, (st)) ++#define sk_nid_triple_num(st) SKM_sk_num(nid_triple, (st)) ++#define sk_nid_triple_value(st, i) SKM_sk_value(nid_triple, (st), (i)) ++#define sk_nid_triple_set(st, i, val) SKM_sk_set(nid_triple, (st), (i), (val)) ++#define sk_nid_triple_zero(st) SKM_sk_zero(nid_triple, (st)) ++#define sk_nid_triple_push(st, val) SKM_sk_push(nid_triple, (st), (val)) ++#define sk_nid_triple_unshift(st, val) SKM_sk_unshift(nid_triple, (st), (val)) ++#define sk_nid_triple_find(st, val) SKM_sk_find(nid_triple, (st), (val)) ++#define sk_nid_triple_find_ex(st, val) SKM_sk_find_ex(nid_triple, (st), (val)) ++#define sk_nid_triple_delete(st, i) SKM_sk_delete(nid_triple, (st), (i)) ++#define sk_nid_triple_delete_ptr(st, ptr) SKM_sk_delete_ptr(nid_triple, (st), (ptr)) ++#define sk_nid_triple_insert(st, val, i) SKM_sk_insert(nid_triple, (st), (val), (i)) ++#define sk_nid_triple_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(nid_triple, (st), (cmp)) ++#define sk_nid_triple_dup(st) SKM_sk_dup(nid_triple, st) ++#define sk_nid_triple_pop_free(st, free_func) SKM_sk_pop_free(nid_triple, (st), (free_func)) ++#define sk_nid_triple_shift(st) SKM_sk_shift(nid_triple, (st)) ++#define sk_nid_triple_pop(st) SKM_sk_pop(nid_triple, (st)) ++#define sk_nid_triple_sort(st) SKM_sk_sort(nid_triple, (st)) ++#define sk_nid_triple_is_sorted(st) SKM_sk_is_sorted(nid_triple, (st)) ++ ++#define sk_void_new(cmp) SKM_sk_new(void, (cmp)) ++#define sk_void_new_null() SKM_sk_new_null(void) ++#define sk_void_free(st) SKM_sk_free(void, (st)) ++#define sk_void_num(st) SKM_sk_num(void, (st)) ++#define sk_void_value(st, i) SKM_sk_value(void, (st), (i)) ++#define sk_void_set(st, i, val) SKM_sk_set(void, (st), (i), (val)) ++#define sk_void_zero(st) SKM_sk_zero(void, (st)) ++#define sk_void_push(st, val) SKM_sk_push(void, (st), (val)) ++#define sk_void_unshift(st, val) SKM_sk_unshift(void, (st), (val)) ++#define sk_void_find(st, val) SKM_sk_find(void, (st), (val)) ++#define sk_void_find_ex(st, val) SKM_sk_find_ex(void, (st), (val)) ++#define sk_void_delete(st, i) SKM_sk_delete(void, (st), (i)) ++#define sk_void_delete_ptr(st, ptr) SKM_sk_delete_ptr(void, (st), (ptr)) ++#define sk_void_insert(st, val, i) SKM_sk_insert(void, (st), (val), (i)) ++#define sk_void_set_cmp_func(st, cmp) SKM_sk_set_cmp_func(void, (st), (cmp)) ++#define sk_void_dup(st) SKM_sk_dup(void, st) ++#define sk_void_pop_free(st, free_func) SKM_sk_pop_free(void, (st), (free_func)) ++#define sk_void_shift(st) SKM_sk_shift(void, (st)) ++#define sk_void_pop(st) SKM_sk_pop(void, (st)) ++#define sk_void_sort(st) SKM_sk_sort(void, (st)) ++#define sk_void_is_sorted(st) SKM_sk_is_sorted(void, (st)) ++ ++#define sk_OPENSSL_BLOCK_new(cmp) ((STACK_OF(OPENSSL_BLOCK) *)sk_new(CHECKED_SK_CMP_FUNC(void, cmp))) ++#define sk_OPENSSL_BLOCK_new_null() ((STACK_OF(OPENSSL_BLOCK) *)sk_new_null()) ++#define sk_OPENSSL_BLOCK_push(st, val) sk_push(CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), CHECKED_PTR_OF(void, val)) ++#define sk_OPENSSL_BLOCK_find(st, val) sk_find(CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), CHECKED_PTR_OF(void, val)) ++#define sk_OPENSSL_BLOCK_value(st, i) ((OPENSSL_BLOCK)sk_value(CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), i)) ++#define sk_OPENSSL_BLOCK_num(st) SKM_sk_num(OPENSSL_BLOCK, st) ++#define sk_OPENSSL_BLOCK_pop_free(st, free_func) sk_pop_free(CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), CHECKED_SK_FREE_FUNC2(OPENSSL_BLOCK, free_func)) ++#define sk_OPENSSL_BLOCK_insert(st, val, i) sk_insert(CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), CHECKED_PTR_OF(void, val), i) ++#define sk_OPENSSL_BLOCK_free(st) SKM_sk_free(OPENSSL_BLOCK, st) ++#define sk_OPENSSL_BLOCK_set(st, i, val) sk_set((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), i, CHECKED_PTR_OF(void, val)) ++#define sk_OPENSSL_BLOCK_zero(st) SKM_sk_zero(OPENSSL_BLOCK, (st)) ++#define sk_OPENSSL_BLOCK_unshift(st, val) sk_unshift((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), CHECKED_PTR_OF(void, val)) ++#define sk_OPENSSL_BLOCK_find_ex(st, val) sk_find_ex((_STACK *)CHECKED_CONST_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), CHECKED_CONST_PTR_OF(void, val)) ++#define sk_OPENSSL_BLOCK_delete(st, i) SKM_sk_delete(OPENSSL_BLOCK, (st), (i)) ++#define sk_OPENSSL_BLOCK_delete_ptr(st, ptr) (OPENSSL_BLOCK *)sk_delete_ptr((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), CHECKED_PTR_OF(void, ptr)) ++#define sk_OPENSSL_BLOCK_set_cmp_func(st, cmp) \ ++ ((int (*)(const void * const *,const void * const *)) \ ++ sk_set_cmp_func((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), CHECKED_SK_CMP_FUNC(void, cmp))) ++#define sk_OPENSSL_BLOCK_dup(st) SKM_sk_dup(OPENSSL_BLOCK, st) ++#define sk_OPENSSL_BLOCK_shift(st) SKM_sk_shift(OPENSSL_BLOCK, (st)) ++#define sk_OPENSSL_BLOCK_pop(st) (void *)sk_pop((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st)) ++#define sk_OPENSSL_BLOCK_sort(st) SKM_sk_sort(OPENSSL_BLOCK, (st)) ++#define sk_OPENSSL_BLOCK_is_sorted(st) SKM_sk_is_sorted(OPENSSL_BLOCK, (st)) ++ ++ ++#define sk_OPENSSL_PSTRING_new(cmp) ((STACK_OF(OPENSSL_PSTRING) *)sk_new(CHECKED_SK_CMP_FUNC(OPENSSL_STRING, cmp))) ++#define sk_OPENSSL_PSTRING_new_null() ((STACK_OF(OPENSSL_PSTRING) *)sk_new_null()) ++#define sk_OPENSSL_PSTRING_push(st, val) sk_push(CHECKED_PTR_OF(STACK_OF(OPENSSL_PSTRING), st), CHECKED_PTR_OF(OPENSSL_STRING, val)) ++#define sk_OPENSSL_PSTRING_find(st, val) sk_find(CHECKED_PTR_OF(STACK_OF(OPENSSL_PSTRING), st), CHECKED_PTR_OF(OPENSSL_STRING, val)) ++#define sk_OPENSSL_PSTRING_value(st, i) ((OPENSSL_PSTRING)sk_value(CHECKED_PTR_OF(STACK_OF(OPENSSL_PSTRING), st), i)) ++#define sk_OPENSSL_PSTRING_num(st) SKM_sk_num(OPENSSL_PSTRING, st) ++#define sk_OPENSSL_PSTRING_pop_free(st, free_func) sk_pop_free(CHECKED_PTR_OF(STACK_OF(OPENSSL_PSTRING), st), CHECKED_SK_FREE_FUNC2(OPENSSL_PSTRING, free_func)) ++#define sk_OPENSSL_PSTRING_insert(st, val, i) sk_insert(CHECKED_PTR_OF(STACK_OF(OPENSSL_PSTRING), st), CHECKED_PTR_OF(OPENSSL_STRING, val), i) ++#define sk_OPENSSL_PSTRING_free(st) SKM_sk_free(OPENSSL_PSTRING, st) ++#define sk_OPENSSL_PSTRING_set(st, i, val) sk_set((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_PSTRING), st), i, CHECKED_PTR_OF(OPENSSL_STRING, val)) ++#define sk_OPENSSL_PSTRING_zero(st) SKM_sk_zero(OPENSSL_PSTRING, (st)) ++#define sk_OPENSSL_PSTRING_unshift(st, val) sk_unshift((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_PSTRING), st), CHECKED_PTR_OF(OPENSSL_STRING, val)) ++#define sk_OPENSSL_PSTRING_find_ex(st, val) sk_find_ex((_STACK *)CHECKED_CONST_PTR_OF(STACK_OF(OPENSSL_PSTRING), st), CHECKED_CONST_PTR_OF(OPENSSL_STRING, val)) ++#define sk_OPENSSL_PSTRING_delete(st, i) SKM_sk_delete(OPENSSL_PSTRING, (st), (i)) ++#define sk_OPENSSL_PSTRING_delete_ptr(st, ptr) (OPENSSL_PSTRING *)sk_delete_ptr((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_PSTRING), st), CHECKED_PTR_OF(OPENSSL_STRING, ptr)) ++#define sk_OPENSSL_PSTRING_set_cmp_func(st, cmp) \ ++ ((int (*)(const OPENSSL_STRING * const *,const OPENSSL_STRING * const *)) \ ++ sk_set_cmp_func((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_PSTRING), st), CHECKED_SK_CMP_FUNC(OPENSSL_STRING, cmp))) ++#define sk_OPENSSL_PSTRING_dup(st) SKM_sk_dup(OPENSSL_PSTRING, st) ++#define sk_OPENSSL_PSTRING_shift(st) SKM_sk_shift(OPENSSL_PSTRING, (st)) ++#define sk_OPENSSL_PSTRING_pop(st) (OPENSSL_STRING *)sk_pop((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_PSTRING), st)) ++#define sk_OPENSSL_PSTRING_sort(st) SKM_sk_sort(OPENSSL_PSTRING, (st)) ++#define sk_OPENSSL_PSTRING_is_sorted(st) SKM_sk_is_sorted(OPENSSL_PSTRING, (st)) ++ ++ ++#define sk_OPENSSL_STRING_new(cmp) ((STACK_OF(OPENSSL_STRING) *)sk_new(CHECKED_SK_CMP_FUNC(char, cmp))) ++#define sk_OPENSSL_STRING_new_null() ((STACK_OF(OPENSSL_STRING) *)sk_new_null()) ++#define sk_OPENSSL_STRING_push(st, val) sk_push(CHECKED_PTR_OF(STACK_OF(OPENSSL_STRING), st), CHECKED_PTR_OF(char, val)) ++#define sk_OPENSSL_STRING_find(st, val) sk_find(CHECKED_PTR_OF(STACK_OF(OPENSSL_STRING), st), CHECKED_PTR_OF(char, val)) ++#define sk_OPENSSL_STRING_value(st, i) ((OPENSSL_STRING)sk_value(CHECKED_PTR_OF(STACK_OF(OPENSSL_STRING), st), i)) ++#define sk_OPENSSL_STRING_num(st) SKM_sk_num(OPENSSL_STRING, st) ++#define sk_OPENSSL_STRING_pop_free(st, free_func) sk_pop_free(CHECKED_PTR_OF(STACK_OF(OPENSSL_STRING), st), CHECKED_SK_FREE_FUNC2(OPENSSL_STRING, free_func)) ++#define sk_OPENSSL_STRING_insert(st, val, i) sk_insert(CHECKED_PTR_OF(STACK_OF(OPENSSL_STRING), st), CHECKED_PTR_OF(char, val), i) ++#define sk_OPENSSL_STRING_free(st) SKM_sk_free(OPENSSL_STRING, st) ++#define sk_OPENSSL_STRING_set(st, i, val) sk_set((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_STRING), st), i, CHECKED_PTR_OF(char, val)) ++#define sk_OPENSSL_STRING_zero(st) SKM_sk_zero(OPENSSL_STRING, (st)) ++#define sk_OPENSSL_STRING_unshift(st, val) sk_unshift((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_STRING), st), CHECKED_PTR_OF(char, val)) ++#define sk_OPENSSL_STRING_find_ex(st, val) sk_find_ex((_STACK *)CHECKED_CONST_PTR_OF(STACK_OF(OPENSSL_STRING), st), CHECKED_CONST_PTR_OF(char, val)) ++#define sk_OPENSSL_STRING_delete(st, i) SKM_sk_delete(OPENSSL_STRING, (st), (i)) ++#define sk_OPENSSL_STRING_delete_ptr(st, ptr) (OPENSSL_STRING *)sk_delete_ptr((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_STRING), st), CHECKED_PTR_OF(char, ptr)) ++#define sk_OPENSSL_STRING_set_cmp_func(st, cmp) \ ++ ((int (*)(const char * const *,const char * const *)) \ ++ sk_set_cmp_func((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_STRING), st), CHECKED_SK_CMP_FUNC(char, cmp))) ++#define sk_OPENSSL_STRING_dup(st) SKM_sk_dup(OPENSSL_STRING, st) ++#define sk_OPENSSL_STRING_shift(st) SKM_sk_shift(OPENSSL_STRING, (st)) ++#define sk_OPENSSL_STRING_pop(st) (char *)sk_pop((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_STRING), st)) ++#define sk_OPENSSL_STRING_sort(st) SKM_sk_sort(OPENSSL_STRING, (st)) ++#define sk_OPENSSL_STRING_is_sorted(st) SKM_sk_is_sorted(OPENSSL_STRING, (st)) ++ ++ ++#define d2i_ASN1_SET_OF_ACCESS_DESCRIPTION(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(ACCESS_DESCRIPTION, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_ACCESS_DESCRIPTION(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(ACCESS_DESCRIPTION, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_ACCESS_DESCRIPTION(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(ACCESS_DESCRIPTION, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_ACCESS_DESCRIPTION(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(ACCESS_DESCRIPTION, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_ASN1_INTEGER(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(ASN1_INTEGER, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_ASN1_INTEGER(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(ASN1_INTEGER, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_ASN1_INTEGER(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(ASN1_INTEGER, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_ASN1_INTEGER(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(ASN1_INTEGER, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_ASN1_OBJECT(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(ASN1_OBJECT, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_ASN1_OBJECT(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(ASN1_OBJECT, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_ASN1_OBJECT(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(ASN1_OBJECT, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_ASN1_OBJECT(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(ASN1_OBJECT, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_ASN1_TYPE(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(ASN1_TYPE, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_ASN1_TYPE(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(ASN1_TYPE, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_ASN1_TYPE(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(ASN1_TYPE, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_ASN1_TYPE(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(ASN1_TYPE, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_ASN1_UTF8STRING(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(ASN1_UTF8STRING, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_ASN1_UTF8STRING(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(ASN1_UTF8STRING, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_ASN1_UTF8STRING(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(ASN1_UTF8STRING, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_ASN1_UTF8STRING(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(ASN1_UTF8STRING, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_DIST_POINT(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(DIST_POINT, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_DIST_POINT(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(DIST_POINT, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_DIST_POINT(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(DIST_POINT, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_DIST_POINT(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(DIST_POINT, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_ESS_CERT_ID(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(ESS_CERT_ID, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_ESS_CERT_ID(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(ESS_CERT_ID, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_ESS_CERT_ID(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(ESS_CERT_ID, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_ESS_CERT_ID(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(ESS_CERT_ID, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_EVP_MD(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(EVP_MD, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_EVP_MD(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(EVP_MD, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_EVP_MD(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(EVP_MD, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_EVP_MD(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(EVP_MD, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_GENERAL_NAME(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(GENERAL_NAME, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_GENERAL_NAME(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(GENERAL_NAME, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_GENERAL_NAME(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(GENERAL_NAME, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_GENERAL_NAME(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(GENERAL_NAME, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_OCSP_ONEREQ(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(OCSP_ONEREQ, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_OCSP_ONEREQ(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(OCSP_ONEREQ, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_OCSP_ONEREQ(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(OCSP_ONEREQ, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_OCSP_ONEREQ(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(OCSP_ONEREQ, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_OCSP_SINGLERESP(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(OCSP_SINGLERESP, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_OCSP_SINGLERESP(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(OCSP_SINGLERESP, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_OCSP_SINGLERESP(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(OCSP_SINGLERESP, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_OCSP_SINGLERESP(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(OCSP_SINGLERESP, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_PKCS12_SAFEBAG(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(PKCS12_SAFEBAG, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_PKCS12_SAFEBAG(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(PKCS12_SAFEBAG, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_PKCS12_SAFEBAG(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(PKCS12_SAFEBAG, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_PKCS12_SAFEBAG(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(PKCS12_SAFEBAG, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_PKCS7(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(PKCS7, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_PKCS7(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(PKCS7, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_PKCS7(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(PKCS7, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_PKCS7(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(PKCS7, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_PKCS7_RECIP_INFO(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(PKCS7_RECIP_INFO, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_PKCS7_RECIP_INFO(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(PKCS7_RECIP_INFO, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_PKCS7_RECIP_INFO(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(PKCS7_RECIP_INFO, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_PKCS7_RECIP_INFO(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(PKCS7_RECIP_INFO, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_PKCS7_SIGNER_INFO(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(PKCS7_SIGNER_INFO, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_PKCS7_SIGNER_INFO(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(PKCS7_SIGNER_INFO, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_PKCS7_SIGNER_INFO(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(PKCS7_SIGNER_INFO, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_PKCS7_SIGNER_INFO(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(PKCS7_SIGNER_INFO, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_POLICYINFO(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(POLICYINFO, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_POLICYINFO(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(POLICYINFO, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_POLICYINFO(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(POLICYINFO, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_POLICYINFO(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(POLICYINFO, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_POLICYQUALINFO(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(POLICYQUALINFO, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_POLICYQUALINFO(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(POLICYQUALINFO, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_POLICYQUALINFO(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(POLICYQUALINFO, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_POLICYQUALINFO(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(POLICYQUALINFO, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_SXNETID(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(SXNETID, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_SXNETID(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(SXNETID, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_SXNETID(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(SXNETID, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_SXNETID(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(SXNETID, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_X509(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(X509, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_X509(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(X509, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_X509(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(X509, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_X509(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(X509, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_X509_ALGOR(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(X509_ALGOR, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_X509_ALGOR(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(X509_ALGOR, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_X509_ALGOR(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(X509_ALGOR, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_X509_ALGOR(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(X509_ALGOR, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_X509_ATTRIBUTE(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(X509_ATTRIBUTE, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_X509_ATTRIBUTE(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(X509_ATTRIBUTE, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_X509_ATTRIBUTE(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(X509_ATTRIBUTE, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_X509_ATTRIBUTE(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(X509_ATTRIBUTE, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_X509_CRL(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(X509_CRL, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_X509_CRL(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(X509_CRL, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_X509_CRL(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(X509_CRL, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_X509_CRL(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(X509_CRL, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_X509_EXTENSION(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(X509_EXTENSION, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_X509_EXTENSION(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(X509_EXTENSION, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_X509_EXTENSION(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(X509_EXTENSION, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_X509_EXTENSION(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(X509_EXTENSION, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_X509_NAME_ENTRY(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(X509_NAME_ENTRY, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_X509_NAME_ENTRY(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(X509_NAME_ENTRY, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_X509_NAME_ENTRY(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(X509_NAME_ENTRY, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_X509_NAME_ENTRY(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(X509_NAME_ENTRY, (buf), (len), (d2i_func), (free_func)) ++ ++#define d2i_ASN1_SET_OF_X509_REVOKED(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \ ++ SKM_ASN1_SET_OF_d2i(X509_REVOKED, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class)) ++#define i2d_ASN1_SET_OF_X509_REVOKED(st, pp, i2d_func, ex_tag, ex_class, is_set) \ ++ SKM_ASN1_SET_OF_i2d(X509_REVOKED, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set)) ++#define ASN1_seq_pack_X509_REVOKED(st, i2d_func, buf, len) \ ++ SKM_ASN1_seq_pack(X509_REVOKED, (st), (i2d_func), (buf), (len)) ++#define ASN1_seq_unpack_X509_REVOKED(buf, len, d2i_func, free_func) \ ++ SKM_ASN1_seq_unpack(X509_REVOKED, (buf), (len), (d2i_func), (free_func)) ++ ++#define PKCS12_decrypt_d2i_PKCS12_SAFEBAG(algor, d2i_func, free_func, pass, passlen, oct, seq) \ ++ SKM_PKCS12_decrypt_d2i(PKCS12_SAFEBAG, (algor), (d2i_func), (free_func), (pass), (passlen), (oct), (seq)) ++ ++#define PKCS12_decrypt_d2i_PKCS7(algor, d2i_func, free_func, pass, passlen, oct, seq) \ ++ SKM_PKCS12_decrypt_d2i(PKCS7, (algor), (d2i_func), (free_func), (pass), (passlen), (oct), (seq)) ++ ++#define lh_ADDED_OBJ_new() LHM_lh_new(ADDED_OBJ,added_obj) ++#define lh_ADDED_OBJ_insert(lh,inst) LHM_lh_insert(ADDED_OBJ,lh,inst) ++#define lh_ADDED_OBJ_retrieve(lh,inst) LHM_lh_retrieve(ADDED_OBJ,lh,inst) ++#define lh_ADDED_OBJ_delete(lh,inst) LHM_lh_delete(ADDED_OBJ,lh,inst) ++#define lh_ADDED_OBJ_doall(lh,fn) LHM_lh_doall(ADDED_OBJ,lh,fn) ++#define lh_ADDED_OBJ_doall_arg(lh,fn,arg_type,arg) \ ++ LHM_lh_doall_arg(ADDED_OBJ,lh,fn,arg_type,arg) ++#define lh_ADDED_OBJ_error(lh) LHM_lh_error(ADDED_OBJ,lh) ++#define lh_ADDED_OBJ_num_items(lh) LHM_lh_num_items(ADDED_OBJ,lh) ++#define lh_ADDED_OBJ_down_load(lh) LHM_lh_down_load(ADDED_OBJ,lh) ++#define lh_ADDED_OBJ_node_stats_bio(lh,out) \ ++ LHM_lh_node_stats_bio(ADDED_OBJ,lh,out) ++#define lh_ADDED_OBJ_node_usage_stats_bio(lh,out) \ ++ LHM_lh_node_usage_stats_bio(ADDED_OBJ,lh,out) ++#define lh_ADDED_OBJ_stats_bio(lh,out) \ ++ LHM_lh_stats_bio(ADDED_OBJ,lh,out) ++#define lh_ADDED_OBJ_free(lh) LHM_lh_free(ADDED_OBJ,lh) ++ ++#define lh_APP_INFO_new() LHM_lh_new(APP_INFO,app_info) ++#define lh_APP_INFO_insert(lh,inst) LHM_lh_insert(APP_INFO,lh,inst) ++#define lh_APP_INFO_retrieve(lh,inst) LHM_lh_retrieve(APP_INFO,lh,inst) ++#define lh_APP_INFO_delete(lh,inst) LHM_lh_delete(APP_INFO,lh,inst) ++#define lh_APP_INFO_doall(lh,fn) LHM_lh_doall(APP_INFO,lh,fn) ++#define lh_APP_INFO_doall_arg(lh,fn,arg_type,arg) \ ++ LHM_lh_doall_arg(APP_INFO,lh,fn,arg_type,arg) ++#define lh_APP_INFO_error(lh) LHM_lh_error(APP_INFO,lh) ++#define lh_APP_INFO_num_items(lh) LHM_lh_num_items(APP_INFO,lh) ++#define lh_APP_INFO_down_load(lh) LHM_lh_down_load(APP_INFO,lh) ++#define lh_APP_INFO_node_stats_bio(lh,out) \ ++ LHM_lh_node_stats_bio(APP_INFO,lh,out) ++#define lh_APP_INFO_node_usage_stats_bio(lh,out) \ ++ LHM_lh_node_usage_stats_bio(APP_INFO,lh,out) ++#define lh_APP_INFO_stats_bio(lh,out) \ ++ LHM_lh_stats_bio(APP_INFO,lh,out) ++#define lh_APP_INFO_free(lh) LHM_lh_free(APP_INFO,lh) ++ ++#define lh_CONF_VALUE_new() LHM_lh_new(CONF_VALUE,conf_value) ++#define lh_CONF_VALUE_insert(lh,inst) LHM_lh_insert(CONF_VALUE,lh,inst) ++#define lh_CONF_VALUE_retrieve(lh,inst) LHM_lh_retrieve(CONF_VALUE,lh,inst) ++#define lh_CONF_VALUE_delete(lh,inst) LHM_lh_delete(CONF_VALUE,lh,inst) ++#define lh_CONF_VALUE_doall(lh,fn) LHM_lh_doall(CONF_VALUE,lh,fn) ++#define lh_CONF_VALUE_doall_arg(lh,fn,arg_type,arg) \ ++ LHM_lh_doall_arg(CONF_VALUE,lh,fn,arg_type,arg) ++#define lh_CONF_VALUE_error(lh) LHM_lh_error(CONF_VALUE,lh) ++#define lh_CONF_VALUE_num_items(lh) LHM_lh_num_items(CONF_VALUE,lh) ++#define lh_CONF_VALUE_down_load(lh) LHM_lh_down_load(CONF_VALUE,lh) ++#define lh_CONF_VALUE_node_stats_bio(lh,out) \ ++ LHM_lh_node_stats_bio(CONF_VALUE,lh,out) ++#define lh_CONF_VALUE_node_usage_stats_bio(lh,out) \ ++ LHM_lh_node_usage_stats_bio(CONF_VALUE,lh,out) ++#define lh_CONF_VALUE_stats_bio(lh,out) \ ++ LHM_lh_stats_bio(CONF_VALUE,lh,out) ++#define lh_CONF_VALUE_free(lh) LHM_lh_free(CONF_VALUE,lh) ++ ++#define lh_ENGINE_PILE_new() LHM_lh_new(ENGINE_PILE,engine_pile) ++#define lh_ENGINE_PILE_insert(lh,inst) LHM_lh_insert(ENGINE_PILE,lh,inst) ++#define lh_ENGINE_PILE_retrieve(lh,inst) LHM_lh_retrieve(ENGINE_PILE,lh,inst) ++#define lh_ENGINE_PILE_delete(lh,inst) LHM_lh_delete(ENGINE_PILE,lh,inst) ++#define lh_ENGINE_PILE_doall(lh,fn) LHM_lh_doall(ENGINE_PILE,lh,fn) ++#define lh_ENGINE_PILE_doall_arg(lh,fn,arg_type,arg) \ ++ LHM_lh_doall_arg(ENGINE_PILE,lh,fn,arg_type,arg) ++#define lh_ENGINE_PILE_error(lh) LHM_lh_error(ENGINE_PILE,lh) ++#define lh_ENGINE_PILE_num_items(lh) LHM_lh_num_items(ENGINE_PILE,lh) ++#define lh_ENGINE_PILE_down_load(lh) LHM_lh_down_load(ENGINE_PILE,lh) ++#define lh_ENGINE_PILE_node_stats_bio(lh,out) \ ++ LHM_lh_node_stats_bio(ENGINE_PILE,lh,out) ++#define lh_ENGINE_PILE_node_usage_stats_bio(lh,out) \ ++ LHM_lh_node_usage_stats_bio(ENGINE_PILE,lh,out) ++#define lh_ENGINE_PILE_stats_bio(lh,out) \ ++ LHM_lh_stats_bio(ENGINE_PILE,lh,out) ++#define lh_ENGINE_PILE_free(lh) LHM_lh_free(ENGINE_PILE,lh) ++ ++#define lh_ERR_STATE_new() LHM_lh_new(ERR_STATE,err_state) ++#define lh_ERR_STATE_insert(lh,inst) LHM_lh_insert(ERR_STATE,lh,inst) ++#define lh_ERR_STATE_retrieve(lh,inst) LHM_lh_retrieve(ERR_STATE,lh,inst) ++#define lh_ERR_STATE_delete(lh,inst) LHM_lh_delete(ERR_STATE,lh,inst) ++#define lh_ERR_STATE_doall(lh,fn) LHM_lh_doall(ERR_STATE,lh,fn) ++#define lh_ERR_STATE_doall_arg(lh,fn,arg_type,arg) \ ++ LHM_lh_doall_arg(ERR_STATE,lh,fn,arg_type,arg) ++#define lh_ERR_STATE_error(lh) LHM_lh_error(ERR_STATE,lh) ++#define lh_ERR_STATE_num_items(lh) LHM_lh_num_items(ERR_STATE,lh) ++#define lh_ERR_STATE_down_load(lh) LHM_lh_down_load(ERR_STATE,lh) ++#define lh_ERR_STATE_node_stats_bio(lh,out) \ ++ LHM_lh_node_stats_bio(ERR_STATE,lh,out) ++#define lh_ERR_STATE_node_usage_stats_bio(lh,out) \ ++ LHM_lh_node_usage_stats_bio(ERR_STATE,lh,out) ++#define lh_ERR_STATE_stats_bio(lh,out) \ ++ LHM_lh_stats_bio(ERR_STATE,lh,out) ++#define lh_ERR_STATE_free(lh) LHM_lh_free(ERR_STATE,lh) ++ ++#define lh_ERR_STRING_DATA_new() LHM_lh_new(ERR_STRING_DATA,err_string_data) ++#define lh_ERR_STRING_DATA_insert(lh,inst) LHM_lh_insert(ERR_STRING_DATA,lh,inst) ++#define lh_ERR_STRING_DATA_retrieve(lh,inst) LHM_lh_retrieve(ERR_STRING_DATA,lh,inst) ++#define lh_ERR_STRING_DATA_delete(lh,inst) LHM_lh_delete(ERR_STRING_DATA,lh,inst) ++#define lh_ERR_STRING_DATA_doall(lh,fn) LHM_lh_doall(ERR_STRING_DATA,lh,fn) ++#define lh_ERR_STRING_DATA_doall_arg(lh,fn,arg_type,arg) \ ++ LHM_lh_doall_arg(ERR_STRING_DATA,lh,fn,arg_type,arg) ++#define lh_ERR_STRING_DATA_error(lh) LHM_lh_error(ERR_STRING_DATA,lh) ++#define lh_ERR_STRING_DATA_num_items(lh) LHM_lh_num_items(ERR_STRING_DATA,lh) ++#define lh_ERR_STRING_DATA_down_load(lh) LHM_lh_down_load(ERR_STRING_DATA,lh) ++#define lh_ERR_STRING_DATA_node_stats_bio(lh,out) \ ++ LHM_lh_node_stats_bio(ERR_STRING_DATA,lh,out) ++#define lh_ERR_STRING_DATA_node_usage_stats_bio(lh,out) \ ++ LHM_lh_node_usage_stats_bio(ERR_STRING_DATA,lh,out) ++#define lh_ERR_STRING_DATA_stats_bio(lh,out) \ ++ LHM_lh_stats_bio(ERR_STRING_DATA,lh,out) ++#define lh_ERR_STRING_DATA_free(lh) LHM_lh_free(ERR_STRING_DATA,lh) ++ ++#define lh_EX_CLASS_ITEM_new() LHM_lh_new(EX_CLASS_ITEM,ex_class_item) ++#define lh_EX_CLASS_ITEM_insert(lh,inst) LHM_lh_insert(EX_CLASS_ITEM,lh,inst) ++#define lh_EX_CLASS_ITEM_retrieve(lh,inst) LHM_lh_retrieve(EX_CLASS_ITEM,lh,inst) ++#define lh_EX_CLASS_ITEM_delete(lh,inst) LHM_lh_delete(EX_CLASS_ITEM,lh,inst) ++#define lh_EX_CLASS_ITEM_doall(lh,fn) LHM_lh_doall(EX_CLASS_ITEM,lh,fn) ++#define lh_EX_CLASS_ITEM_doall_arg(lh,fn,arg_type,arg) \ ++ LHM_lh_doall_arg(EX_CLASS_ITEM,lh,fn,arg_type,arg) ++#define lh_EX_CLASS_ITEM_error(lh) LHM_lh_error(EX_CLASS_ITEM,lh) ++#define lh_EX_CLASS_ITEM_num_items(lh) LHM_lh_num_items(EX_CLASS_ITEM,lh) ++#define lh_EX_CLASS_ITEM_down_load(lh) LHM_lh_down_load(EX_CLASS_ITEM,lh) ++#define lh_EX_CLASS_ITEM_node_stats_bio(lh,out) \ ++ LHM_lh_node_stats_bio(EX_CLASS_ITEM,lh,out) ++#define lh_EX_CLASS_ITEM_node_usage_stats_bio(lh,out) \ ++ LHM_lh_node_usage_stats_bio(EX_CLASS_ITEM,lh,out) ++#define lh_EX_CLASS_ITEM_stats_bio(lh,out) \ ++ LHM_lh_stats_bio(EX_CLASS_ITEM,lh,out) ++#define lh_EX_CLASS_ITEM_free(lh) LHM_lh_free(EX_CLASS_ITEM,lh) ++ ++#define lh_FUNCTION_new() LHM_lh_new(FUNCTION,function) ++#define lh_FUNCTION_insert(lh,inst) LHM_lh_insert(FUNCTION,lh,inst) ++#define lh_FUNCTION_retrieve(lh,inst) LHM_lh_retrieve(FUNCTION,lh,inst) ++#define lh_FUNCTION_delete(lh,inst) LHM_lh_delete(FUNCTION,lh,inst) ++#define lh_FUNCTION_doall(lh,fn) LHM_lh_doall(FUNCTION,lh,fn) ++#define lh_FUNCTION_doall_arg(lh,fn,arg_type,arg) \ ++ LHM_lh_doall_arg(FUNCTION,lh,fn,arg_type,arg) ++#define lh_FUNCTION_error(lh) LHM_lh_error(FUNCTION,lh) ++#define lh_FUNCTION_num_items(lh) LHM_lh_num_items(FUNCTION,lh) ++#define lh_FUNCTION_down_load(lh) LHM_lh_down_load(FUNCTION,lh) ++#define lh_FUNCTION_node_stats_bio(lh,out) \ ++ LHM_lh_node_stats_bio(FUNCTION,lh,out) ++#define lh_FUNCTION_node_usage_stats_bio(lh,out) \ ++ LHM_lh_node_usage_stats_bio(FUNCTION,lh,out) ++#define lh_FUNCTION_stats_bio(lh,out) \ ++ LHM_lh_stats_bio(FUNCTION,lh,out) ++#define lh_FUNCTION_free(lh) LHM_lh_free(FUNCTION,lh) ++ ++#define lh_MEM_new() LHM_lh_new(MEM,mem) ++#define lh_MEM_insert(lh,inst) LHM_lh_insert(MEM,lh,inst) ++#define lh_MEM_retrieve(lh,inst) LHM_lh_retrieve(MEM,lh,inst) ++#define lh_MEM_delete(lh,inst) LHM_lh_delete(MEM,lh,inst) ++#define lh_MEM_doall(lh,fn) LHM_lh_doall(MEM,lh,fn) ++#define lh_MEM_doall_arg(lh,fn,arg_type,arg) \ ++ LHM_lh_doall_arg(MEM,lh,fn,arg_type,arg) ++#define lh_MEM_error(lh) LHM_lh_error(MEM,lh) ++#define lh_MEM_num_items(lh) LHM_lh_num_items(MEM,lh) ++#define lh_MEM_down_load(lh) LHM_lh_down_load(MEM,lh) ++#define lh_MEM_node_stats_bio(lh,out) \ ++ LHM_lh_node_stats_bio(MEM,lh,out) ++#define lh_MEM_node_usage_stats_bio(lh,out) \ ++ LHM_lh_node_usage_stats_bio(MEM,lh,out) ++#define lh_MEM_stats_bio(lh,out) \ ++ LHM_lh_stats_bio(MEM,lh,out) ++#define lh_MEM_free(lh) LHM_lh_free(MEM,lh) ++ ++#define lh_OBJ_NAME_new() LHM_lh_new(OBJ_NAME,obj_name) ++#define lh_OBJ_NAME_insert(lh,inst) LHM_lh_insert(OBJ_NAME,lh,inst) ++#define lh_OBJ_NAME_retrieve(lh,inst) LHM_lh_retrieve(OBJ_NAME,lh,inst) ++#define lh_OBJ_NAME_delete(lh,inst) LHM_lh_delete(OBJ_NAME,lh,inst) ++#define lh_OBJ_NAME_doall(lh,fn) LHM_lh_doall(OBJ_NAME,lh,fn) ++#define lh_OBJ_NAME_doall_arg(lh,fn,arg_type,arg) \ ++ LHM_lh_doall_arg(OBJ_NAME,lh,fn,arg_type,arg) ++#define lh_OBJ_NAME_error(lh) LHM_lh_error(OBJ_NAME,lh) ++#define lh_OBJ_NAME_num_items(lh) LHM_lh_num_items(OBJ_NAME,lh) ++#define lh_OBJ_NAME_down_load(lh) LHM_lh_down_load(OBJ_NAME,lh) ++#define lh_OBJ_NAME_node_stats_bio(lh,out) \ ++ LHM_lh_node_stats_bio(OBJ_NAME,lh,out) ++#define lh_OBJ_NAME_node_usage_stats_bio(lh,out) \ ++ LHM_lh_node_usage_stats_bio(OBJ_NAME,lh,out) ++#define lh_OBJ_NAME_stats_bio(lh,out) \ ++ LHM_lh_stats_bio(OBJ_NAME,lh,out) ++#define lh_OBJ_NAME_free(lh) LHM_lh_free(OBJ_NAME,lh) ++ ++#define lh_OPENSSL_CSTRING_new() LHM_lh_new(OPENSSL_CSTRING,openssl_cstring) ++#define lh_OPENSSL_CSTRING_insert(lh,inst) LHM_lh_insert(OPENSSL_CSTRING,lh,inst) ++#define lh_OPENSSL_CSTRING_retrieve(lh,inst) LHM_lh_retrieve(OPENSSL_CSTRING,lh,inst) ++#define lh_OPENSSL_CSTRING_delete(lh,inst) LHM_lh_delete(OPENSSL_CSTRING,lh,inst) ++#define lh_OPENSSL_CSTRING_doall(lh,fn) LHM_lh_doall(OPENSSL_CSTRING,lh,fn) ++#define lh_OPENSSL_CSTRING_doall_arg(lh,fn,arg_type,arg) \ ++ LHM_lh_doall_arg(OPENSSL_CSTRING,lh,fn,arg_type,arg) ++#define lh_OPENSSL_CSTRING_error(lh) LHM_lh_error(OPENSSL_CSTRING,lh) ++#define lh_OPENSSL_CSTRING_num_items(lh) LHM_lh_num_items(OPENSSL_CSTRING,lh) ++#define lh_OPENSSL_CSTRING_down_load(lh) LHM_lh_down_load(OPENSSL_CSTRING,lh) ++#define lh_OPENSSL_CSTRING_node_stats_bio(lh,out) \ ++ LHM_lh_node_stats_bio(OPENSSL_CSTRING,lh,out) ++#define lh_OPENSSL_CSTRING_node_usage_stats_bio(lh,out) \ ++ LHM_lh_node_usage_stats_bio(OPENSSL_CSTRING,lh,out) ++#define lh_OPENSSL_CSTRING_stats_bio(lh,out) \ ++ LHM_lh_stats_bio(OPENSSL_CSTRING,lh,out) ++#define lh_OPENSSL_CSTRING_free(lh) LHM_lh_free(OPENSSL_CSTRING,lh) ++ ++#define lh_OPENSSL_STRING_new() LHM_lh_new(OPENSSL_STRING,openssl_string) ++#define lh_OPENSSL_STRING_insert(lh,inst) LHM_lh_insert(OPENSSL_STRING,lh,inst) ++#define lh_OPENSSL_STRING_retrieve(lh,inst) LHM_lh_retrieve(OPENSSL_STRING,lh,inst) ++#define lh_OPENSSL_STRING_delete(lh,inst) LHM_lh_delete(OPENSSL_STRING,lh,inst) ++#define lh_OPENSSL_STRING_doall(lh,fn) LHM_lh_doall(OPENSSL_STRING,lh,fn) ++#define lh_OPENSSL_STRING_doall_arg(lh,fn,arg_type,arg) \ ++ LHM_lh_doall_arg(OPENSSL_STRING,lh,fn,arg_type,arg) ++#define lh_OPENSSL_STRING_error(lh) LHM_lh_error(OPENSSL_STRING,lh) ++#define lh_OPENSSL_STRING_num_items(lh) LHM_lh_num_items(OPENSSL_STRING,lh) ++#define lh_OPENSSL_STRING_down_load(lh) LHM_lh_down_load(OPENSSL_STRING,lh) ++#define lh_OPENSSL_STRING_node_stats_bio(lh,out) \ ++ LHM_lh_node_stats_bio(OPENSSL_STRING,lh,out) ++#define lh_OPENSSL_STRING_node_usage_stats_bio(lh,out) \ ++ LHM_lh_node_usage_stats_bio(OPENSSL_STRING,lh,out) ++#define lh_OPENSSL_STRING_stats_bio(lh,out) \ ++ LHM_lh_stats_bio(OPENSSL_STRING,lh,out) ++#define lh_OPENSSL_STRING_free(lh) LHM_lh_free(OPENSSL_STRING,lh) ++ ++#define lh_SSL_SESSION_new() LHM_lh_new(SSL_SESSION,ssl_session) ++#define lh_SSL_SESSION_insert(lh,inst) LHM_lh_insert(SSL_SESSION,lh,inst) ++#define lh_SSL_SESSION_retrieve(lh,inst) LHM_lh_retrieve(SSL_SESSION,lh,inst) ++#define lh_SSL_SESSION_delete(lh,inst) LHM_lh_delete(SSL_SESSION,lh,inst) ++#define lh_SSL_SESSION_doall(lh,fn) LHM_lh_doall(SSL_SESSION,lh,fn) ++#define lh_SSL_SESSION_doall_arg(lh,fn,arg_type,arg) \ ++ LHM_lh_doall_arg(SSL_SESSION,lh,fn,arg_type,arg) ++#define lh_SSL_SESSION_error(lh) LHM_lh_error(SSL_SESSION,lh) ++#define lh_SSL_SESSION_num_items(lh) LHM_lh_num_items(SSL_SESSION,lh) ++#define lh_SSL_SESSION_down_load(lh) LHM_lh_down_load(SSL_SESSION,lh) ++#define lh_SSL_SESSION_node_stats_bio(lh,out) \ ++ LHM_lh_node_stats_bio(SSL_SESSION,lh,out) ++#define lh_SSL_SESSION_node_usage_stats_bio(lh,out) \ ++ LHM_lh_node_usage_stats_bio(SSL_SESSION,lh,out) ++#define lh_SSL_SESSION_stats_bio(lh,out) \ ++ LHM_lh_stats_bio(SSL_SESSION,lh,out) ++#define lh_SSL_SESSION_free(lh) LHM_lh_free(SSL_SESSION,lh) ++/* End of util/mkstack.pl block, you may now edit :-) */ ++ ++#endif /* !defined HEADER_SAFESTACK_H */ +diff -urN qt.orig/include/openssl/seed.h qt.patched/include/openssl/seed.h +--- qt.orig/include/openssl/seed.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/seed.h 2010-08-27 12:01:45.618270300 +0200 +@@ -0,0 +1,137 @@ ++/* ++ * Copyright (c) 2007 KISA(Korea Information Security Agency). All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Neither the name of author nor the names of its contributors may ++ * be used to endorse or promote products derived from this software ++ * without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ */ ++/* ==================================================================== ++ * Copyright (c) 1998-2007 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * openssl-core@openssl.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.openssl.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++ ++ ++#ifndef HEADER_SEED_H ++#define HEADER_SEED_H ++ ++#include ++#include ++#include ++ ++#ifdef OPENSSL_NO_SEED ++#error SEED is disabled. ++#endif ++ ++#ifdef AES_LONG /* look whether we need 'long' to get 32 bits */ ++# ifndef SEED_LONG ++# define SEED_LONG 1 ++# endif ++#endif ++ ++#if !defined(NO_SYS_TYPES_H) ++# include ++#endif ++ ++#define SEED_BLOCK_SIZE 16 ++#define SEED_KEY_LENGTH 16 ++ ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++ ++typedef struct seed_key_st { ++#ifdef SEED_LONG ++ unsigned long data[32]; ++#else ++ unsigned int data[32]; ++#endif ++} SEED_KEY_SCHEDULE; ++ ++ ++void SEED_set_key(const unsigned char rawkey[SEED_KEY_LENGTH], SEED_KEY_SCHEDULE *ks); ++ ++void SEED_encrypt(const unsigned char s[SEED_BLOCK_SIZE], unsigned char d[SEED_BLOCK_SIZE], const SEED_KEY_SCHEDULE *ks); ++void SEED_decrypt(const unsigned char s[SEED_BLOCK_SIZE], unsigned char d[SEED_BLOCK_SIZE], const SEED_KEY_SCHEDULE *ks); ++ ++void SEED_ecb_encrypt(const unsigned char *in, unsigned char *out, const SEED_KEY_SCHEDULE *ks, int enc); ++void SEED_cbc_encrypt(const unsigned char *in, unsigned char *out, ++ size_t len, const SEED_KEY_SCHEDULE *ks, unsigned char ivec[SEED_BLOCK_SIZE], int enc); ++void SEED_cfb128_encrypt(const unsigned char *in, unsigned char *out, ++ size_t len, const SEED_KEY_SCHEDULE *ks, unsigned char ivec[SEED_BLOCK_SIZE], int *num, int enc); ++void SEED_ofb128_encrypt(const unsigned char *in, unsigned char *out, ++ size_t len, const SEED_KEY_SCHEDULE *ks, unsigned char ivec[SEED_BLOCK_SIZE], int *num); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* HEADER_SEED_H */ +diff -urN qt.orig/include/openssl/sha.h qt.patched/include/openssl/sha.h +--- qt.orig/include/openssl/sha.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/sha.h 2010-08-27 12:01:45.618270300 +0200 +@@ -0,0 +1,200 @@ ++/* crypto/sha/sha.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_SHA_H ++#define HEADER_SHA_H ++ ++#include ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#if defined(OPENSSL_NO_SHA) || (defined(OPENSSL_NO_SHA0) && defined(OPENSSL_NO_SHA1)) ++#error SHA is disabled. ++#endif ++ ++#if defined(OPENSSL_FIPS) ++#define FIPS_SHA_SIZE_T size_t ++#endif ++ ++/* ++ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ++ * ! SHA_LONG has to be at least 32 bits wide. If it's wider, then ! ++ * ! SHA_LONG_LOG2 has to be defined along. ! ++ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ++ */ ++ ++#if defined(__LP32__) ++#define SHA_LONG unsigned long ++#elif defined(OPENSSL_SYS_CRAY) || defined(__ILP64__) ++#define SHA_LONG unsigned long ++#define SHA_LONG_LOG2 3 ++#else ++#define SHA_LONG unsigned int ++#endif ++ ++#define SHA_LBLOCK 16 ++#define SHA_CBLOCK (SHA_LBLOCK*4) /* SHA treats input data as a ++ * contiguous array of 32 bit ++ * wide big-endian values. */ ++#define SHA_LAST_BLOCK (SHA_CBLOCK-8) ++#define SHA_DIGEST_LENGTH 20 ++ ++typedef struct SHAstate_st ++ { ++ SHA_LONG h0,h1,h2,h3,h4; ++ SHA_LONG Nl,Nh; ++ SHA_LONG data[SHA_LBLOCK]; ++ unsigned int num; ++ } SHA_CTX; ++ ++#ifndef OPENSSL_NO_SHA0 ++int SHA_Init(SHA_CTX *c); ++int SHA_Update(SHA_CTX *c, const void *data, size_t len); ++int SHA_Final(unsigned char *md, SHA_CTX *c); ++unsigned char *SHA(const unsigned char *d, size_t n, unsigned char *md); ++void SHA_Transform(SHA_CTX *c, const unsigned char *data); ++#endif ++#ifndef OPENSSL_NO_SHA1 ++int SHA1_Init(SHA_CTX *c); ++int SHA1_Update(SHA_CTX *c, const void *data, size_t len); ++int SHA1_Final(unsigned char *md, SHA_CTX *c); ++unsigned char *SHA1(const unsigned char *d, size_t n, unsigned char *md); ++void SHA1_Transform(SHA_CTX *c, const unsigned char *data); ++#endif ++ ++#define SHA256_CBLOCK (SHA_LBLOCK*4) /* SHA-256 treats input data as a ++ * contiguous array of 32 bit ++ * wide big-endian values. */ ++#define SHA224_DIGEST_LENGTH 28 ++#define SHA256_DIGEST_LENGTH 32 ++ ++typedef struct SHA256state_st ++ { ++ SHA_LONG h[8]; ++ SHA_LONG Nl,Nh; ++ SHA_LONG data[SHA_LBLOCK]; ++ unsigned int num,md_len; ++ } SHA256_CTX; ++ ++#ifndef OPENSSL_NO_SHA256 ++int SHA224_Init(SHA256_CTX *c); ++int SHA224_Update(SHA256_CTX *c, const void *data, size_t len); ++int SHA224_Final(unsigned char *md, SHA256_CTX *c); ++unsigned char *SHA224(const unsigned char *d, size_t n,unsigned char *md); ++int SHA256_Init(SHA256_CTX *c); ++int SHA256_Update(SHA256_CTX *c, const void *data, size_t len); ++int SHA256_Final(unsigned char *md, SHA256_CTX *c); ++unsigned char *SHA256(const unsigned char *d, size_t n,unsigned char *md); ++void SHA256_Transform(SHA256_CTX *c, const unsigned char *data); ++#endif ++ ++#define SHA384_DIGEST_LENGTH 48 ++#define SHA512_DIGEST_LENGTH 64 ++ ++#ifndef OPENSSL_NO_SHA512 ++/* ++ * Unlike 32-bit digest algorithms, SHA-512 *relies* on SHA_LONG64 ++ * being exactly 64-bit wide. See Implementation Notes in sha512.c ++ * for further details. ++ */ ++#define SHA512_CBLOCK (SHA_LBLOCK*8) /* SHA-512 treats input data as a ++ * contiguous array of 64 bit ++ * wide big-endian values. */ ++#if (defined(_WIN32) || defined(_WIN64)) && !defined(__MINGW32__) ++#define SHA_LONG64 unsigned __int64 ++#define U64(C) C##UI64 ++#elif defined(__arch64__) ++#define SHA_LONG64 unsigned long ++#define U64(C) C##UL ++#else ++#define SHA_LONG64 unsigned long long ++#define U64(C) C##ULL ++#endif ++ ++typedef struct SHA512state_st ++ { ++ SHA_LONG64 h[8]; ++ SHA_LONG64 Nl,Nh; ++ union { ++ SHA_LONG64 d[SHA_LBLOCK]; ++ unsigned char p[SHA512_CBLOCK]; ++ } u; ++ unsigned int num,md_len; ++ } SHA512_CTX; ++#endif ++ ++#ifndef OPENSSL_NO_SHA512 ++int SHA384_Init(SHA512_CTX *c); ++int SHA384_Update(SHA512_CTX *c, const void *data, size_t len); ++int SHA384_Final(unsigned char *md, SHA512_CTX *c); ++unsigned char *SHA384(const unsigned char *d, size_t n,unsigned char *md); ++int SHA512_Init(SHA512_CTX *c); ++int SHA512_Update(SHA512_CTX *c, const void *data, size_t len); ++int SHA512_Final(unsigned char *md, SHA512_CTX *c); ++unsigned char *SHA512(const unsigned char *d, size_t n,unsigned char *md); ++void SHA512_Transform(SHA512_CTX *c, const unsigned char *data); ++#endif ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff -urN qt.orig/include/openssl/ssl.h qt.patched/include/openssl/ssl.h +--- qt.orig/include/openssl/ssl.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/ssl.h 2010-08-27 12:01:45.633894700 +0200 +@@ -0,0 +1,2302 @@ ++/* ssl/ssl.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++/* ==================================================================== ++ * Copyright (c) 1998-2007 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * openssl-core@openssl.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.openssl.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++/* ==================================================================== ++ * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. ++ * ECC cipher suite support in OpenSSL originally developed by ++ * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project. ++ */ ++/* ==================================================================== ++ * Copyright 2005 Nokia. All rights reserved. ++ * ++ * The portions of the attached software ("Contribution") is developed by ++ * Nokia Corporation and is licensed pursuant to the OpenSSL open source ++ * license. ++ * ++ * The Contribution, originally written by Mika Kousa and Pasi Eronen of ++ * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites ++ * support (see RFC 4279) to OpenSSL. ++ * ++ * No patent licenses or other rights except those expressly stated in ++ * the OpenSSL open source license shall be deemed granted or received ++ * expressly, by implication, estoppel, or otherwise. ++ * ++ * No assurances are provided by Nokia that the Contribution does not ++ * infringe the patent or other intellectual property rights of any third ++ * party or that the license provides you with all the necessary rights ++ * to make use of the Contribution. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN ++ * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA ++ * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY ++ * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR ++ * OTHERWISE. ++ */ ++ ++#ifndef HEADER_SSL_H ++#define HEADER_SSL_H ++ ++#include ++ ++#ifndef OPENSSL_NO_COMP ++#include ++#endif ++#ifndef OPENSSL_NO_BIO ++#include ++#endif ++#ifndef OPENSSL_NO_DEPRECATED ++#ifndef OPENSSL_NO_X509 ++#include ++#endif ++#include ++#include ++#include ++#endif ++#include ++#include ++ ++#include ++#include ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* SSLeay version number for ASN.1 encoding of the session information */ ++/* Version 0 - initial version ++ * Version 1 - added the optional peer certificate ++ */ ++#define SSL_SESSION_ASN1_VERSION 0x0001 ++ ++/* text strings for the ciphers */ ++#define SSL_TXT_NULL_WITH_MD5 SSL2_TXT_NULL_WITH_MD5 ++#define SSL_TXT_RC4_128_WITH_MD5 SSL2_TXT_RC4_128_WITH_MD5 ++#define SSL_TXT_RC4_128_EXPORT40_WITH_MD5 SSL2_TXT_RC4_128_EXPORT40_WITH_MD5 ++#define SSL_TXT_RC2_128_CBC_WITH_MD5 SSL2_TXT_RC2_128_CBC_WITH_MD5 ++#define SSL_TXT_RC2_128_CBC_EXPORT40_WITH_MD5 SSL2_TXT_RC2_128_CBC_EXPORT40_WITH_MD5 ++#define SSL_TXT_IDEA_128_CBC_WITH_MD5 SSL2_TXT_IDEA_128_CBC_WITH_MD5 ++#define SSL_TXT_DES_64_CBC_WITH_MD5 SSL2_TXT_DES_64_CBC_WITH_MD5 ++#define SSL_TXT_DES_64_CBC_WITH_SHA SSL2_TXT_DES_64_CBC_WITH_SHA ++#define SSL_TXT_DES_192_EDE3_CBC_WITH_MD5 SSL2_TXT_DES_192_EDE3_CBC_WITH_MD5 ++#define SSL_TXT_DES_192_EDE3_CBC_WITH_SHA SSL2_TXT_DES_192_EDE3_CBC_WITH_SHA ++ ++/* VRS Additional Kerberos5 entries ++ */ ++#define SSL_TXT_KRB5_DES_64_CBC_SHA SSL3_TXT_KRB5_DES_64_CBC_SHA ++#define SSL_TXT_KRB5_DES_192_CBC3_SHA SSL3_TXT_KRB5_DES_192_CBC3_SHA ++#define SSL_TXT_KRB5_RC4_128_SHA SSL3_TXT_KRB5_RC4_128_SHA ++#define SSL_TXT_KRB5_IDEA_128_CBC_SHA SSL3_TXT_KRB5_IDEA_128_CBC_SHA ++#define SSL_TXT_KRB5_DES_64_CBC_MD5 SSL3_TXT_KRB5_DES_64_CBC_MD5 ++#define SSL_TXT_KRB5_DES_192_CBC3_MD5 SSL3_TXT_KRB5_DES_192_CBC3_MD5 ++#define SSL_TXT_KRB5_RC4_128_MD5 SSL3_TXT_KRB5_RC4_128_MD5 ++#define SSL_TXT_KRB5_IDEA_128_CBC_MD5 SSL3_TXT_KRB5_IDEA_128_CBC_MD5 ++ ++#define SSL_TXT_KRB5_DES_40_CBC_SHA SSL3_TXT_KRB5_DES_40_CBC_SHA ++#define SSL_TXT_KRB5_RC2_40_CBC_SHA SSL3_TXT_KRB5_RC2_40_CBC_SHA ++#define SSL_TXT_KRB5_RC4_40_SHA SSL3_TXT_KRB5_RC4_40_SHA ++#define SSL_TXT_KRB5_DES_40_CBC_MD5 SSL3_TXT_KRB5_DES_40_CBC_MD5 ++#define SSL_TXT_KRB5_RC2_40_CBC_MD5 SSL3_TXT_KRB5_RC2_40_CBC_MD5 ++#define SSL_TXT_KRB5_RC4_40_MD5 SSL3_TXT_KRB5_RC4_40_MD5 ++ ++#define SSL_TXT_KRB5_DES_40_CBC_SHA SSL3_TXT_KRB5_DES_40_CBC_SHA ++#define SSL_TXT_KRB5_DES_40_CBC_MD5 SSL3_TXT_KRB5_DES_40_CBC_MD5 ++#define SSL_TXT_KRB5_DES_64_CBC_SHA SSL3_TXT_KRB5_DES_64_CBC_SHA ++#define SSL_TXT_KRB5_DES_64_CBC_MD5 SSL3_TXT_KRB5_DES_64_CBC_MD5 ++#define SSL_TXT_KRB5_DES_192_CBC3_SHA SSL3_TXT_KRB5_DES_192_CBC3_SHA ++#define SSL_TXT_KRB5_DES_192_CBC3_MD5 SSL3_TXT_KRB5_DES_192_CBC3_MD5 ++#define SSL_MAX_KRB5_PRINCIPAL_LENGTH 256 ++ ++#define SSL_MAX_SSL_SESSION_ID_LENGTH 32 ++#define SSL_MAX_SID_CTX_LENGTH 32 ++ ++#define SSL_MIN_RSA_MODULUS_LENGTH_IN_BYTES (512/8) ++#define SSL_MAX_KEY_ARG_LENGTH 8 ++#define SSL_MAX_MASTER_KEY_LENGTH 48 ++ ++ ++/* These are used to specify which ciphers to use and not to use */ ++ ++#define SSL_TXT_EXP40 "EXPORT40" ++#define SSL_TXT_EXP56 "EXPORT56" ++#define SSL_TXT_LOW "LOW" ++#define SSL_TXT_MEDIUM "MEDIUM" ++#define SSL_TXT_HIGH "HIGH" ++#define SSL_TXT_FIPS "FIPS" ++ ++#define SSL_TXT_kFZA "kFZA" /* unused! */ ++#define SSL_TXT_aFZA "aFZA" /* unused! */ ++#define SSL_TXT_eFZA "eFZA" /* unused! */ ++#define SSL_TXT_FZA "FZA" /* unused! */ ++ ++#define SSL_TXT_aNULL "aNULL" ++#define SSL_TXT_eNULL "eNULL" ++#define SSL_TXT_NULL "NULL" ++ ++#define SSL_TXT_kRSA "kRSA" ++#define SSL_TXT_kDHr "kDHr" /* no such ciphersuites supported! */ ++#define SSL_TXT_kDHd "kDHd" /* no such ciphersuites supported! */ ++#define SSL_TXT_kDH "kDH" /* no such ciphersuites supported! */ ++#define SSL_TXT_kEDH "kEDH" ++#define SSL_TXT_kKRB5 "kKRB5" ++#define SSL_TXT_kECDHr "kECDHr" ++#define SSL_TXT_kECDHe "kECDHe" ++#define SSL_TXT_kECDH "kECDH" ++#define SSL_TXT_kEECDH "kEECDH" ++#define SSL_TXT_kPSK "kPSK" ++#define SSL_TXT_kGOST "kGOST" ++ ++#define SSL_TXT_aRSA "aRSA" ++#define SSL_TXT_aDSS "aDSS" ++#define SSL_TXT_aDH "aDH" /* no such ciphersuites supported! */ ++#define SSL_TXT_aECDH "aECDH" ++#define SSL_TXT_aKRB5 "aKRB5" ++#define SSL_TXT_aECDSA "aECDSA" ++#define SSL_TXT_aPSK "aPSK" ++#define SSL_TXT_aGOST94 "aGOST94" ++#define SSL_TXT_aGOST01 "aGOST01" ++#define SSL_TXT_aGOST "aGOST" ++ ++#define SSL_TXT_DSS "DSS" ++#define SSL_TXT_DH "DH" ++#define SSL_TXT_EDH "EDH" /* same as "kEDH:-ADH" */ ++#define SSL_TXT_ADH "ADH" ++#define SSL_TXT_RSA "RSA" ++#define SSL_TXT_ECDH "ECDH" ++#define SSL_TXT_EECDH "EECDH" /* same as "kEECDH:-AECDH" */ ++#define SSL_TXT_AECDH "AECDH" ++#define SSL_TXT_ECDSA "ECDSA" ++#define SSL_TXT_KRB5 "KRB5" ++#define SSL_TXT_PSK "PSK" ++ ++#define SSL_TXT_DES "DES" ++#define SSL_TXT_3DES "3DES" ++#define SSL_TXT_RC4 "RC4" ++#define SSL_TXT_RC2 "RC2" ++#define SSL_TXT_IDEA "IDEA" ++#define SSL_TXT_SEED "SEED" ++#define SSL_TXT_AES128 "AES128" ++#define SSL_TXT_AES256 "AES256" ++#define SSL_TXT_AES "AES" ++#define SSL_TXT_CAMELLIA128 "CAMELLIA128" ++#define SSL_TXT_CAMELLIA256 "CAMELLIA256" ++#define SSL_TXT_CAMELLIA "CAMELLIA" ++ ++#define SSL_TXT_MD5 "MD5" ++#define SSL_TXT_SHA1 "SHA1" ++#define SSL_TXT_SHA "SHA" /* same as "SHA1" */ ++#define SSL_TXT_GOST94 "GOST94" ++#define SSL_TXT_GOST89MAC "GOST89MAC" ++ ++#define SSL_TXT_SSLV2 "SSLv2" ++#define SSL_TXT_SSLV3 "SSLv3" ++#define SSL_TXT_TLSV1 "TLSv1" ++ ++#define SSL_TXT_EXP "EXP" ++#define SSL_TXT_EXPORT "EXPORT" ++ ++#define SSL_TXT_ALL "ALL" ++ ++/* ++ * COMPLEMENTOF* definitions. These identifiers are used to (de-select) ++ * ciphers normally not being used. ++ * Example: "RC4" will activate all ciphers using RC4 including ciphers ++ * without authentication, which would normally disabled by DEFAULT (due ++ * the "!ADH" being part of default). Therefore "RC4:!COMPLEMENTOFDEFAULT" ++ * will make sure that it is also disabled in the specific selection. ++ * COMPLEMENTOF* identifiers are portable between version, as adjustments ++ * to the default cipher setup will also be included here. ++ * ++ * COMPLEMENTOFDEFAULT does not experience the same special treatment that ++ * DEFAULT gets, as only selection is being done and no sorting as needed ++ * for DEFAULT. ++ */ ++#define SSL_TXT_CMPALL "COMPLEMENTOFALL" ++#define SSL_TXT_CMPDEF "COMPLEMENTOFDEFAULT" ++ ++/* The following cipher list is used by default. ++ * It also is substituted when an application-defined cipher list string ++ * starts with 'DEFAULT'. */ ++#define SSL_DEFAULT_CIPHER_LIST "ALL:!aNULL:!eNULL:!SSLv2" ++/* As of OpenSSL 1.0.0, ssl_create_cipher_list() in ssl/ssl_ciph.c always ++ * starts with a reasonable order, and all we have to do for DEFAULT is ++ * throwing out anonymous and unencrypted ciphersuites! ++ * (The latter are not actually enabled by ALL, but "ALL:RSA" would enable ++ * some of them.) ++ */ ++ ++/* Used in SSL_set_shutdown()/SSL_get_shutdown(); */ ++#define SSL_SENT_SHUTDOWN 1 ++#define SSL_RECEIVED_SHUTDOWN 2 ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#if (defined(OPENSSL_NO_RSA) || defined(OPENSSL_NO_MD5)) && !defined(OPENSSL_NO_SSL2) ++#define OPENSSL_NO_SSL2 ++#endif ++ ++#define SSL_FILETYPE_ASN1 X509_FILETYPE_ASN1 ++#define SSL_FILETYPE_PEM X509_FILETYPE_PEM ++ ++/* This is needed to stop compilers complaining about the ++ * 'struct ssl_st *' function parameters used to prototype callbacks ++ * in SSL_CTX. */ ++typedef struct ssl_st *ssl_crock_st; ++typedef struct tls_session_ticket_ext_st TLS_SESSION_TICKET_EXT; ++ ++/* used to hold info on the particular ciphers used */ ++typedef struct ssl_cipher_st ++ { ++ int valid; ++ const char *name; /* text name */ ++ unsigned long id; /* id, 4 bytes, first is version */ ++ ++ /* changed in 0.9.9: these four used to be portions of a single value 'algorithms' */ ++ unsigned long algorithm_mkey; /* key exchange algorithm */ ++ unsigned long algorithm_auth; /* server authentication */ ++ unsigned long algorithm_enc; /* symmetric encryption */ ++ unsigned long algorithm_mac; /* symmetric authentication */ ++ unsigned long algorithm_ssl; /* (major) protocol version */ ++ ++ unsigned long algo_strength; /* strength and export flags */ ++ unsigned long algorithm2; /* Extra flags */ ++ int strength_bits; /* Number of bits really used */ ++ int alg_bits; /* Number of bits for algorithm */ ++ } SSL_CIPHER; ++ ++DECLARE_STACK_OF(SSL_CIPHER) ++ ++typedef int (*tls_session_ticket_ext_cb_fn)(SSL *s, const unsigned char *data, int len, void *arg); ++typedef int (*tls_session_secret_cb_fn)(SSL *s, void *secret, int *secret_len, STACK_OF(SSL_CIPHER) *peer_ciphers, SSL_CIPHER **cipher, void *arg); ++ ++/* Used to hold functions for SSLv2 or SSLv3/TLSv1 functions */ ++typedef struct ssl_method_st ++ { ++ int version; ++ int (*ssl_new)(SSL *s); ++ void (*ssl_clear)(SSL *s); ++ void (*ssl_free)(SSL *s); ++ int (*ssl_accept)(SSL *s); ++ int (*ssl_connect)(SSL *s); ++ int (*ssl_read)(SSL *s,void *buf,int len); ++ int (*ssl_peek)(SSL *s,void *buf,int len); ++ int (*ssl_write)(SSL *s,const void *buf,int len); ++ int (*ssl_shutdown)(SSL *s); ++ int (*ssl_renegotiate)(SSL *s); ++ int (*ssl_renegotiate_check)(SSL *s); ++ long (*ssl_get_message)(SSL *s, int st1, int stn, int mt, long ++ max, int *ok); ++ int (*ssl_read_bytes)(SSL *s, int type, unsigned char *buf, int len, ++ int peek); ++ int (*ssl_write_bytes)(SSL *s, int type, const void *buf_, int len); ++ int (*ssl_dispatch_alert)(SSL *s); ++ long (*ssl_ctrl)(SSL *s,int cmd,long larg,void *parg); ++ long (*ssl_ctx_ctrl)(SSL_CTX *ctx,int cmd,long larg,void *parg); ++ const SSL_CIPHER *(*get_cipher_by_char)(const unsigned char *ptr); ++ int (*put_cipher_by_char)(const SSL_CIPHER *cipher,unsigned char *ptr); ++ int (*ssl_pending)(const SSL *s); ++ int (*num_ciphers)(void); ++ const SSL_CIPHER *(*get_cipher)(unsigned ncipher); ++ const struct ssl_method_st *(*get_ssl_method)(int version); ++ long (*get_timeout)(void); ++ struct ssl3_enc_method *ssl3_enc; /* Extra SSLv3/TLS stuff */ ++ int (*ssl_version)(void); ++ long (*ssl_callback_ctrl)(SSL *s, int cb_id, void (*fp)(void)); ++ long (*ssl_ctx_callback_ctrl)(SSL_CTX *s, int cb_id, void (*fp)(void)); ++ } SSL_METHOD; ++ ++/* Lets make this into an ASN.1 type structure as follows ++ * SSL_SESSION_ID ::= SEQUENCE { ++ * version INTEGER, -- structure version number ++ * SSLversion INTEGER, -- SSL version number ++ * Cipher OCTET STRING, -- the 3 byte cipher ID ++ * Session_ID OCTET STRING, -- the Session ID ++ * Master_key OCTET STRING, -- the master key ++ * KRB5_principal OCTET STRING -- optional Kerberos principal ++ * Key_Arg [ 0 ] IMPLICIT OCTET STRING, -- the optional Key argument ++ * Time [ 1 ] EXPLICIT INTEGER, -- optional Start Time ++ * Timeout [ 2 ] EXPLICIT INTEGER, -- optional Timeout ins seconds ++ * Peer [ 3 ] EXPLICIT X509, -- optional Peer Certificate ++ * Session_ID_context [ 4 ] EXPLICIT OCTET STRING, -- the Session ID context ++ * Verify_result [ 5 ] EXPLICIT INTEGER, -- X509_V_... code for `Peer' ++ * HostName [ 6 ] EXPLICIT OCTET STRING, -- optional HostName from servername TLS extension ++ * ECPointFormatList [ 7 ] OCTET STRING, -- optional EC point format list from TLS extension ++ * PSK_identity_hint [ 8 ] EXPLICIT OCTET STRING, -- optional PSK identity hint ++ * PSK_identity [ 9 ] EXPLICIT OCTET STRING -- optional PSK identity ++ * } ++ * Look in ssl/ssl_asn1.c for more details ++ * I'm using EXPLICIT tags so I can read the damn things using asn1parse :-). ++ */ ++typedef struct ssl_session_st ++ { ++ int ssl_version; /* what ssl version session info is ++ * being kept in here? */ ++ ++ /* only really used in SSLv2 */ ++ unsigned int key_arg_length; ++ unsigned char key_arg[SSL_MAX_KEY_ARG_LENGTH]; ++ int master_key_length; ++ unsigned char master_key[SSL_MAX_MASTER_KEY_LENGTH]; ++ /* session_id - valid? */ ++ unsigned int session_id_length; ++ unsigned char session_id[SSL_MAX_SSL_SESSION_ID_LENGTH]; ++ /* this is used to determine whether the session is being reused in ++ * the appropriate context. It is up to the application to set this, ++ * via SSL_new */ ++ unsigned int sid_ctx_length; ++ unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH]; ++ ++#ifndef OPENSSL_NO_KRB5 ++ unsigned int krb5_client_princ_len; ++ unsigned char krb5_client_princ[SSL_MAX_KRB5_PRINCIPAL_LENGTH]; ++#endif /* OPENSSL_NO_KRB5 */ ++#ifndef OPENSSL_NO_PSK ++ char *psk_identity_hint; ++ char *psk_identity; ++#endif ++ int not_resumable; ++ ++ /* The cert is the certificate used to establish this connection */ ++ struct sess_cert_st /* SESS_CERT */ *sess_cert; ++ ++ /* This is the cert for the other end. ++ * On clients, it will be the same as sess_cert->peer_key->x509 ++ * (the latter is not enough as sess_cert is not retained ++ * in the external representation of sessions, see ssl_asn1.c). */ ++ X509 *peer; ++ /* when app_verify_callback accepts a session where the peer's certificate ++ * is not ok, we must remember the error for session reuse: */ ++ long verify_result; /* only for servers */ ++ ++ int references; ++ long timeout; ++ long time; ++ ++ unsigned int compress_meth; /* Need to lookup the method */ ++ ++ const SSL_CIPHER *cipher; ++ unsigned long cipher_id; /* when ASN.1 loaded, this ++ * needs to be used to load ++ * the 'cipher' structure */ ++ ++ STACK_OF(SSL_CIPHER) *ciphers; /* shared ciphers? */ ++ ++ CRYPTO_EX_DATA ex_data; /* application specific data */ ++ ++ /* These are used to make removal of session-ids more ++ * efficient and to implement a maximum cache size. */ ++ struct ssl_session_st *prev,*next; ++#ifndef OPENSSL_NO_TLSEXT ++ char *tlsext_hostname; ++#ifndef OPENSSL_NO_EC ++ size_t tlsext_ecpointformatlist_length; ++ unsigned char *tlsext_ecpointformatlist; /* peer's list */ ++ size_t tlsext_ellipticcurvelist_length; ++ unsigned char *tlsext_ellipticcurvelist; /* peer's list */ ++#endif /* OPENSSL_NO_EC */ ++ /* RFC4507 info */ ++ unsigned char *tlsext_tick; /* Session ticket */ ++ size_t tlsext_ticklen; /* Session ticket length */ ++ long tlsext_tick_lifetime_hint; /* Session lifetime hint in seconds */ ++#endif ++ } SSL_SESSION; ++ ++ ++#define SSL_OP_MICROSOFT_SESS_ID_BUG 0x00000001L ++#define SSL_OP_NETSCAPE_CHALLENGE_BUG 0x00000002L ++/* Allow initial connection to servers that don't support RI */ ++#define SSL_OP_LEGACY_SERVER_CONNECT 0x00000004L ++#define SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG 0x00000008L ++#define SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG 0x00000010L ++#define SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER 0x00000020L ++#define SSL_OP_MSIE_SSLV2_RSA_PADDING 0x00000040L /* no effect since 0.9.7h and 0.9.8b */ ++#define SSL_OP_SSLEAY_080_CLIENT_DH_BUG 0x00000080L ++#define SSL_OP_TLS_D5_BUG 0x00000100L ++#define SSL_OP_TLS_BLOCK_PADDING_BUG 0x00000200L ++ ++/* Disable SSL 3.0/TLS 1.0 CBC vulnerability workaround that was added ++ * in OpenSSL 0.9.6d. Usually (depending on the application protocol) ++ * the workaround is not needed. Unfortunately some broken SSL/TLS ++ * implementations cannot handle it at all, which is why we include ++ * it in SSL_OP_ALL. */ ++#define SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS 0x00000800L /* added in 0.9.6e */ ++ ++/* SSL_OP_ALL: various bug workarounds that should be rather harmless. ++ * This used to be 0x000FFFFFL before 0.9.7. */ ++#define SSL_OP_ALL 0x80000FFFL ++ ++/* DTLS options */ ++#define SSL_OP_NO_QUERY_MTU 0x00001000L ++/* Turn on Cookie Exchange (on relevant for servers) */ ++#define SSL_OP_COOKIE_EXCHANGE 0x00002000L ++/* Don't use RFC4507 ticket extension */ ++#define SSL_OP_NO_TICKET 0x00004000L ++/* Use Cisco's "speshul" version of DTLS_BAD_VER (as client) */ ++#define SSL_OP_CISCO_ANYCONNECT 0x00008000L ++ ++/* As server, disallow session resumption on renegotiation */ ++#define SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION 0x00010000L ++/* Don't use compression even if supported */ ++#define SSL_OP_NO_COMPRESSION 0x00020000L ++/* Permit unsafe legacy renegotiation */ ++#define SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION 0x00040000L ++/* If set, always create a new key when using tmp_ecdh parameters */ ++#define SSL_OP_SINGLE_ECDH_USE 0x00080000L ++/* If set, always create a new key when using tmp_dh parameters */ ++#define SSL_OP_SINGLE_DH_USE 0x00100000L ++/* Set to always use the tmp_rsa key when doing RSA operations, ++ * even when this violates protocol specs */ ++#define SSL_OP_EPHEMERAL_RSA 0x00200000L ++/* Set on servers to choose the cipher according to the server's ++ * preferences */ ++#define SSL_OP_CIPHER_SERVER_PREFERENCE 0x00400000L ++/* If set, a server will allow a client to issue a SSLv3.0 version number ++ * as latest version supported in the premaster secret, even when TLSv1.0 ++ * (version 3.1) was announced in the client hello. Normally this is ++ * forbidden to prevent version rollback attacks. */ ++#define SSL_OP_TLS_ROLLBACK_BUG 0x00800000L ++ ++#define SSL_OP_NO_SSLv2 0x01000000L ++#define SSL_OP_NO_SSLv3 0x02000000L ++#define SSL_OP_NO_TLSv1 0x04000000L ++ ++/* The next flag deliberately changes the ciphertest, this is a check ++ * for the PKCS#1 attack */ ++#define SSL_OP_PKCS1_CHECK_1 0x08000000L ++#define SSL_OP_PKCS1_CHECK_2 0x10000000L ++#define SSL_OP_NETSCAPE_CA_DN_BUG 0x20000000L ++#define SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG 0x40000000L ++/* Make server add server-hello extension from early version of ++ * cryptopro draft, when GOST ciphersuite is negotiated. ++ * Required for interoperability with CryptoPro CSP 3.x ++ */ ++#define SSL_OP_CRYPTOPRO_TLSEXT_BUG 0x80000000L ++ ++/* Allow SSL_write(..., n) to return r with 0 < r < n (i.e. report success ++ * when just a single record has been written): */ ++#define SSL_MODE_ENABLE_PARTIAL_WRITE 0x00000001L ++/* Make it possible to retry SSL_write() with changed buffer location ++ * (buffer contents must stay the same!); this is not the default to avoid ++ * the misconception that non-blocking SSL_write() behaves like ++ * non-blocking write(): */ ++#define SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER 0x00000002L ++/* Never bother the application with retries if the transport ++ * is blocking: */ ++#define SSL_MODE_AUTO_RETRY 0x00000004L ++/* Don't attempt to automatically build certificate chain */ ++#define SSL_MODE_NO_AUTO_CHAIN 0x00000008L ++/* Save RAM by releasing read and write buffers when they're empty. (SSL3 and ++ * TLS only.) "Released" buffers are put onto a free-list in the context ++ * or just freed (depending on the context's setting for freelist_max_len). */ ++#define SSL_MODE_RELEASE_BUFFERS 0x00000010L ++ ++/* Note: SSL[_CTX]_set_{options,mode} use |= op on the previous value, ++ * they cannot be used to clear bits. */ ++ ++#define SSL_CTX_set_options(ctx,op) \ ++ SSL_CTX_ctrl((ctx),SSL_CTRL_OPTIONS,(op),NULL) ++#define SSL_CTX_clear_options(ctx,op) \ ++ SSL_CTX_ctrl((ctx),SSL_CTRL_CLEAR_OPTIONS,(op),NULL) ++#define SSL_CTX_get_options(ctx) \ ++ SSL_CTX_ctrl((ctx),SSL_CTRL_OPTIONS,0,NULL) ++#define SSL_set_options(ssl,op) \ ++ SSL_ctrl((ssl),SSL_CTRL_OPTIONS,(op),NULL) ++#define SSL_clear_options(ssl,op) \ ++ SSL_ctrl((ssl),SSL_CTRL_CLEAR_OPTIONS,(op),NULL) ++#define SSL_get_options(ssl) \ ++ SSL_ctrl((ssl),SSL_CTRL_OPTIONS,0,NULL) ++ ++#define SSL_CTX_set_mode(ctx,op) \ ++ SSL_CTX_ctrl((ctx),SSL_CTRL_MODE,(op),NULL) ++#define SSL_CTX_clear_mode(ctx,op) \ ++ SSL_CTX_ctrl((ctx),SSL_CTRL_CLEAR_MODE,(op),NULL) ++#define SSL_CTX_get_mode(ctx) \ ++ SSL_CTX_ctrl((ctx),SSL_CTRL_MODE,0,NULL) ++#define SSL_clear_mode(ssl,op) \ ++ SSL_ctrl((ssl),SSL_CTRL_CLEAR_MODE,(op),NULL) ++#define SSL_set_mode(ssl,op) \ ++ SSL_ctrl((ssl),SSL_CTRL_MODE,(op),NULL) ++#define SSL_get_mode(ssl) \ ++ SSL_ctrl((ssl),SSL_CTRL_MODE,0,NULL) ++#define SSL_set_mtu(ssl, mtu) \ ++ SSL_ctrl((ssl),SSL_CTRL_SET_MTU,(mtu),NULL) ++ ++#define SSL_get_secure_renegotiation_support(ssl) \ ++ SSL_ctrl((ssl), SSL_CTRL_GET_RI_SUPPORT, 0, NULL) ++ ++void SSL_CTX_set_msg_callback(SSL_CTX *ctx, void (*cb)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg)); ++void SSL_set_msg_callback(SSL *ssl, void (*cb)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg)); ++#define SSL_CTX_set_msg_callback_arg(ctx, arg) SSL_CTX_ctrl((ctx), SSL_CTRL_SET_MSG_CALLBACK_ARG, 0, (arg)) ++#define SSL_set_msg_callback_arg(ssl, arg) SSL_ctrl((ssl), SSL_CTRL_SET_MSG_CALLBACK_ARG, 0, (arg)) ++ ++ ++ ++#if defined(OPENSSL_SYS_MSDOS) && !defined(OPENSSL_SYS_WIN32) ++#define SSL_MAX_CERT_LIST_DEFAULT 1024*30 /* 30k max cert list :-) */ ++#else ++#define SSL_MAX_CERT_LIST_DEFAULT 1024*100 /* 100k max cert list :-) */ ++#endif ++ ++#define SSL_SESSION_CACHE_MAX_SIZE_DEFAULT (1024*20) ++ ++/* This callback type is used inside SSL_CTX, SSL, and in the functions that set ++ * them. It is used to override the generation of SSL/TLS session IDs in a ++ * server. Return value should be zero on an error, non-zero to proceed. Also, ++ * callbacks should themselves check if the id they generate is unique otherwise ++ * the SSL handshake will fail with an error - callbacks can do this using the ++ * 'ssl' value they're passed by; ++ * SSL_has_matching_session_id(ssl, id, *id_len) ++ * The length value passed in is set at the maximum size the session ID can be. ++ * In SSLv2 this is 16 bytes, whereas SSLv3/TLSv1 it is 32 bytes. The callback ++ * can alter this length to be less if desired, but under SSLv2 session IDs are ++ * supposed to be fixed at 16 bytes so the id will be padded after the callback ++ * returns in this case. It is also an error for the callback to set the size to ++ * zero. */ ++typedef int (*GEN_SESSION_CB)(const SSL *ssl, unsigned char *id, ++ unsigned int *id_len); ++ ++typedef struct ssl_comp_st ++ { ++ int id; ++ const char *name; ++#ifndef OPENSSL_NO_COMP ++ COMP_METHOD *method; ++#else ++ char *method; ++#endif ++ } SSL_COMP; ++ ++DECLARE_STACK_OF(SSL_COMP) ++DECLARE_LHASH_OF(SSL_SESSION); ++ ++struct ssl_ctx_st ++ { ++ const SSL_METHOD *method; ++ ++ STACK_OF(SSL_CIPHER) *cipher_list; ++ /* same as above but sorted for lookup */ ++ STACK_OF(SSL_CIPHER) *cipher_list_by_id; ++ ++ struct x509_store_st /* X509_STORE */ *cert_store; ++ LHASH_OF(SSL_SESSION) *sessions; ++ /* Most session-ids that will be cached, default is ++ * SSL_SESSION_CACHE_MAX_SIZE_DEFAULT. 0 is unlimited. */ ++ unsigned long session_cache_size; ++ struct ssl_session_st *session_cache_head; ++ struct ssl_session_st *session_cache_tail; ++ ++ /* This can have one of 2 values, ored together, ++ * SSL_SESS_CACHE_CLIENT, ++ * SSL_SESS_CACHE_SERVER, ++ * Default is SSL_SESSION_CACHE_SERVER, which means only ++ * SSL_accept which cache SSL_SESSIONS. */ ++ int session_cache_mode; ++ ++ /* If timeout is not 0, it is the default timeout value set ++ * when SSL_new() is called. This has been put in to make ++ * life easier to set things up */ ++ long session_timeout; ++ ++ /* If this callback is not null, it will be called each ++ * time a session id is added to the cache. If this function ++ * returns 1, it means that the callback will do a ++ * SSL_SESSION_free() when it has finished using it. Otherwise, ++ * on 0, it means the callback has finished with it. ++ * If remove_session_cb is not null, it will be called when ++ * a session-id is removed from the cache. After the call, ++ * OpenSSL will SSL_SESSION_free() it. */ ++ int (*new_session_cb)(struct ssl_st *ssl,SSL_SESSION *sess); ++ void (*remove_session_cb)(struct ssl_ctx_st *ctx,SSL_SESSION *sess); ++ SSL_SESSION *(*get_session_cb)(struct ssl_st *ssl, ++ unsigned char *data,int len,int *copy); ++ ++ struct ++ { ++ int sess_connect; /* SSL new conn - started */ ++ int sess_connect_renegotiate;/* SSL reneg - requested */ ++ int sess_connect_good; /* SSL new conne/reneg - finished */ ++ int sess_accept; /* SSL new accept - started */ ++ int sess_accept_renegotiate;/* SSL reneg - requested */ ++ int sess_accept_good; /* SSL accept/reneg - finished */ ++ int sess_miss; /* session lookup misses */ ++ int sess_timeout; /* reuse attempt on timeouted session */ ++ int sess_cache_full; /* session removed due to full cache */ ++ int sess_hit; /* session reuse actually done */ ++ int sess_cb_hit; /* session-id that was not ++ * in the cache was ++ * passed back via the callback. This ++ * indicates that the application is ++ * supplying session-id's from other ++ * processes - spooky :-) */ ++ } stats; ++ ++ int references; ++ ++ /* if defined, these override the X509_verify_cert() calls */ ++ int (*app_verify_callback)(X509_STORE_CTX *, void *); ++ void *app_verify_arg; ++ /* before OpenSSL 0.9.7, 'app_verify_arg' was ignored ++ * ('app_verify_callback' was called with just one argument) */ ++ ++ /* Default password callback. */ ++ pem_password_cb *default_passwd_callback; ++ ++ /* Default password callback user data. */ ++ void *default_passwd_callback_userdata; ++ ++ /* get client cert callback */ ++ int (*client_cert_cb)(SSL *ssl, X509 **x509, EVP_PKEY **pkey); ++ ++ /* cookie generate callback */ ++ int (*app_gen_cookie_cb)(SSL *ssl, unsigned char *cookie, ++ unsigned int *cookie_len); ++ ++ /* verify cookie callback */ ++ int (*app_verify_cookie_cb)(SSL *ssl, unsigned char *cookie, ++ unsigned int cookie_len); ++ ++ CRYPTO_EX_DATA ex_data; ++ ++ const EVP_MD *rsa_md5;/* For SSLv2 - name is 'ssl2-md5' */ ++ const EVP_MD *md5; /* For SSLv3/TLSv1 'ssl3-md5' */ ++ const EVP_MD *sha1; /* For SSLv3/TLSv1 'ssl3->sha1' */ ++ ++ STACK_OF(X509) *extra_certs; ++ STACK_OF(SSL_COMP) *comp_methods; /* stack of SSL_COMP, SSLv3/TLSv1 */ ++ ++ ++ /* Default values used when no per-SSL value is defined follow */ ++ ++ void (*info_callback)(const SSL *ssl,int type,int val); /* used if SSL's info_callback is NULL */ ++ ++ /* what we put in client cert requests */ ++ STACK_OF(X509_NAME) *client_CA; ++ ++ ++ /* Default values to use in SSL structures follow (these are copied by SSL_new) */ ++ ++ unsigned long options; ++ unsigned long mode; ++ long max_cert_list; ++ ++ struct cert_st /* CERT */ *cert; ++ int read_ahead; ++ ++ /* callback that allows applications to peek at protocol messages */ ++ void (*msg_callback)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg); ++ void *msg_callback_arg; ++ ++ int verify_mode; ++ unsigned int sid_ctx_length; ++ unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH]; ++ int (*default_verify_callback)(int ok,X509_STORE_CTX *ctx); /* called 'verify_callback' in the SSL */ ++ ++ /* Default generate session ID callback. */ ++ GEN_SESSION_CB generate_session_id; ++ ++ X509_VERIFY_PARAM *param; ++ ++#if 0 ++ int purpose; /* Purpose setting */ ++ int trust; /* Trust setting */ ++#endif ++ ++ int quiet_shutdown; ++ ++ /* Maximum amount of data to send in one fragment. ++ * actual record size can be more than this due to ++ * padding and MAC overheads. ++ */ ++ unsigned int max_send_fragment; ++ ++#ifndef OPENSSL_ENGINE ++ /* Engine to pass requests for client certs to ++ */ ++ ENGINE *client_cert_engine; ++#endif ++ ++#ifndef OPENSSL_NO_TLSEXT ++ /* TLS extensions servername callback */ ++ int (*tlsext_servername_callback)(SSL*, int *, void *); ++ void *tlsext_servername_arg; ++ /* RFC 4507 session ticket keys */ ++ unsigned char tlsext_tick_key_name[16]; ++ unsigned char tlsext_tick_hmac_key[16]; ++ unsigned char tlsext_tick_aes_key[16]; ++ /* Callback to support customisation of ticket key setting */ ++ int (*tlsext_ticket_key_cb)(SSL *ssl, ++ unsigned char *name, unsigned char *iv, ++ EVP_CIPHER_CTX *ectx, ++ HMAC_CTX *hctx, int enc); ++ ++ /* certificate status request info */ ++ /* Callback for status request */ ++ int (*tlsext_status_cb)(SSL *ssl, void *arg); ++ void *tlsext_status_arg; ++ ++ /* draft-rescorla-tls-opaque-prf-input-00.txt information */ ++ int (*tlsext_opaque_prf_input_callback)(SSL *, void *peerinput, size_t len, void *arg); ++ void *tlsext_opaque_prf_input_callback_arg; ++#endif ++ ++#ifndef OPENSSL_NO_PSK ++ char *psk_identity_hint; ++ unsigned int (*psk_client_callback)(SSL *ssl, const char *hint, char *identity, ++ unsigned int max_identity_len, unsigned char *psk, ++ unsigned int max_psk_len); ++ unsigned int (*psk_server_callback)(SSL *ssl, const char *identity, ++ unsigned char *psk, unsigned int max_psk_len); ++#endif ++ ++#ifndef OPENSSL_NO_BUF_FREELISTS ++#define SSL_MAX_BUF_FREELIST_LEN_DEFAULT 32 ++ unsigned int freelist_max_len; ++ struct ssl3_buf_freelist_st *wbuf_freelist; ++ struct ssl3_buf_freelist_st *rbuf_freelist; ++#endif ++ }; ++ ++#define SSL_SESS_CACHE_OFF 0x0000 ++#define SSL_SESS_CACHE_CLIENT 0x0001 ++#define SSL_SESS_CACHE_SERVER 0x0002 ++#define SSL_SESS_CACHE_BOTH (SSL_SESS_CACHE_CLIENT|SSL_SESS_CACHE_SERVER) ++#define SSL_SESS_CACHE_NO_AUTO_CLEAR 0x0080 ++/* enough comments already ... see SSL_CTX_set_session_cache_mode(3) */ ++#define SSL_SESS_CACHE_NO_INTERNAL_LOOKUP 0x0100 ++#define SSL_SESS_CACHE_NO_INTERNAL_STORE 0x0200 ++#define SSL_SESS_CACHE_NO_INTERNAL \ ++ (SSL_SESS_CACHE_NO_INTERNAL_LOOKUP|SSL_SESS_CACHE_NO_INTERNAL_STORE) ++ ++LHASH_OF(SSL_SESSION) *SSL_CTX_sessions(SSL_CTX *ctx); ++#define SSL_CTX_sess_number(ctx) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_NUMBER,0,NULL) ++#define SSL_CTX_sess_connect(ctx) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT,0,NULL) ++#define SSL_CTX_sess_connect_good(ctx) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT_GOOD,0,NULL) ++#define SSL_CTX_sess_connect_renegotiate(ctx) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT_RENEGOTIATE,0,NULL) ++#define SSL_CTX_sess_accept(ctx) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT,0,NULL) ++#define SSL_CTX_sess_accept_renegotiate(ctx) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT_RENEGOTIATE,0,NULL) ++#define SSL_CTX_sess_accept_good(ctx) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT_GOOD,0,NULL) ++#define SSL_CTX_sess_hits(ctx) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_HIT,0,NULL) ++#define SSL_CTX_sess_cb_hits(ctx) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CB_HIT,0,NULL) ++#define SSL_CTX_sess_misses(ctx) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_MISSES,0,NULL) ++#define SSL_CTX_sess_timeouts(ctx) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_TIMEOUTS,0,NULL) ++#define SSL_CTX_sess_cache_full(ctx) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CACHE_FULL,0,NULL) ++ ++void SSL_CTX_sess_set_new_cb(SSL_CTX *ctx, int (*new_session_cb)(struct ssl_st *ssl,SSL_SESSION *sess)); ++int (*SSL_CTX_sess_get_new_cb(SSL_CTX *ctx))(struct ssl_st *ssl, SSL_SESSION *sess); ++void SSL_CTX_sess_set_remove_cb(SSL_CTX *ctx, void (*remove_session_cb)(struct ssl_ctx_st *ctx,SSL_SESSION *sess)); ++void (*SSL_CTX_sess_get_remove_cb(SSL_CTX *ctx))(struct ssl_ctx_st *ctx, SSL_SESSION *sess); ++void SSL_CTX_sess_set_get_cb(SSL_CTX *ctx, SSL_SESSION *(*get_session_cb)(struct ssl_st *ssl, unsigned char *data,int len,int *copy)); ++SSL_SESSION *(*SSL_CTX_sess_get_get_cb(SSL_CTX *ctx))(struct ssl_st *ssl, unsigned char *Data, int len, int *copy); ++void SSL_CTX_set_info_callback(SSL_CTX *ctx, void (*cb)(const SSL *ssl,int type,int val)); ++void (*SSL_CTX_get_info_callback(SSL_CTX *ctx))(const SSL *ssl,int type,int val); ++void SSL_CTX_set_client_cert_cb(SSL_CTX *ctx, int (*client_cert_cb)(SSL *ssl, X509 **x509, EVP_PKEY **pkey)); ++int (*SSL_CTX_get_client_cert_cb(SSL_CTX *ctx))(SSL *ssl, X509 **x509, EVP_PKEY **pkey); ++#ifndef OPENSSL_NO_ENGINE ++int SSL_CTX_set_client_cert_engine(SSL_CTX *ctx, ENGINE *e); ++#endif ++void SSL_CTX_set_cookie_generate_cb(SSL_CTX *ctx, int (*app_gen_cookie_cb)(SSL *ssl, unsigned char *cookie, unsigned int *cookie_len)); ++void SSL_CTX_set_cookie_verify_cb(SSL_CTX *ctx, int (*app_verify_cookie_cb)(SSL *ssl, unsigned char *cookie, unsigned int cookie_len)); ++ ++#ifndef OPENSSL_NO_PSK ++/* the maximum length of the buffer given to callbacks containing the ++ * resulting identity/psk */ ++#define PSK_MAX_IDENTITY_LEN 128 ++#define PSK_MAX_PSK_LEN 256 ++void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx, ++ unsigned int (*psk_client_callback)(SSL *ssl, const char *hint, ++ char *identity, unsigned int max_identity_len, unsigned char *psk, ++ unsigned int max_psk_len)); ++void SSL_set_psk_client_callback(SSL *ssl, ++ unsigned int (*psk_client_callback)(SSL *ssl, const char *hint, ++ char *identity, unsigned int max_identity_len, unsigned char *psk, ++ unsigned int max_psk_len)); ++void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx, ++ unsigned int (*psk_server_callback)(SSL *ssl, const char *identity, ++ unsigned char *psk, unsigned int max_psk_len)); ++void SSL_set_psk_server_callback(SSL *ssl, ++ unsigned int (*psk_server_callback)(SSL *ssl, const char *identity, ++ unsigned char *psk, unsigned int max_psk_len)); ++int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *identity_hint); ++int SSL_use_psk_identity_hint(SSL *s, const char *identity_hint); ++const char *SSL_get_psk_identity_hint(const SSL *s); ++const char *SSL_get_psk_identity(const SSL *s); ++#endif ++ ++#define SSL_NOTHING 1 ++#define SSL_WRITING 2 ++#define SSL_READING 3 ++#define SSL_X509_LOOKUP 4 ++ ++/* These will only be used when doing non-blocking IO */ ++#define SSL_want_nothing(s) (SSL_want(s) == SSL_NOTHING) ++#define SSL_want_read(s) (SSL_want(s) == SSL_READING) ++#define SSL_want_write(s) (SSL_want(s) == SSL_WRITING) ++#define SSL_want_x509_lookup(s) (SSL_want(s) == SSL_X509_LOOKUP) ++ ++#define SSL_MAC_FLAG_READ_MAC_STREAM 1 ++#define SSL_MAC_FLAG_WRITE_MAC_STREAM 2 ++ ++struct ssl_st ++ { ++ /* protocol version ++ * (one of SSL2_VERSION, SSL3_VERSION, TLS1_VERSION, DTLS1_VERSION) ++ */ ++ int version; ++ int type; /* SSL_ST_CONNECT or SSL_ST_ACCEPT */ ++ ++ const SSL_METHOD *method; /* SSLv3 */ ++ ++ /* There are 2 BIO's even though they are normally both the ++ * same. This is so data can be read and written to different ++ * handlers */ ++ ++#ifndef OPENSSL_NO_BIO ++ BIO *rbio; /* used by SSL_read */ ++ BIO *wbio; /* used by SSL_write */ ++ BIO *bbio; /* used during session-id reuse to concatenate ++ * messages */ ++#else ++ char *rbio; /* used by SSL_read */ ++ char *wbio; /* used by SSL_write */ ++ char *bbio; ++#endif ++ /* This holds a variable that indicates what we were doing ++ * when a 0 or -1 is returned. This is needed for ++ * non-blocking IO so we know what request needs re-doing when ++ * in SSL_accept or SSL_connect */ ++ int rwstate; ++ ++ /* true when we are actually in SSL_accept() or SSL_connect() */ ++ int in_handshake; ++ int (*handshake_func)(SSL *); ++ ++ /* Imagine that here's a boolean member "init" that is ++ * switched as soon as SSL_set_{accept/connect}_state ++ * is called for the first time, so that "state" and ++ * "handshake_func" are properly initialized. But as ++ * handshake_func is == 0 until then, we use this ++ * test instead of an "init" member. ++ */ ++ ++ int server; /* are we the server side? - mostly used by SSL_clear*/ ++ ++ int new_session;/* 1 if we are to use a new session. ++ * 2 if we are a server and are inside a handshake ++ * (i.e. not just sending a HelloRequest) ++ * NB: For servers, the 'new' session may actually be a previously ++ * cached session or even the previous session unless ++ * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION is set */ ++ int quiet_shutdown;/* don't send shutdown packets */ ++ int shutdown; /* we have shut things down, 0x01 sent, 0x02 ++ * for received */ ++ int state; /* where we are */ ++ int rstate; /* where we are when reading */ ++ ++ BUF_MEM *init_buf; /* buffer used during init */ ++ void *init_msg; /* pointer to handshake message body, set by ssl3_get_message() */ ++ int init_num; /* amount read/written */ ++ int init_off; /* amount read/written */ ++ ++ /* used internally to point at a raw packet */ ++ unsigned char *packet; ++ unsigned int packet_length; ++ ++ struct ssl2_state_st *s2; /* SSLv2 variables */ ++ struct ssl3_state_st *s3; /* SSLv3 variables */ ++ struct dtls1_state_st *d1; /* DTLSv1 variables */ ++ ++ int read_ahead; /* Read as many input bytes as possible ++ * (for non-blocking reads) */ ++ ++ /* callback that allows applications to peek at protocol messages */ ++ void (*msg_callback)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg); ++ void *msg_callback_arg; ++ ++ int hit; /* reusing a previous session */ ++ ++ X509_VERIFY_PARAM *param; ++ ++#if 0 ++ int purpose; /* Purpose setting */ ++ int trust; /* Trust setting */ ++#endif ++ ++ /* crypto */ ++ STACK_OF(SSL_CIPHER) *cipher_list; ++ STACK_OF(SSL_CIPHER) *cipher_list_by_id; ++ ++ /* These are the ones being used, the ones in SSL_SESSION are ++ * the ones to be 'copied' into these ones */ ++ int mac_flags; ++ EVP_CIPHER_CTX *enc_read_ctx; /* cryptographic state */ ++ EVP_MD_CTX *read_hash; /* used for mac generation */ ++#ifndef OPENSSL_NO_COMP ++ COMP_CTX *expand; /* uncompress */ ++#else ++ char *expand; ++#endif ++ ++ EVP_CIPHER_CTX *enc_write_ctx; /* cryptographic state */ ++ EVP_MD_CTX *write_hash; /* used for mac generation */ ++#ifndef OPENSSL_NO_COMP ++ COMP_CTX *compress; /* compression */ ++#else ++ char *compress; ++#endif ++ ++ /* session info */ ++ ++ /* client cert? */ ++ /* This is used to hold the server certificate used */ ++ struct cert_st /* CERT */ *cert; ++ ++ /* the session_id_context is used to ensure sessions are only reused ++ * in the appropriate context */ ++ unsigned int sid_ctx_length; ++ unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH]; ++ ++ /* This can also be in the session once a session is established */ ++ SSL_SESSION *session; ++ ++ /* Default generate session ID callback. */ ++ GEN_SESSION_CB generate_session_id; ++ ++ /* Used in SSL2 and SSL3 */ ++ int verify_mode; /* 0 don't care about verify failure. ++ * 1 fail if verify fails */ ++ int (*verify_callback)(int ok,X509_STORE_CTX *ctx); /* fail if callback returns 0 */ ++ ++ void (*info_callback)(const SSL *ssl,int type,int val); /* optional informational callback */ ++ ++ int error; /* error bytes to be written */ ++ int error_code; /* actual code */ ++ ++#ifndef OPENSSL_NO_KRB5 ++ KSSL_CTX *kssl_ctx; /* Kerberos 5 context */ ++#endif /* OPENSSL_NO_KRB5 */ ++ ++#ifndef OPENSSL_NO_PSK ++ unsigned int (*psk_client_callback)(SSL *ssl, const char *hint, char *identity, ++ unsigned int max_identity_len, unsigned char *psk, ++ unsigned int max_psk_len); ++ unsigned int (*psk_server_callback)(SSL *ssl, const char *identity, ++ unsigned char *psk, unsigned int max_psk_len); ++#endif ++ ++ SSL_CTX *ctx; ++ /* set this flag to 1 and a sleep(1) is put into all SSL_read() ++ * and SSL_write() calls, good for nbio debuging :-) */ ++ int debug; ++ ++ /* extra application data */ ++ long verify_result; ++ CRYPTO_EX_DATA ex_data; ++ ++ /* for server side, keep the list of CA_dn we can use */ ++ STACK_OF(X509_NAME) *client_CA; ++ ++ int references; ++ unsigned long options; /* protocol behaviour */ ++ unsigned long mode; /* API behaviour */ ++ long max_cert_list; ++ int first_packet; ++ int client_version; /* what was passed, used for ++ * SSLv3/TLS rollback check */ ++ unsigned int max_send_fragment; ++#ifndef OPENSSL_NO_TLSEXT ++ /* TLS extension debug callback */ ++ void (*tlsext_debug_cb)(SSL *s, int client_server, int type, ++ unsigned char *data, int len, ++ void *arg); ++ void *tlsext_debug_arg; ++ char *tlsext_hostname; ++ int servername_done; /* no further mod of servername ++ 0 : call the servername extension callback. ++ 1 : prepare 2, allow last ack just after in server callback. ++ 2 : don't call servername callback, no ack in server hello ++ */ ++ /* certificate status request info */ ++ /* Status type or -1 if no status type */ ++ int tlsext_status_type; ++ /* Expect OCSP CertificateStatus message */ ++ int tlsext_status_expected; ++ /* OCSP status request only */ ++ STACK_OF(OCSP_RESPID) *tlsext_ocsp_ids; ++ X509_EXTENSIONS *tlsext_ocsp_exts; ++ /* OCSP response received or to be sent */ ++ unsigned char *tlsext_ocsp_resp; ++ int tlsext_ocsp_resplen; ++ ++ /* RFC4507 session ticket expected to be received or sent */ ++ int tlsext_ticket_expected; ++#ifndef OPENSSL_NO_EC ++ size_t tlsext_ecpointformatlist_length; ++ unsigned char *tlsext_ecpointformatlist; /* our list */ ++ size_t tlsext_ellipticcurvelist_length; ++ unsigned char *tlsext_ellipticcurvelist; /* our list */ ++#endif /* OPENSSL_NO_EC */ ++ ++ /* draft-rescorla-tls-opaque-prf-input-00.txt information to be used for handshakes */ ++ void *tlsext_opaque_prf_input; ++ size_t tlsext_opaque_prf_input_len; ++ ++ /* TLS Session Ticket extension override */ ++ TLS_SESSION_TICKET_EXT *tlsext_session_ticket; ++ ++ /* TLS Session Ticket extension callback */ ++ tls_session_ticket_ext_cb_fn tls_session_ticket_ext_cb; ++ void *tls_session_ticket_ext_cb_arg; ++ ++ /* TLS pre-shared secret session resumption */ ++ tls_session_secret_cb_fn tls_session_secret_cb; ++ void *tls_session_secret_cb_arg; ++ ++ SSL_CTX * initial_ctx; /* initial ctx, used to store sessions */ ++#define session_ctx initial_ctx ++#else ++#define session_ctx ctx ++#endif /* OPENSSL_NO_TLSEXT */ ++ }; ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#include ++#include ++#include /* This is mostly sslv3 with a few tweaks */ ++#include /* Datagram TLS */ ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* compatibility */ ++#define SSL_set_app_data(s,arg) (SSL_set_ex_data(s,0,(char *)arg)) ++#define SSL_get_app_data(s) (SSL_get_ex_data(s,0)) ++#define SSL_SESSION_set_app_data(s,a) (SSL_SESSION_set_ex_data(s,0,(char *)a)) ++#define SSL_SESSION_get_app_data(s) (SSL_SESSION_get_ex_data(s,0)) ++#define SSL_CTX_get_app_data(ctx) (SSL_CTX_get_ex_data(ctx,0)) ++#define SSL_CTX_set_app_data(ctx,arg) (SSL_CTX_set_ex_data(ctx,0,(char *)arg)) ++ ++/* The following are the possible values for ssl->state are are ++ * used to indicate where we are up to in the SSL connection establishment. ++ * The macros that follow are about the only things you should need to use ++ * and even then, only when using non-blocking IO. ++ * It can also be useful to work out where you were when the connection ++ * failed */ ++ ++#define SSL_ST_CONNECT 0x1000 ++#define SSL_ST_ACCEPT 0x2000 ++#define SSL_ST_MASK 0x0FFF ++#define SSL_ST_INIT (SSL_ST_CONNECT|SSL_ST_ACCEPT) ++#define SSL_ST_BEFORE 0x4000 ++#define SSL_ST_OK 0x03 ++#define SSL_ST_RENEGOTIATE (0x04|SSL_ST_INIT) ++ ++#define SSL_CB_LOOP 0x01 ++#define SSL_CB_EXIT 0x02 ++#define SSL_CB_READ 0x04 ++#define SSL_CB_WRITE 0x08 ++#define SSL_CB_ALERT 0x4000 /* used in callback */ ++#define SSL_CB_READ_ALERT (SSL_CB_ALERT|SSL_CB_READ) ++#define SSL_CB_WRITE_ALERT (SSL_CB_ALERT|SSL_CB_WRITE) ++#define SSL_CB_ACCEPT_LOOP (SSL_ST_ACCEPT|SSL_CB_LOOP) ++#define SSL_CB_ACCEPT_EXIT (SSL_ST_ACCEPT|SSL_CB_EXIT) ++#define SSL_CB_CONNECT_LOOP (SSL_ST_CONNECT|SSL_CB_LOOP) ++#define SSL_CB_CONNECT_EXIT (SSL_ST_CONNECT|SSL_CB_EXIT) ++#define SSL_CB_HANDSHAKE_START 0x10 ++#define SSL_CB_HANDSHAKE_DONE 0x20 ++ ++/* Is the SSL_connection established? */ ++#define SSL_get_state(a) SSL_state(a) ++#define SSL_is_init_finished(a) (SSL_state(a) == SSL_ST_OK) ++#define SSL_in_init(a) (SSL_state(a)&SSL_ST_INIT) ++#define SSL_in_before(a) (SSL_state(a)&SSL_ST_BEFORE) ++#define SSL_in_connect_init(a) (SSL_state(a)&SSL_ST_CONNECT) ++#define SSL_in_accept_init(a) (SSL_state(a)&SSL_ST_ACCEPT) ++ ++/* The following 2 states are kept in ssl->rstate when reads fail, ++ * you should not need these */ ++#define SSL_ST_READ_HEADER 0xF0 ++#define SSL_ST_READ_BODY 0xF1 ++#define SSL_ST_READ_DONE 0xF2 ++ ++/* Obtain latest Finished message ++ * -- that we sent (SSL_get_finished) ++ * -- that we expected from peer (SSL_get_peer_finished). ++ * Returns length (0 == no Finished so far), copies up to 'count' bytes. */ ++size_t SSL_get_finished(const SSL *s, void *buf, size_t count); ++size_t SSL_get_peer_finished(const SSL *s, void *buf, size_t count); ++ ++/* use either SSL_VERIFY_NONE or SSL_VERIFY_PEER, the last 2 options ++ * are 'ored' with SSL_VERIFY_PEER if they are desired */ ++#define SSL_VERIFY_NONE 0x00 ++#define SSL_VERIFY_PEER 0x01 ++#define SSL_VERIFY_FAIL_IF_NO_PEER_CERT 0x02 ++#define SSL_VERIFY_CLIENT_ONCE 0x04 ++ ++#define OpenSSL_add_ssl_algorithms() SSL_library_init() ++#define SSLeay_add_ssl_algorithms() SSL_library_init() ++ ++/* this is for backward compatibility */ ++#if 0 /* NEW_SSLEAY */ ++#define SSL_CTX_set_default_verify(a,b,c) SSL_CTX_set_verify(a,b,c) ++#define SSL_set_pref_cipher(c,n) SSL_set_cipher_list(c,n) ++#define SSL_add_session(a,b) SSL_CTX_add_session((a),(b)) ++#define SSL_remove_session(a,b) SSL_CTX_remove_session((a),(b)) ++#define SSL_flush_sessions(a,b) SSL_CTX_flush_sessions((a),(b)) ++#endif ++/* More backward compatibility */ ++#define SSL_get_cipher(s) \ ++ SSL_CIPHER_get_name(SSL_get_current_cipher(s)) ++#define SSL_get_cipher_bits(s,np) \ ++ SSL_CIPHER_get_bits(SSL_get_current_cipher(s),np) ++#define SSL_get_cipher_version(s) \ ++ SSL_CIPHER_get_version(SSL_get_current_cipher(s)) ++#define SSL_get_cipher_name(s) \ ++ SSL_CIPHER_get_name(SSL_get_current_cipher(s)) ++#define SSL_get_time(a) SSL_SESSION_get_time(a) ++#define SSL_set_time(a,b) SSL_SESSION_set_time((a),(b)) ++#define SSL_get_timeout(a) SSL_SESSION_get_timeout(a) ++#define SSL_set_timeout(a,b) SSL_SESSION_set_timeout((a),(b)) ++ ++#define d2i_SSL_SESSION_bio(bp,s_id) ASN1_d2i_bio_of(SSL_SESSION,SSL_SESSION_new,d2i_SSL_SESSION,bp,s_id) ++#define i2d_SSL_SESSION_bio(bp,s_id) ASN1_i2d_bio_of(SSL_SESSION,i2d_SSL_SESSION,bp,s_id) ++ ++DECLARE_PEM_rw(SSL_SESSION, SSL_SESSION) ++ ++#define SSL_AD_REASON_OFFSET 1000 /* offset to get SSL_R_... value from SSL_AD_... */ ++ ++/* These alert types are for SSLv3 and TLSv1 */ ++#define SSL_AD_CLOSE_NOTIFY SSL3_AD_CLOSE_NOTIFY ++#define SSL_AD_UNEXPECTED_MESSAGE SSL3_AD_UNEXPECTED_MESSAGE /* fatal */ ++#define SSL_AD_BAD_RECORD_MAC SSL3_AD_BAD_RECORD_MAC /* fatal */ ++#define SSL_AD_DECRYPTION_FAILED TLS1_AD_DECRYPTION_FAILED ++#define SSL_AD_RECORD_OVERFLOW TLS1_AD_RECORD_OVERFLOW ++#define SSL_AD_DECOMPRESSION_FAILURE SSL3_AD_DECOMPRESSION_FAILURE/* fatal */ ++#define SSL_AD_HANDSHAKE_FAILURE SSL3_AD_HANDSHAKE_FAILURE/* fatal */ ++#define SSL_AD_NO_CERTIFICATE SSL3_AD_NO_CERTIFICATE /* Not for TLS */ ++#define SSL_AD_BAD_CERTIFICATE SSL3_AD_BAD_CERTIFICATE ++#define SSL_AD_UNSUPPORTED_CERTIFICATE SSL3_AD_UNSUPPORTED_CERTIFICATE ++#define SSL_AD_CERTIFICATE_REVOKED SSL3_AD_CERTIFICATE_REVOKED ++#define SSL_AD_CERTIFICATE_EXPIRED SSL3_AD_CERTIFICATE_EXPIRED ++#define SSL_AD_CERTIFICATE_UNKNOWN SSL3_AD_CERTIFICATE_UNKNOWN ++#define SSL_AD_ILLEGAL_PARAMETER SSL3_AD_ILLEGAL_PARAMETER /* fatal */ ++#define SSL_AD_UNKNOWN_CA TLS1_AD_UNKNOWN_CA /* fatal */ ++#define SSL_AD_ACCESS_DENIED TLS1_AD_ACCESS_DENIED /* fatal */ ++#define SSL_AD_DECODE_ERROR TLS1_AD_DECODE_ERROR /* fatal */ ++#define SSL_AD_DECRYPT_ERROR TLS1_AD_DECRYPT_ERROR ++#define SSL_AD_EXPORT_RESTRICTION TLS1_AD_EXPORT_RESTRICTION/* fatal */ ++#define SSL_AD_PROTOCOL_VERSION TLS1_AD_PROTOCOL_VERSION /* fatal */ ++#define SSL_AD_INSUFFICIENT_SECURITY TLS1_AD_INSUFFICIENT_SECURITY/* fatal */ ++#define SSL_AD_INTERNAL_ERROR TLS1_AD_INTERNAL_ERROR /* fatal */ ++#define SSL_AD_USER_CANCELLED TLS1_AD_USER_CANCELLED ++#define SSL_AD_NO_RENEGOTIATION TLS1_AD_NO_RENEGOTIATION ++#define SSL_AD_UNSUPPORTED_EXTENSION TLS1_AD_UNSUPPORTED_EXTENSION ++#define SSL_AD_CERTIFICATE_UNOBTAINABLE TLS1_AD_CERTIFICATE_UNOBTAINABLE ++#define SSL_AD_UNRECOGNIZED_NAME TLS1_AD_UNRECOGNIZED_NAME ++#define SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE ++#define SSL_AD_BAD_CERTIFICATE_HASH_VALUE TLS1_AD_BAD_CERTIFICATE_HASH_VALUE ++#define SSL_AD_UNKNOWN_PSK_IDENTITY TLS1_AD_UNKNOWN_PSK_IDENTITY /* fatal */ ++ ++#define SSL_ERROR_NONE 0 ++#define SSL_ERROR_SSL 1 ++#define SSL_ERROR_WANT_READ 2 ++#define SSL_ERROR_WANT_WRITE 3 ++#define SSL_ERROR_WANT_X509_LOOKUP 4 ++#define SSL_ERROR_SYSCALL 5 /* look at error stack/return value/errno */ ++#define SSL_ERROR_ZERO_RETURN 6 ++#define SSL_ERROR_WANT_CONNECT 7 ++#define SSL_ERROR_WANT_ACCEPT 8 ++ ++#define SSL_CTRL_NEED_TMP_RSA 1 ++#define SSL_CTRL_SET_TMP_RSA 2 ++#define SSL_CTRL_SET_TMP_DH 3 ++#define SSL_CTRL_SET_TMP_ECDH 4 ++#define SSL_CTRL_SET_TMP_RSA_CB 5 ++#define SSL_CTRL_SET_TMP_DH_CB 6 ++#define SSL_CTRL_SET_TMP_ECDH_CB 7 ++ ++#define SSL_CTRL_GET_SESSION_REUSED 8 ++#define SSL_CTRL_GET_CLIENT_CERT_REQUEST 9 ++#define SSL_CTRL_GET_NUM_RENEGOTIATIONS 10 ++#define SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS 11 ++#define SSL_CTRL_GET_TOTAL_RENEGOTIATIONS 12 ++#define SSL_CTRL_GET_FLAGS 13 ++#define SSL_CTRL_EXTRA_CHAIN_CERT 14 ++ ++#define SSL_CTRL_SET_MSG_CALLBACK 15 ++#define SSL_CTRL_SET_MSG_CALLBACK_ARG 16 ++ ++/* only applies to datagram connections */ ++#define SSL_CTRL_SET_MTU 17 ++/* Stats */ ++#define SSL_CTRL_SESS_NUMBER 20 ++#define SSL_CTRL_SESS_CONNECT 21 ++#define SSL_CTRL_SESS_CONNECT_GOOD 22 ++#define SSL_CTRL_SESS_CONNECT_RENEGOTIATE 23 ++#define SSL_CTRL_SESS_ACCEPT 24 ++#define SSL_CTRL_SESS_ACCEPT_GOOD 25 ++#define SSL_CTRL_SESS_ACCEPT_RENEGOTIATE 26 ++#define SSL_CTRL_SESS_HIT 27 ++#define SSL_CTRL_SESS_CB_HIT 28 ++#define SSL_CTRL_SESS_MISSES 29 ++#define SSL_CTRL_SESS_TIMEOUTS 30 ++#define SSL_CTRL_SESS_CACHE_FULL 31 ++#define SSL_CTRL_OPTIONS 32 ++#define SSL_CTRL_MODE 33 ++ ++#define SSL_CTRL_GET_READ_AHEAD 40 ++#define SSL_CTRL_SET_READ_AHEAD 41 ++#define SSL_CTRL_SET_SESS_CACHE_SIZE 42 ++#define SSL_CTRL_GET_SESS_CACHE_SIZE 43 ++#define SSL_CTRL_SET_SESS_CACHE_MODE 44 ++#define SSL_CTRL_GET_SESS_CACHE_MODE 45 ++ ++#define SSL_CTRL_GET_MAX_CERT_LIST 50 ++#define SSL_CTRL_SET_MAX_CERT_LIST 51 ++ ++#define SSL_CTRL_SET_MAX_SEND_FRAGMENT 52 ++ ++/* see tls1.h for macros based on these */ ++#ifndef OPENSSL_NO_TLSEXT ++#define SSL_CTRL_SET_TLSEXT_SERVERNAME_CB 53 ++#define SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG 54 ++#define SSL_CTRL_SET_TLSEXT_HOSTNAME 55 ++#define SSL_CTRL_SET_TLSEXT_DEBUG_CB 56 ++#define SSL_CTRL_SET_TLSEXT_DEBUG_ARG 57 ++#define SSL_CTRL_GET_TLSEXT_TICKET_KEYS 58 ++#define SSL_CTRL_SET_TLSEXT_TICKET_KEYS 59 ++#define SSL_CTRL_SET_TLSEXT_OPAQUE_PRF_INPUT 60 ++#define SSL_CTRL_SET_TLSEXT_OPAQUE_PRF_INPUT_CB 61 ++#define SSL_CTRL_SET_TLSEXT_OPAQUE_PRF_INPUT_CB_ARG 62 ++#define SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB 63 ++#define SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB_ARG 64 ++#define SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE 65 ++#define SSL_CTRL_GET_TLSEXT_STATUS_REQ_EXTS 66 ++#define SSL_CTRL_SET_TLSEXT_STATUS_REQ_EXTS 67 ++#define SSL_CTRL_GET_TLSEXT_STATUS_REQ_IDS 68 ++#define SSL_CTRL_SET_TLSEXT_STATUS_REQ_IDS 69 ++#define SSL_CTRL_GET_TLSEXT_STATUS_REQ_OCSP_RESP 70 ++#define SSL_CTRL_SET_TLSEXT_STATUS_REQ_OCSP_RESP 71 ++ ++#define SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB 72 ++#endif ++ ++#define DTLS_CTRL_GET_TIMEOUT 73 ++#define DTLS_CTRL_HANDLE_TIMEOUT 74 ++#define DTLS_CTRL_LISTEN 75 ++ ++#define SSL_CTRL_GET_RI_SUPPORT 76 ++#define SSL_CTRL_CLEAR_OPTIONS 77 ++#define SSL_CTRL_CLEAR_MODE 78 ++ ++#define DTLSv1_get_timeout(ssl, arg) \ ++ SSL_ctrl(ssl,DTLS_CTRL_GET_TIMEOUT,0, (void *)arg) ++#define DTLSv1_handle_timeout(ssl) \ ++ SSL_ctrl(ssl,DTLS_CTRL_HANDLE_TIMEOUT,0, NULL) ++#define DTLSv1_listen(ssl, peer) \ ++ SSL_ctrl(ssl,DTLS_CTRL_LISTEN,0, (void *)peer) ++ ++#define SSL_session_reused(ssl) \ ++ SSL_ctrl((ssl),SSL_CTRL_GET_SESSION_REUSED,0,NULL) ++#define SSL_num_renegotiations(ssl) \ ++ SSL_ctrl((ssl),SSL_CTRL_GET_NUM_RENEGOTIATIONS,0,NULL) ++#define SSL_clear_num_renegotiations(ssl) \ ++ SSL_ctrl((ssl),SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS,0,NULL) ++#define SSL_total_renegotiations(ssl) \ ++ SSL_ctrl((ssl),SSL_CTRL_GET_TOTAL_RENEGOTIATIONS,0,NULL) ++ ++#define SSL_CTX_need_tmp_RSA(ctx) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_NEED_TMP_RSA,0,NULL) ++#define SSL_CTX_set_tmp_rsa(ctx,rsa) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TMP_RSA,0,(char *)rsa) ++#define SSL_CTX_set_tmp_dh(ctx,dh) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TMP_DH,0,(char *)dh) ++#define SSL_CTX_set_tmp_ecdh(ctx,ecdh) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TMP_ECDH,0,(char *)ecdh) ++ ++#define SSL_need_tmp_RSA(ssl) \ ++ SSL_ctrl(ssl,SSL_CTRL_NEED_TMP_RSA,0,NULL) ++#define SSL_set_tmp_rsa(ssl,rsa) \ ++ SSL_ctrl(ssl,SSL_CTRL_SET_TMP_RSA,0,(char *)rsa) ++#define SSL_set_tmp_dh(ssl,dh) \ ++ SSL_ctrl(ssl,SSL_CTRL_SET_TMP_DH,0,(char *)dh) ++#define SSL_set_tmp_ecdh(ssl,ecdh) \ ++ SSL_ctrl(ssl,SSL_CTRL_SET_TMP_ECDH,0,(char *)ecdh) ++ ++#define SSL_CTX_add_extra_chain_cert(ctx,x509) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_EXTRA_CHAIN_CERT,0,(char *)x509) ++ ++#ifndef OPENSSL_NO_BIO ++BIO_METHOD *BIO_f_ssl(void); ++BIO *BIO_new_ssl(SSL_CTX *ctx,int client); ++BIO *BIO_new_ssl_connect(SSL_CTX *ctx); ++BIO *BIO_new_buffer_ssl_connect(SSL_CTX *ctx); ++int BIO_ssl_copy_session_id(BIO *to,BIO *from); ++void BIO_ssl_shutdown(BIO *ssl_bio); ++ ++#endif ++ ++int SSL_CTX_set_cipher_list(SSL_CTX *,const char *str); ++SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth); ++void SSL_CTX_free(SSL_CTX *); ++long SSL_CTX_set_timeout(SSL_CTX *ctx,long t); ++long SSL_CTX_get_timeout(const SSL_CTX *ctx); ++X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *); ++void SSL_CTX_set_cert_store(SSL_CTX *,X509_STORE *); ++int SSL_want(const SSL *s); ++int SSL_clear(SSL *s); ++ ++void SSL_CTX_flush_sessions(SSL_CTX *ctx,long tm); ++ ++const SSL_CIPHER *SSL_get_current_cipher(const SSL *s); ++int SSL_CIPHER_get_bits(const SSL_CIPHER *c,int *alg_bits); ++char * SSL_CIPHER_get_version(const SSL_CIPHER *c); ++const char * SSL_CIPHER_get_name(const SSL_CIPHER *c); ++ ++int SSL_get_fd(const SSL *s); ++int SSL_get_rfd(const SSL *s); ++int SSL_get_wfd(const SSL *s); ++const char * SSL_get_cipher_list(const SSL *s,int n); ++char * SSL_get_shared_ciphers(const SSL *s, char *buf, int len); ++int SSL_get_read_ahead(const SSL * s); ++int SSL_pending(const SSL *s); ++#ifndef OPENSSL_NO_SOCK ++int SSL_set_fd(SSL *s, int fd); ++int SSL_set_rfd(SSL *s, int fd); ++int SSL_set_wfd(SSL *s, int fd); ++#endif ++#ifndef OPENSSL_NO_BIO ++void SSL_set_bio(SSL *s, BIO *rbio,BIO *wbio); ++BIO * SSL_get_rbio(const SSL *s); ++BIO * SSL_get_wbio(const SSL *s); ++#endif ++int SSL_set_cipher_list(SSL *s, const char *str); ++void SSL_set_read_ahead(SSL *s, int yes); ++int SSL_get_verify_mode(const SSL *s); ++int SSL_get_verify_depth(const SSL *s); ++int (*SSL_get_verify_callback(const SSL *s))(int,X509_STORE_CTX *); ++void SSL_set_verify(SSL *s, int mode, ++ int (*callback)(int ok,X509_STORE_CTX *ctx)); ++void SSL_set_verify_depth(SSL *s, int depth); ++#ifndef OPENSSL_NO_RSA ++int SSL_use_RSAPrivateKey(SSL *ssl, RSA *rsa); ++#endif ++int SSL_use_RSAPrivateKey_ASN1(SSL *ssl, unsigned char *d, long len); ++int SSL_use_PrivateKey(SSL *ssl, EVP_PKEY *pkey); ++int SSL_use_PrivateKey_ASN1(int pk,SSL *ssl, const unsigned char *d, long len); ++int SSL_use_certificate(SSL *ssl, X509 *x); ++int SSL_use_certificate_ASN1(SSL *ssl, const unsigned char *d, int len); ++ ++#ifndef OPENSSL_NO_STDIO ++int SSL_use_RSAPrivateKey_file(SSL *ssl, const char *file, int type); ++int SSL_use_PrivateKey_file(SSL *ssl, const char *file, int type); ++int SSL_use_certificate_file(SSL *ssl, const char *file, int type); ++int SSL_CTX_use_RSAPrivateKey_file(SSL_CTX *ctx, const char *file, int type); ++int SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, const char *file, int type); ++int SSL_CTX_use_certificate_file(SSL_CTX *ctx, const char *file, int type); ++int SSL_CTX_use_certificate_chain_file(SSL_CTX *ctx, const char *file); /* PEM type */ ++STACK_OF(X509_NAME) *SSL_load_client_CA_file(const char *file); ++int SSL_add_file_cert_subjects_to_stack(STACK_OF(X509_NAME) *stackCAs, ++ const char *file); ++#ifndef OPENSSL_SYS_VMS ++#ifndef OPENSSL_SYS_MACINTOSH_CLASSIC /* XXXXX: Better scheme needed! [was: #ifndef MAC_OS_pre_X] */ ++int SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) *stackCAs, ++ const char *dir); ++#endif ++#endif ++ ++#endif ++ ++void SSL_load_error_strings(void ); ++const char *SSL_state_string(const SSL *s); ++const char *SSL_rstate_string(const SSL *s); ++const char *SSL_state_string_long(const SSL *s); ++const char *SSL_rstate_string_long(const SSL *s); ++long SSL_SESSION_get_time(const SSL_SESSION *s); ++long SSL_SESSION_set_time(SSL_SESSION *s, long t); ++long SSL_SESSION_get_timeout(const SSL_SESSION *s); ++long SSL_SESSION_set_timeout(SSL_SESSION *s, long t); ++void SSL_copy_session_id(SSL *to,const SSL *from); ++ ++SSL_SESSION *SSL_SESSION_new(void); ++const unsigned char *SSL_SESSION_get_id(const SSL_SESSION *s, ++ unsigned int *len); ++#ifndef OPENSSL_NO_FP_API ++int SSL_SESSION_print_fp(FILE *fp,const SSL_SESSION *ses); ++#endif ++#ifndef OPENSSL_NO_BIO ++int SSL_SESSION_print(BIO *fp,const SSL_SESSION *ses); ++#endif ++void SSL_SESSION_free(SSL_SESSION *ses); ++int i2d_SSL_SESSION(SSL_SESSION *in,unsigned char **pp); ++int SSL_set_session(SSL *to, SSL_SESSION *session); ++int SSL_CTX_add_session(SSL_CTX *s, SSL_SESSION *c); ++int SSL_CTX_remove_session(SSL_CTX *,SSL_SESSION *c); ++int SSL_CTX_set_generate_session_id(SSL_CTX *, GEN_SESSION_CB); ++int SSL_set_generate_session_id(SSL *, GEN_SESSION_CB); ++int SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id, ++ unsigned int id_len); ++SSL_SESSION *d2i_SSL_SESSION(SSL_SESSION **a,const unsigned char **pp, ++ long length); ++ ++#ifdef HEADER_X509_H ++X509 * SSL_get_peer_certificate(const SSL *s); ++#endif ++ ++STACK_OF(X509) *SSL_get_peer_cert_chain(const SSL *s); ++ ++int SSL_CTX_get_verify_mode(const SSL_CTX *ctx); ++int SSL_CTX_get_verify_depth(const SSL_CTX *ctx); ++int (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx))(int,X509_STORE_CTX *); ++void SSL_CTX_set_verify(SSL_CTX *ctx,int mode, ++ int (*callback)(int, X509_STORE_CTX *)); ++void SSL_CTX_set_verify_depth(SSL_CTX *ctx,int depth); ++void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx, int (*cb)(X509_STORE_CTX *,void *), void *arg); ++#ifndef OPENSSL_NO_RSA ++int SSL_CTX_use_RSAPrivateKey(SSL_CTX *ctx, RSA *rsa); ++#endif ++int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX *ctx, const unsigned char *d, long len); ++int SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey); ++int SSL_CTX_use_PrivateKey_ASN1(int pk,SSL_CTX *ctx, ++ const unsigned char *d, long len); ++int SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x); ++int SSL_CTX_use_certificate_ASN1(SSL_CTX *ctx, int len, const unsigned char *d); ++ ++void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb); ++void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx, void *u); ++ ++int SSL_CTX_check_private_key(const SSL_CTX *ctx); ++int SSL_check_private_key(const SSL *ctx); ++ ++int SSL_CTX_set_session_id_context(SSL_CTX *ctx,const unsigned char *sid_ctx, ++ unsigned int sid_ctx_len); ++ ++SSL * SSL_new(SSL_CTX *ctx); ++int SSL_set_session_id_context(SSL *ssl,const unsigned char *sid_ctx, ++ unsigned int sid_ctx_len); ++ ++int SSL_CTX_set_purpose(SSL_CTX *s, int purpose); ++int SSL_set_purpose(SSL *s, int purpose); ++int SSL_CTX_set_trust(SSL_CTX *s, int trust); ++int SSL_set_trust(SSL *s, int trust); ++ ++int SSL_CTX_set1_param(SSL_CTX *ctx, X509_VERIFY_PARAM *vpm); ++int SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm); ++ ++void SSL_free(SSL *ssl); ++int SSL_accept(SSL *ssl); ++int SSL_connect(SSL *ssl); ++int SSL_read(SSL *ssl,void *buf,int num); ++int SSL_peek(SSL *ssl,void *buf,int num); ++int SSL_write(SSL *ssl,const void *buf,int num); ++long SSL_ctrl(SSL *ssl,int cmd, long larg, void *parg); ++long SSL_callback_ctrl(SSL *, int, void (*)(void)); ++long SSL_CTX_ctrl(SSL_CTX *ctx,int cmd, long larg, void *parg); ++long SSL_CTX_callback_ctrl(SSL_CTX *, int, void (*)(void)); ++ ++int SSL_get_error(const SSL *s,int ret_code); ++const char *SSL_get_version(const SSL *s); ++ ++/* This sets the 'default' SSL version that SSL_new() will create */ ++int SSL_CTX_set_ssl_version(SSL_CTX *ctx, const SSL_METHOD *meth); ++ ++#ifndef OPENSSL_NO_SSL2 ++const SSL_METHOD *SSLv2_method(void); /* SSLv2 */ ++const SSL_METHOD *SSLv2_server_method(void); /* SSLv2 */ ++const SSL_METHOD *SSLv2_client_method(void); /* SSLv2 */ ++#endif ++ ++const SSL_METHOD *SSLv3_method(void); /* SSLv3 */ ++const SSL_METHOD *SSLv3_server_method(void); /* SSLv3 */ ++const SSL_METHOD *SSLv3_client_method(void); /* SSLv3 */ ++ ++const SSL_METHOD *SSLv23_method(void); /* SSLv3 but can rollback to v2 */ ++const SSL_METHOD *SSLv23_server_method(void); /* SSLv3 but can rollback to v2 */ ++const SSL_METHOD *SSLv23_client_method(void); /* SSLv3 but can rollback to v2 */ ++ ++const SSL_METHOD *TLSv1_method(void); /* TLSv1.0 */ ++const SSL_METHOD *TLSv1_server_method(void); /* TLSv1.0 */ ++const SSL_METHOD *TLSv1_client_method(void); /* TLSv1.0 */ ++ ++const SSL_METHOD *DTLSv1_method(void); /* DTLSv1.0 */ ++const SSL_METHOD *DTLSv1_server_method(void); /* DTLSv1.0 */ ++const SSL_METHOD *DTLSv1_client_method(void); /* DTLSv1.0 */ ++ ++STACK_OF(SSL_CIPHER) *SSL_get_ciphers(const SSL *s); ++ ++int SSL_do_handshake(SSL *s); ++int SSL_renegotiate(SSL *s); ++int SSL_renegotiate_pending(SSL *s); ++int SSL_shutdown(SSL *s); ++ ++const SSL_METHOD *SSL_get_ssl_method(SSL *s); ++int SSL_set_ssl_method(SSL *s, const SSL_METHOD *method); ++const char *SSL_alert_type_string_long(int value); ++const char *SSL_alert_type_string(int value); ++const char *SSL_alert_desc_string_long(int value); ++const char *SSL_alert_desc_string(int value); ++ ++void SSL_set_client_CA_list(SSL *s, STACK_OF(X509_NAME) *name_list); ++void SSL_CTX_set_client_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list); ++STACK_OF(X509_NAME) *SSL_get_client_CA_list(const SSL *s); ++STACK_OF(X509_NAME) *SSL_CTX_get_client_CA_list(const SSL_CTX *s); ++int SSL_add_client_CA(SSL *ssl,X509 *x); ++int SSL_CTX_add_client_CA(SSL_CTX *ctx,X509 *x); ++ ++void SSL_set_connect_state(SSL *s); ++void SSL_set_accept_state(SSL *s); ++ ++long SSL_get_default_timeout(const SSL *s); ++ ++int SSL_library_init(void ); ++ ++char *SSL_CIPHER_description(const SSL_CIPHER *,char *buf,int size); ++STACK_OF(X509_NAME) *SSL_dup_CA_list(STACK_OF(X509_NAME) *sk); ++ ++SSL *SSL_dup(SSL *ssl); ++ ++X509 *SSL_get_certificate(const SSL *ssl); ++/* EVP_PKEY */ struct evp_pkey_st *SSL_get_privatekey(SSL *ssl); ++ ++void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx,int mode); ++int SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx); ++void SSL_set_quiet_shutdown(SSL *ssl,int mode); ++int SSL_get_quiet_shutdown(const SSL *ssl); ++void SSL_set_shutdown(SSL *ssl,int mode); ++int SSL_get_shutdown(const SSL *ssl); ++int SSL_version(const SSL *ssl); ++int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx); ++int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile, ++ const char *CApath); ++#define SSL_get0_session SSL_get_session /* just peek at pointer */ ++SSL_SESSION *SSL_get_session(const SSL *ssl); ++SSL_SESSION *SSL_get1_session(SSL *ssl); /* obtain a reference count */ ++SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl); ++SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX* ctx); ++void SSL_set_info_callback(SSL *ssl, ++ void (*cb)(const SSL *ssl,int type,int val)); ++void (*SSL_get_info_callback(const SSL *ssl))(const SSL *ssl,int type,int val); ++int SSL_state(const SSL *ssl); ++ ++void SSL_set_verify_result(SSL *ssl,long v); ++long SSL_get_verify_result(const SSL *ssl); ++ ++int SSL_set_ex_data(SSL *ssl,int idx,void *data); ++void *SSL_get_ex_data(const SSL *ssl,int idx); ++int SSL_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, ++ CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func); ++ ++int SSL_SESSION_set_ex_data(SSL_SESSION *ss,int idx,void *data); ++void *SSL_SESSION_get_ex_data(const SSL_SESSION *ss,int idx); ++int SSL_SESSION_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, ++ CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func); ++ ++int SSL_CTX_set_ex_data(SSL_CTX *ssl,int idx,void *data); ++void *SSL_CTX_get_ex_data(const SSL_CTX *ssl,int idx); ++int SSL_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, ++ CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func); ++ ++int SSL_get_ex_data_X509_STORE_CTX_idx(void ); ++ ++#define SSL_CTX_sess_set_cache_size(ctx,t) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SESS_CACHE_SIZE,t,NULL) ++#define SSL_CTX_sess_get_cache_size(ctx) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_GET_SESS_CACHE_SIZE,0,NULL) ++#define SSL_CTX_set_session_cache_mode(ctx,m) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SESS_CACHE_MODE,m,NULL) ++#define SSL_CTX_get_session_cache_mode(ctx) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_GET_SESS_CACHE_MODE,0,NULL) ++ ++#define SSL_CTX_get_default_read_ahead(ctx) SSL_CTX_get_read_ahead(ctx) ++#define SSL_CTX_set_default_read_ahead(ctx,m) SSL_CTX_set_read_ahead(ctx,m) ++#define SSL_CTX_get_read_ahead(ctx) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_GET_READ_AHEAD,0,NULL) ++#define SSL_CTX_set_read_ahead(ctx,m) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_SET_READ_AHEAD,m,NULL) ++#define SSL_CTX_get_max_cert_list(ctx) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_GET_MAX_CERT_LIST,0,NULL) ++#define SSL_CTX_set_max_cert_list(ctx,m) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_SET_MAX_CERT_LIST,m,NULL) ++#define SSL_get_max_cert_list(ssl) \ ++ SSL_ctrl(ssl,SSL_CTRL_GET_MAX_CERT_LIST,0,NULL) ++#define SSL_set_max_cert_list(ssl,m) \ ++ SSL_ctrl(ssl,SSL_CTRL_SET_MAX_CERT_LIST,m,NULL) ++ ++#define SSL_CTX_set_max_send_fragment(ctx,m) \ ++ SSL_CTX_ctrl(ctx,SSL_CTRL_SET_MAX_SEND_FRAGMENT,m,NULL) ++#define SSL_set_max_send_fragment(ssl,m) \ ++ SSL_ctrl(ssl,SSL_CTRL_SET_MAX_SEND_FRAGMENT,m,NULL) ++ ++ /* NB: the keylength is only applicable when is_export is true */ ++#ifndef OPENSSL_NO_RSA ++void SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx, ++ RSA *(*cb)(SSL *ssl,int is_export, ++ int keylength)); ++ ++void SSL_set_tmp_rsa_callback(SSL *ssl, ++ RSA *(*cb)(SSL *ssl,int is_export, ++ int keylength)); ++#endif ++#ifndef OPENSSL_NO_DH ++void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx, ++ DH *(*dh)(SSL *ssl,int is_export, ++ int keylength)); ++void SSL_set_tmp_dh_callback(SSL *ssl, ++ DH *(*dh)(SSL *ssl,int is_export, ++ int keylength)); ++#endif ++#ifndef OPENSSL_NO_ECDH ++void SSL_CTX_set_tmp_ecdh_callback(SSL_CTX *ctx, ++ EC_KEY *(*ecdh)(SSL *ssl,int is_export, ++ int keylength)); ++void SSL_set_tmp_ecdh_callback(SSL *ssl, ++ EC_KEY *(*ecdh)(SSL *ssl,int is_export, ++ int keylength)); ++#endif ++ ++#ifndef OPENSSL_NO_COMP ++const COMP_METHOD *SSL_get_current_compression(SSL *s); ++const COMP_METHOD *SSL_get_current_expansion(SSL *s); ++const char *SSL_COMP_get_name(const COMP_METHOD *comp); ++STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void); ++int SSL_COMP_add_compression_method(int id,COMP_METHOD *cm); ++#else ++const void *SSL_get_current_compression(SSL *s); ++const void *SSL_get_current_expansion(SSL *s); ++const char *SSL_COMP_get_name(const void *comp); ++void *SSL_COMP_get_compression_methods(void); ++int SSL_COMP_add_compression_method(int id,void *cm); ++#endif ++ ++/* TLS extensions functions */ ++int SSL_set_session_ticket_ext(SSL *s, void *ext_data, int ext_len); ++ ++int SSL_set_session_ticket_ext_cb(SSL *s, tls_session_ticket_ext_cb_fn cb, ++ void *arg); ++ ++/* Pre-shared secret session resumption functions */ ++int SSL_set_session_secret_cb(SSL *s, tls_session_secret_cb_fn tls_session_secret_cb, void *arg); ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_SSL_strings(void); ++ ++/* Error codes for the SSL functions. */ ++ ++/* Function codes. */ ++#define SSL_F_CLIENT_CERTIFICATE 100 ++#define SSL_F_CLIENT_FINISHED 167 ++#define SSL_F_CLIENT_HELLO 101 ++#define SSL_F_CLIENT_MASTER_KEY 102 ++#define SSL_F_D2I_SSL_SESSION 103 ++#define SSL_F_DO_DTLS1_WRITE 245 ++#define SSL_F_DO_SSL3_WRITE 104 ++#define SSL_F_DTLS1_ACCEPT 246 ++#define SSL_F_DTLS1_ADD_CERT_TO_BUF 295 ++#define SSL_F_DTLS1_BUFFER_RECORD 247 ++#define SSL_F_DTLS1_CLIENT_HELLO 248 ++#define SSL_F_DTLS1_CONNECT 249 ++#define SSL_F_DTLS1_ENC 250 ++#define SSL_F_DTLS1_GET_HELLO_VERIFY 251 ++#define SSL_F_DTLS1_GET_MESSAGE 252 ++#define SSL_F_DTLS1_GET_MESSAGE_FRAGMENT 253 ++#define SSL_F_DTLS1_GET_RECORD 254 ++#define SSL_F_DTLS1_HANDLE_TIMEOUT 297 ++#define SSL_F_DTLS1_OUTPUT_CERT_CHAIN 255 ++#define SSL_F_DTLS1_PREPROCESS_FRAGMENT 288 ++#define SSL_F_DTLS1_PROCESS_OUT_OF_SEQ_MESSAGE 256 ++#define SSL_F_DTLS1_PROCESS_RECORD 257 ++#define SSL_F_DTLS1_READ_BYTES 258 ++#define SSL_F_DTLS1_READ_FAILED 259 ++#define SSL_F_DTLS1_SEND_CERTIFICATE_REQUEST 260 ++#define SSL_F_DTLS1_SEND_CLIENT_CERTIFICATE 261 ++#define SSL_F_DTLS1_SEND_CLIENT_KEY_EXCHANGE 262 ++#define SSL_F_DTLS1_SEND_CLIENT_VERIFY 263 ++#define SSL_F_DTLS1_SEND_HELLO_VERIFY_REQUEST 264 ++#define SSL_F_DTLS1_SEND_SERVER_CERTIFICATE 265 ++#define SSL_F_DTLS1_SEND_SERVER_HELLO 266 ++#define SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE 267 ++#define SSL_F_DTLS1_WRITE_APP_DATA_BYTES 268 ++#define SSL_F_GET_CLIENT_FINISHED 105 ++#define SSL_F_GET_CLIENT_HELLO 106 ++#define SSL_F_GET_CLIENT_MASTER_KEY 107 ++#define SSL_F_GET_SERVER_FINISHED 108 ++#define SSL_F_GET_SERVER_HELLO 109 ++#define SSL_F_GET_SERVER_VERIFY 110 ++#define SSL_F_I2D_SSL_SESSION 111 ++#define SSL_F_READ_N 112 ++#define SSL_F_REQUEST_CERTIFICATE 113 ++#define SSL_F_SERVER_FINISH 239 ++#define SSL_F_SERVER_HELLO 114 ++#define SSL_F_SERVER_VERIFY 240 ++#define SSL_F_SSL23_ACCEPT 115 ++#define SSL_F_SSL23_CLIENT_HELLO 116 ++#define SSL_F_SSL23_CONNECT 117 ++#define SSL_F_SSL23_GET_CLIENT_HELLO 118 ++#define SSL_F_SSL23_GET_SERVER_HELLO 119 ++#define SSL_F_SSL23_PEEK 237 ++#define SSL_F_SSL23_READ 120 ++#define SSL_F_SSL23_WRITE 121 ++#define SSL_F_SSL2_ACCEPT 122 ++#define SSL_F_SSL2_CONNECT 123 ++#define SSL_F_SSL2_ENC_INIT 124 ++#define SSL_F_SSL2_GENERATE_KEY_MATERIAL 241 ++#define SSL_F_SSL2_PEEK 234 ++#define SSL_F_SSL2_READ 125 ++#define SSL_F_SSL2_READ_INTERNAL 236 ++#define SSL_F_SSL2_SET_CERTIFICATE 126 ++#define SSL_F_SSL2_WRITE 127 ++#define SSL_F_SSL3_ACCEPT 128 ++#define SSL_F_SSL3_ADD_CERT_TO_BUF 296 ++#define SSL_F_SSL3_CALLBACK_CTRL 233 ++#define SSL_F_SSL3_CHANGE_CIPHER_STATE 129 ++#define SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM 130 ++#define SSL_F_SSL3_CLIENT_HELLO 131 ++#define SSL_F_SSL3_CONNECT 132 ++#define SSL_F_SSL3_CTRL 213 ++#define SSL_F_SSL3_CTX_CTRL 133 ++#define SSL_F_SSL3_DIGEST_CACHED_RECORDS 293 ++#define SSL_F_SSL3_DO_CHANGE_CIPHER_SPEC 292 ++#define SSL_F_SSL3_ENC 134 ++#define SSL_F_SSL3_GENERATE_KEY_BLOCK 238 ++#define SSL_F_SSL3_GET_CERTIFICATE_REQUEST 135 ++#define SSL_F_SSL3_GET_CERT_STATUS 289 ++#define SSL_F_SSL3_GET_CERT_VERIFY 136 ++#define SSL_F_SSL3_GET_CLIENT_CERTIFICATE 137 ++#define SSL_F_SSL3_GET_CLIENT_HELLO 138 ++#define SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE 139 ++#define SSL_F_SSL3_GET_FINISHED 140 ++#define SSL_F_SSL3_GET_KEY_EXCHANGE 141 ++#define SSL_F_SSL3_GET_MESSAGE 142 ++#define SSL_F_SSL3_GET_NEW_SESSION_TICKET 283 ++#define SSL_F_SSL3_GET_RECORD 143 ++#define SSL_F_SSL3_GET_SERVER_CERTIFICATE 144 ++#define SSL_F_SSL3_GET_SERVER_DONE 145 ++#define SSL_F_SSL3_GET_SERVER_HELLO 146 ++#define SSL_F_SSL3_HANDSHAKE_MAC 285 ++#define SSL_F_SSL3_NEW_SESSION_TICKET 287 ++#define SSL_F_SSL3_OUTPUT_CERT_CHAIN 147 ++#define SSL_F_SSL3_PEEK 235 ++#define SSL_F_SSL3_READ_BYTES 148 ++#define SSL_F_SSL3_READ_N 149 ++#define SSL_F_SSL3_SEND_CERTIFICATE_REQUEST 150 ++#define SSL_F_SSL3_SEND_CLIENT_CERTIFICATE 151 ++#define SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE 152 ++#define SSL_F_SSL3_SEND_CLIENT_VERIFY 153 ++#define SSL_F_SSL3_SEND_SERVER_CERTIFICATE 154 ++#define SSL_F_SSL3_SEND_SERVER_HELLO 242 ++#define SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE 155 ++#define SSL_F_SSL3_SETUP_KEY_BLOCK 157 ++#define SSL_F_SSL3_SETUP_READ_BUFFER 156 ++#define SSL_F_SSL3_SETUP_WRITE_BUFFER 291 ++#define SSL_F_SSL3_WRITE_BYTES 158 ++#define SSL_F_SSL3_WRITE_PENDING 159 ++#define SSL_F_SSL_ADD_CLIENTHELLO_RENEGOTIATE_EXT 298 ++#define SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT 277 ++#define SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK 215 ++#define SSL_F_SSL_ADD_FILE_CERT_SUBJECTS_TO_STACK 216 ++#define SSL_F_SSL_ADD_SERVERHELLO_RENEGOTIATE_EXT 299 ++#define SSL_F_SSL_ADD_SERVERHELLO_TLSEXT 278 ++#define SSL_F_SSL_BAD_METHOD 160 ++#define SSL_F_SSL_BYTES_TO_CIPHER_LIST 161 ++#define SSL_F_SSL_CERT_DUP 221 ++#define SSL_F_SSL_CERT_INST 222 ++#define SSL_F_SSL_CERT_INSTANTIATE 214 ++#define SSL_F_SSL_CERT_NEW 162 ++#define SSL_F_SSL_CHECK_PRIVATE_KEY 163 ++#define SSL_F_SSL_CHECK_SERVERHELLO_TLSEXT 280 ++#define SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG 279 ++#define SSL_F_SSL_CIPHER_PROCESS_RULESTR 230 ++#define SSL_F_SSL_CIPHER_STRENGTH_SORT 231 ++#define SSL_F_SSL_CLEAR 164 ++#define SSL_F_SSL_COMP_ADD_COMPRESSION_METHOD 165 ++#define SSL_F_SSL_CREATE_CIPHER_LIST 166 ++#define SSL_F_SSL_CTRL 232 ++#define SSL_F_SSL_CTX_CHECK_PRIVATE_KEY 168 ++#define SSL_F_SSL_CTX_NEW 169 ++#define SSL_F_SSL_CTX_SET_CIPHER_LIST 269 ++#define SSL_F_SSL_CTX_SET_CLIENT_CERT_ENGINE 290 ++#define SSL_F_SSL_CTX_SET_PURPOSE 226 ++#define SSL_F_SSL_CTX_SET_SESSION_ID_CONTEXT 219 ++#define SSL_F_SSL_CTX_SET_SSL_VERSION 170 ++#define SSL_F_SSL_CTX_SET_TRUST 229 ++#define SSL_F_SSL_CTX_USE_CERTIFICATE 171 ++#define SSL_F_SSL_CTX_USE_CERTIFICATE_ASN1 172 ++#define SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE 220 ++#define SSL_F_SSL_CTX_USE_CERTIFICATE_FILE 173 ++#define SSL_F_SSL_CTX_USE_PRIVATEKEY 174 ++#define SSL_F_SSL_CTX_USE_PRIVATEKEY_ASN1 175 ++#define SSL_F_SSL_CTX_USE_PRIVATEKEY_FILE 176 ++#define SSL_F_SSL_CTX_USE_PSK_IDENTITY_HINT 272 ++#define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY 177 ++#define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_ASN1 178 ++#define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_FILE 179 ++#define SSL_F_SSL_DO_HANDSHAKE 180 ++#define SSL_F_SSL_GET_NEW_SESSION 181 ++#define SSL_F_SSL_GET_PREV_SESSION 217 ++#define SSL_F_SSL_GET_SERVER_SEND_CERT 182 ++#define SSL_F_SSL_GET_SIGN_PKEY 183 ++#define SSL_F_SSL_INIT_WBIO_BUFFER 184 ++#define SSL_F_SSL_LOAD_CLIENT_CA_FILE 185 ++#define SSL_F_SSL_NEW 186 ++#define SSL_F_SSL_PARSE_CLIENTHELLO_RENEGOTIATE_EXT 300 ++#define SSL_F_SSL_PARSE_CLIENTHELLO_TLSEXT 302 ++#define SSL_F_SSL_PARSE_SERVERHELLO_RENEGOTIATE_EXT 301 ++#define SSL_F_SSL_PARSE_SERVERHELLO_TLSEXT 303 ++#define SSL_F_SSL_PEEK 270 ++#define SSL_F_SSL_PREPARE_CLIENTHELLO_TLSEXT 281 ++#define SSL_F_SSL_PREPARE_SERVERHELLO_TLSEXT 282 ++#define SSL_F_SSL_READ 223 ++#define SSL_F_SSL_RSA_PRIVATE_DECRYPT 187 ++#define SSL_F_SSL_RSA_PUBLIC_ENCRYPT 188 ++#define SSL_F_SSL_SESSION_NEW 189 ++#define SSL_F_SSL_SESSION_PRINT_FP 190 ++#define SSL_F_SSL_SESS_CERT_NEW 225 ++#define SSL_F_SSL_SET_CERT 191 ++#define SSL_F_SSL_SET_CIPHER_LIST 271 ++#define SSL_F_SSL_SET_FD 192 ++#define SSL_F_SSL_SET_PKEY 193 ++#define SSL_F_SSL_SET_PURPOSE 227 ++#define SSL_F_SSL_SET_RFD 194 ++#define SSL_F_SSL_SET_SESSION 195 ++#define SSL_F_SSL_SET_SESSION_ID_CONTEXT 218 ++#define SSL_F_SSL_SET_SESSION_TICKET_EXT 294 ++#define SSL_F_SSL_SET_TRUST 228 ++#define SSL_F_SSL_SET_WFD 196 ++#define SSL_F_SSL_SHUTDOWN 224 ++#define SSL_F_SSL_UNDEFINED_CONST_FUNCTION 243 ++#define SSL_F_SSL_UNDEFINED_FUNCTION 197 ++#define SSL_F_SSL_UNDEFINED_VOID_FUNCTION 244 ++#define SSL_F_SSL_USE_CERTIFICATE 198 ++#define SSL_F_SSL_USE_CERTIFICATE_ASN1 199 ++#define SSL_F_SSL_USE_CERTIFICATE_FILE 200 ++#define SSL_F_SSL_USE_PRIVATEKEY 201 ++#define SSL_F_SSL_USE_PRIVATEKEY_ASN1 202 ++#define SSL_F_SSL_USE_PRIVATEKEY_FILE 203 ++#define SSL_F_SSL_USE_PSK_IDENTITY_HINT 273 ++#define SSL_F_SSL_USE_RSAPRIVATEKEY 204 ++#define SSL_F_SSL_USE_RSAPRIVATEKEY_ASN1 205 ++#define SSL_F_SSL_USE_RSAPRIVATEKEY_FILE 206 ++#define SSL_F_SSL_VERIFY_CERT_CHAIN 207 ++#define SSL_F_SSL_WRITE 208 ++#define SSL_F_TLS1_CERT_VERIFY_MAC 286 ++#define SSL_F_TLS1_CHANGE_CIPHER_STATE 209 ++#define SSL_F_TLS1_CHECK_SERVERHELLO_TLSEXT 274 ++#define SSL_F_TLS1_ENC 210 ++#define SSL_F_TLS1_PREPARE_CLIENTHELLO_TLSEXT 275 ++#define SSL_F_TLS1_PREPARE_SERVERHELLO_TLSEXT 276 ++#define SSL_F_TLS1_PRF 284 ++#define SSL_F_TLS1_SETUP_KEY_BLOCK 211 ++#define SSL_F_WRITE_PENDING 212 ++ ++/* Reason codes. */ ++#define SSL_R_APP_DATA_IN_HANDSHAKE 100 ++#define SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT 272 ++#define SSL_R_BAD_ALERT_RECORD 101 ++#define SSL_R_BAD_AUTHENTICATION_TYPE 102 ++#define SSL_R_BAD_CHANGE_CIPHER_SPEC 103 ++#define SSL_R_BAD_CHECKSUM 104 ++#define SSL_R_BAD_DATA_RETURNED_BY_CALLBACK 106 ++#define SSL_R_BAD_DECOMPRESSION 107 ++#define SSL_R_BAD_DH_G_LENGTH 108 ++#define SSL_R_BAD_DH_PUB_KEY_LENGTH 109 ++#define SSL_R_BAD_DH_P_LENGTH 110 ++#define SSL_R_BAD_DIGEST_LENGTH 111 ++#define SSL_R_BAD_DSA_SIGNATURE 112 ++#define SSL_R_BAD_ECC_CERT 304 ++#define SSL_R_BAD_ECDSA_SIGNATURE 305 ++#define SSL_R_BAD_ECPOINT 306 ++#define SSL_R_BAD_HANDSHAKE_LENGTH 332 ++#define SSL_R_BAD_HELLO_REQUEST 105 ++#define SSL_R_BAD_LENGTH 271 ++#define SSL_R_BAD_MAC_DECODE 113 ++#define SSL_R_BAD_MAC_LENGTH 333 ++#define SSL_R_BAD_MESSAGE_TYPE 114 ++#define SSL_R_BAD_PACKET_LENGTH 115 ++#define SSL_R_BAD_PROTOCOL_VERSION_NUMBER 116 ++#define SSL_R_BAD_PSK_IDENTITY_HINT_LENGTH 316 ++#define SSL_R_BAD_RESPONSE_ARGUMENT 117 ++#define SSL_R_BAD_RSA_DECRYPT 118 ++#define SSL_R_BAD_RSA_ENCRYPT 119 ++#define SSL_R_BAD_RSA_E_LENGTH 120 ++#define SSL_R_BAD_RSA_MODULUS_LENGTH 121 ++#define SSL_R_BAD_RSA_SIGNATURE 122 ++#define SSL_R_BAD_SIGNATURE 123 ++#define SSL_R_BAD_SSL_FILETYPE 124 ++#define SSL_R_BAD_SSL_SESSION_ID_LENGTH 125 ++#define SSL_R_BAD_STATE 126 ++#define SSL_R_BAD_WRITE_RETRY 127 ++#define SSL_R_BIO_NOT_SET 128 ++#define SSL_R_BLOCK_CIPHER_PAD_IS_WRONG 129 ++#define SSL_R_BN_LIB 130 ++#define SSL_R_CA_DN_LENGTH_MISMATCH 131 ++#define SSL_R_CA_DN_TOO_LONG 132 ++#define SSL_R_CCS_RECEIVED_EARLY 133 ++#define SSL_R_CERTIFICATE_VERIFY_FAILED 134 ++#define SSL_R_CERT_LENGTH_MISMATCH 135 ++#define SSL_R_CHALLENGE_IS_DIFFERENT 136 ++#define SSL_R_CIPHER_CODE_WRONG_LENGTH 137 ++#define SSL_R_CIPHER_OR_HASH_UNAVAILABLE 138 ++#define SSL_R_CIPHER_TABLE_SRC_ERROR 139 ++#define SSL_R_CLIENTHELLO_TLSEXT 226 ++#define SSL_R_COMPRESSED_LENGTH_TOO_LONG 140 ++#define SSL_R_COMPRESSION_DISABLED 343 ++#define SSL_R_COMPRESSION_FAILURE 141 ++#define SSL_R_COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE 307 ++#define SSL_R_COMPRESSION_LIBRARY_ERROR 142 ++#define SSL_R_CONNECTION_ID_IS_DIFFERENT 143 ++#define SSL_R_CONNECTION_TYPE_NOT_SET 144 ++#define SSL_R_COOKIE_MISMATCH 308 ++#define SSL_R_DATA_BETWEEN_CCS_AND_FINISHED 145 ++#define SSL_R_DATA_LENGTH_TOO_LONG 146 ++#define SSL_R_DECRYPTION_FAILED 147 ++#define SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC 281 ++#define SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG 148 ++#define SSL_R_DIGEST_CHECK_FAILED 149 ++#define SSL_R_DTLS_MESSAGE_TOO_BIG 334 ++#define SSL_R_DUPLICATE_COMPRESSION_ID 309 ++#define SSL_R_ECC_CERT_NOT_FOR_KEY_AGREEMENT 317 ++#define SSL_R_ECC_CERT_NOT_FOR_SIGNING 318 ++#define SSL_R_ECC_CERT_SHOULD_HAVE_RSA_SIGNATURE 322 ++#define SSL_R_ECC_CERT_SHOULD_HAVE_SHA1_SIGNATURE 323 ++#define SSL_R_ECGROUP_TOO_LARGE_FOR_CIPHER 310 ++#define SSL_R_ENCRYPTED_LENGTH_TOO_LONG 150 ++#define SSL_R_ERROR_GENERATING_TMP_RSA_KEY 282 ++#define SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST 151 ++#define SSL_R_EXCESSIVE_MESSAGE_SIZE 152 ++#define SSL_R_EXTRA_DATA_IN_MESSAGE 153 ++#define SSL_R_GOT_A_FIN_BEFORE_A_CCS 154 ++#define SSL_R_HTTPS_PROXY_REQUEST 155 ++#define SSL_R_HTTP_REQUEST 156 ++#define SSL_R_ILLEGAL_PADDING 283 ++#define SSL_R_INCONSISTENT_COMPRESSION 340 ++#define SSL_R_INVALID_CHALLENGE_LENGTH 158 ++#define SSL_R_INVALID_COMMAND 280 ++#define SSL_R_INVALID_COMPRESSION_ALGORITHM 341 ++#define SSL_R_INVALID_PURPOSE 278 ++#define SSL_R_INVALID_STATUS_RESPONSE 328 ++#define SSL_R_INVALID_TICKET_KEYS_LENGTH 325 ++#define SSL_R_INVALID_TRUST 279 ++#define SSL_R_KEY_ARG_TOO_LONG 284 ++#define SSL_R_KRB5 285 ++#define SSL_R_KRB5_C_CC_PRINC 286 ++#define SSL_R_KRB5_C_GET_CRED 287 ++#define SSL_R_KRB5_C_INIT 288 ++#define SSL_R_KRB5_C_MK_REQ 289 ++#define SSL_R_KRB5_S_BAD_TICKET 290 ++#define SSL_R_KRB5_S_INIT 291 ++#define SSL_R_KRB5_S_RD_REQ 292 ++#define SSL_R_KRB5_S_TKT_EXPIRED 293 ++#define SSL_R_KRB5_S_TKT_NYV 294 ++#define SSL_R_KRB5_S_TKT_SKEW 295 ++#define SSL_R_LENGTH_MISMATCH 159 ++#define SSL_R_LENGTH_TOO_SHORT 160 ++#define SSL_R_LIBRARY_BUG 274 ++#define SSL_R_LIBRARY_HAS_NO_CIPHERS 161 ++#define SSL_R_MESSAGE_TOO_LONG 296 ++#define SSL_R_MISSING_DH_DSA_CERT 162 ++#define SSL_R_MISSING_DH_KEY 163 ++#define SSL_R_MISSING_DH_RSA_CERT 164 ++#define SSL_R_MISSING_DSA_SIGNING_CERT 165 ++#define SSL_R_MISSING_EXPORT_TMP_DH_KEY 166 ++#define SSL_R_MISSING_EXPORT_TMP_RSA_KEY 167 ++#define SSL_R_MISSING_RSA_CERTIFICATE 168 ++#define SSL_R_MISSING_RSA_ENCRYPTING_CERT 169 ++#define SSL_R_MISSING_RSA_SIGNING_CERT 170 ++#define SSL_R_MISSING_TMP_DH_KEY 171 ++#define SSL_R_MISSING_TMP_ECDH_KEY 311 ++#define SSL_R_MISSING_TMP_RSA_KEY 172 ++#define SSL_R_MISSING_TMP_RSA_PKEY 173 ++#define SSL_R_MISSING_VERIFY_MESSAGE 174 ++#define SSL_R_NON_SSLV2_INITIAL_PACKET 175 ++#define SSL_R_NO_CERTIFICATES_RETURNED 176 ++#define SSL_R_NO_CERTIFICATE_ASSIGNED 177 ++#define SSL_R_NO_CERTIFICATE_RETURNED 178 ++#define SSL_R_NO_CERTIFICATE_SET 179 ++#define SSL_R_NO_CERTIFICATE_SPECIFIED 180 ++#define SSL_R_NO_CIPHERS_AVAILABLE 181 ++#define SSL_R_NO_CIPHERS_PASSED 182 ++#define SSL_R_NO_CIPHERS_SPECIFIED 183 ++#define SSL_R_NO_CIPHER_LIST 184 ++#define SSL_R_NO_CIPHER_MATCH 185 ++#define SSL_R_NO_CLIENT_CERT_METHOD 331 ++#define SSL_R_NO_CLIENT_CERT_RECEIVED 186 ++#define SSL_R_NO_COMPRESSION_SPECIFIED 187 ++#define SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER 330 ++#define SSL_R_NO_METHOD_SPECIFIED 188 ++#define SSL_R_NO_PRIVATEKEY 189 ++#define SSL_R_NO_PRIVATE_KEY_ASSIGNED 190 ++#define SSL_R_NO_PROTOCOLS_AVAILABLE 191 ++#define SSL_R_NO_PUBLICKEY 192 ++#define SSL_R_NO_RENEGOTIATION 339 ++#define SSL_R_NO_REQUIRED_DIGEST 324 ++#define SSL_R_NO_SHARED_CIPHER 193 ++#define SSL_R_NO_VERIFY_CALLBACK 194 ++#define SSL_R_NULL_SSL_CTX 195 ++#define SSL_R_NULL_SSL_METHOD_PASSED 196 ++#define SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED 197 ++#define SSL_R_OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED 344 ++#define SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE 297 ++#define SSL_R_OPAQUE_PRF_INPUT_TOO_LONG 327 ++#define SSL_R_PACKET_LENGTH_TOO_LONG 198 ++#define SSL_R_PARSE_TLSEXT 227 ++#define SSL_R_PATH_TOO_LONG 270 ++#define SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE 199 ++#define SSL_R_PEER_ERROR 200 ++#define SSL_R_PEER_ERROR_CERTIFICATE 201 ++#define SSL_R_PEER_ERROR_NO_CERTIFICATE 202 ++#define SSL_R_PEER_ERROR_NO_CIPHER 203 ++#define SSL_R_PEER_ERROR_UNSUPPORTED_CERTIFICATE_TYPE 204 ++#define SSL_R_PRE_MAC_LENGTH_TOO_LONG 205 ++#define SSL_R_PROBLEMS_MAPPING_CIPHER_FUNCTIONS 206 ++#define SSL_R_PROTOCOL_IS_SHUTDOWN 207 ++#define SSL_R_PSK_IDENTITY_NOT_FOUND 223 ++#define SSL_R_PSK_NO_CLIENT_CB 224 ++#define SSL_R_PSK_NO_SERVER_CB 225 ++#define SSL_R_PUBLIC_KEY_ENCRYPT_ERROR 208 ++#define SSL_R_PUBLIC_KEY_IS_NOT_RSA 209 ++#define SSL_R_PUBLIC_KEY_NOT_RSA 210 ++#define SSL_R_READ_BIO_NOT_SET 211 ++#define SSL_R_READ_TIMEOUT_EXPIRED 312 ++#define SSL_R_READ_WRONG_PACKET_TYPE 212 ++#define SSL_R_RECORD_LENGTH_MISMATCH 213 ++#define SSL_R_RECORD_TOO_LARGE 214 ++#define SSL_R_RECORD_TOO_SMALL 298 ++#define SSL_R_RENEGOTIATE_EXT_TOO_LONG 335 ++#define SSL_R_RENEGOTIATION_ENCODING_ERR 336 ++#define SSL_R_RENEGOTIATION_MISMATCH 337 ++#define SSL_R_REQUIRED_CIPHER_MISSING 215 ++#define SSL_R_REQUIRED_COMPRESSSION_ALGORITHM_MISSING 342 ++#define SSL_R_REUSE_CERT_LENGTH_NOT_ZERO 216 ++#define SSL_R_REUSE_CERT_TYPE_NOT_ZERO 217 ++#define SSL_R_REUSE_CIPHER_LIST_NOT_ZERO 218 ++#define SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING 345 ++#define SSL_R_SERVERHELLO_TLSEXT 275 ++#define SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED 277 ++#define SSL_R_SHORT_READ 219 ++#define SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE 220 ++#define SSL_R_SSL23_DOING_SESSION_ID_REUSE 221 ++#define SSL_R_SSL2_CONNECTION_ID_TOO_LONG 299 ++#define SSL_R_SSL3_EXT_INVALID_ECPOINTFORMAT 321 ++#define SSL_R_SSL3_EXT_INVALID_SERVERNAME 319 ++#define SSL_R_SSL3_EXT_INVALID_SERVERNAME_TYPE 320 ++#define SSL_R_SSL3_SESSION_ID_TOO_LONG 300 ++#define SSL_R_SSL3_SESSION_ID_TOO_SHORT 222 ++#define SSL_R_SSLV3_ALERT_BAD_CERTIFICATE 1042 ++#define SSL_R_SSLV3_ALERT_BAD_RECORD_MAC 1020 ++#define SSL_R_SSLV3_ALERT_CERTIFICATE_EXPIRED 1045 ++#define SSL_R_SSLV3_ALERT_CERTIFICATE_REVOKED 1044 ++#define SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN 1046 ++#define SSL_R_SSLV3_ALERT_DECOMPRESSION_FAILURE 1030 ++#define SSL_R_SSLV3_ALERT_HANDSHAKE_FAILURE 1040 ++#define SSL_R_SSLV3_ALERT_ILLEGAL_PARAMETER 1047 ++#define SSL_R_SSLV3_ALERT_NO_CERTIFICATE 1041 ++#define SSL_R_SSLV3_ALERT_UNEXPECTED_MESSAGE 1010 ++#define SSL_R_SSLV3_ALERT_UNSUPPORTED_CERTIFICATE 1043 ++#define SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION 228 ++#define SSL_R_SSL_HANDSHAKE_FAILURE 229 ++#define SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS 230 ++#define SSL_R_SSL_SESSION_ID_CALLBACK_FAILED 301 ++#define SSL_R_SSL_SESSION_ID_CONFLICT 302 ++#define SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG 273 ++#define SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH 303 ++#define SSL_R_SSL_SESSION_ID_IS_DIFFERENT 231 ++#define SSL_R_TLSV1_ALERT_ACCESS_DENIED 1049 ++#define SSL_R_TLSV1_ALERT_DECODE_ERROR 1050 ++#define SSL_R_TLSV1_ALERT_DECRYPTION_FAILED 1021 ++#define SSL_R_TLSV1_ALERT_DECRYPT_ERROR 1051 ++#define SSL_R_TLSV1_ALERT_EXPORT_RESTRICTION 1060 ++#define SSL_R_TLSV1_ALERT_INSUFFICIENT_SECURITY 1071 ++#define SSL_R_TLSV1_ALERT_INTERNAL_ERROR 1080 ++#define SSL_R_TLSV1_ALERT_NO_RENEGOTIATION 1100 ++#define SSL_R_TLSV1_ALERT_PROTOCOL_VERSION 1070 ++#define SSL_R_TLSV1_ALERT_RECORD_OVERFLOW 1022 ++#define SSL_R_TLSV1_ALERT_UNKNOWN_CA 1048 ++#define SSL_R_TLSV1_ALERT_USER_CANCELLED 1090 ++#define SSL_R_TLSV1_BAD_CERTIFICATE_HASH_VALUE 1114 ++#define SSL_R_TLSV1_BAD_CERTIFICATE_STATUS_RESPONSE 1113 ++#define SSL_R_TLSV1_CERTIFICATE_UNOBTAINABLE 1111 ++#define SSL_R_TLSV1_UNRECOGNIZED_NAME 1112 ++#define SSL_R_TLSV1_UNSUPPORTED_EXTENSION 1110 ++#define SSL_R_TLS_CLIENT_CERT_REQ_WITH_ANON_CIPHER 232 ++#define SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST 157 ++#define SSL_R_TLS_PEER_DID_NOT_RESPOND_WITH_CERTIFICATE_LIST 233 ++#define SSL_R_TLS_RSA_ENCRYPTED_VALUE_LENGTH_IS_WRONG 234 ++#define SSL_R_TRIED_TO_USE_UNSUPPORTED_CIPHER 235 ++#define SSL_R_UNABLE_TO_DECODE_DH_CERTS 236 ++#define SSL_R_UNABLE_TO_DECODE_ECDH_CERTS 313 ++#define SSL_R_UNABLE_TO_EXTRACT_PUBLIC_KEY 237 ++#define SSL_R_UNABLE_TO_FIND_DH_PARAMETERS 238 ++#define SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS 314 ++#define SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS 239 ++#define SSL_R_UNABLE_TO_FIND_SSL_METHOD 240 ++#define SSL_R_UNABLE_TO_LOAD_SSL2_MD5_ROUTINES 241 ++#define SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES 242 ++#define SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES 243 ++#define SSL_R_UNEXPECTED_MESSAGE 244 ++#define SSL_R_UNEXPECTED_RECORD 245 ++#define SSL_R_UNINITIALIZED 276 ++#define SSL_R_UNKNOWN_ALERT_TYPE 246 ++#define SSL_R_UNKNOWN_CERTIFICATE_TYPE 247 ++#define SSL_R_UNKNOWN_CIPHER_RETURNED 248 ++#define SSL_R_UNKNOWN_CIPHER_TYPE 249 ++#define SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE 250 ++#define SSL_R_UNKNOWN_PKEY_TYPE 251 ++#define SSL_R_UNKNOWN_PROTOCOL 252 ++#define SSL_R_UNKNOWN_REMOTE_ERROR_TYPE 253 ++#define SSL_R_UNKNOWN_SSL_VERSION 254 ++#define SSL_R_UNKNOWN_STATE 255 ++#define SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED 338 ++#define SSL_R_UNSUPPORTED_CIPHER 256 ++#define SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM 257 ++#define SSL_R_UNSUPPORTED_DIGEST_TYPE 326 ++#define SSL_R_UNSUPPORTED_ELLIPTIC_CURVE 315 ++#define SSL_R_UNSUPPORTED_PROTOCOL 258 ++#define SSL_R_UNSUPPORTED_SSL_VERSION 259 ++#define SSL_R_UNSUPPORTED_STATUS_TYPE 329 ++#define SSL_R_WRITE_BIO_NOT_SET 260 ++#define SSL_R_WRONG_CIPHER_RETURNED 261 ++#define SSL_R_WRONG_MESSAGE_TYPE 262 ++#define SSL_R_WRONG_NUMBER_OF_KEY_BITS 263 ++#define SSL_R_WRONG_SIGNATURE_LENGTH 264 ++#define SSL_R_WRONG_SIGNATURE_SIZE 265 ++#define SSL_R_WRONG_SSL_VERSION 266 ++#define SSL_R_WRONG_VERSION_NUMBER 267 ++#define SSL_R_X509_LIB 268 ++#define SSL_R_X509_VERIFICATION_SETUP_PROBLEMS 269 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/ssl2.h qt.patched/include/openssl/ssl2.h +--- qt.orig/include/openssl/ssl2.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/ssl2.h 2010-08-27 12:01:45.665143500 +0200 +@@ -0,0 +1,268 @@ ++/* ssl/ssl2.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_SSL2_H ++#define HEADER_SSL2_H ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* Protocol Version Codes */ ++#define SSL2_VERSION 0x0002 ++#define SSL2_VERSION_MAJOR 0x00 ++#define SSL2_VERSION_MINOR 0x02 ++/* #define SSL2_CLIENT_VERSION 0x0002 */ ++/* #define SSL2_SERVER_VERSION 0x0002 */ ++ ++/* Protocol Message Codes */ ++#define SSL2_MT_ERROR 0 ++#define SSL2_MT_CLIENT_HELLO 1 ++#define SSL2_MT_CLIENT_MASTER_KEY 2 ++#define SSL2_MT_CLIENT_FINISHED 3 ++#define SSL2_MT_SERVER_HELLO 4 ++#define SSL2_MT_SERVER_VERIFY 5 ++#define SSL2_MT_SERVER_FINISHED 6 ++#define SSL2_MT_REQUEST_CERTIFICATE 7 ++#define SSL2_MT_CLIENT_CERTIFICATE 8 ++ ++/* Error Message Codes */ ++#define SSL2_PE_UNDEFINED_ERROR 0x0000 ++#define SSL2_PE_NO_CIPHER 0x0001 ++#define SSL2_PE_NO_CERTIFICATE 0x0002 ++#define SSL2_PE_BAD_CERTIFICATE 0x0004 ++#define SSL2_PE_UNSUPPORTED_CERTIFICATE_TYPE 0x0006 ++ ++/* Cipher Kind Values */ ++#define SSL2_CK_NULL_WITH_MD5 0x02000000 /* v3 */ ++#define SSL2_CK_RC4_128_WITH_MD5 0x02010080 ++#define SSL2_CK_RC4_128_EXPORT40_WITH_MD5 0x02020080 ++#define SSL2_CK_RC2_128_CBC_WITH_MD5 0x02030080 ++#define SSL2_CK_RC2_128_CBC_EXPORT40_WITH_MD5 0x02040080 ++#define SSL2_CK_IDEA_128_CBC_WITH_MD5 0x02050080 ++#define SSL2_CK_DES_64_CBC_WITH_MD5 0x02060040 ++#define SSL2_CK_DES_64_CBC_WITH_SHA 0x02060140 /* v3 */ ++#define SSL2_CK_DES_192_EDE3_CBC_WITH_MD5 0x020700c0 ++#define SSL2_CK_DES_192_EDE3_CBC_WITH_SHA 0x020701c0 /* v3 */ ++#define SSL2_CK_RC4_64_WITH_MD5 0x02080080 /* MS hack */ ++ ++#define SSL2_CK_DES_64_CFB64_WITH_MD5_1 0x02ff0800 /* SSLeay */ ++#define SSL2_CK_NULL 0x02ff0810 /* SSLeay */ ++ ++#define SSL2_TXT_DES_64_CFB64_WITH_MD5_1 "DES-CFB-M1" ++#define SSL2_TXT_NULL_WITH_MD5 "NULL-MD5" ++#define SSL2_TXT_RC4_128_WITH_MD5 "RC4-MD5" ++#define SSL2_TXT_RC4_128_EXPORT40_WITH_MD5 "EXP-RC4-MD5" ++#define SSL2_TXT_RC2_128_CBC_WITH_MD5 "RC2-CBC-MD5" ++#define SSL2_TXT_RC2_128_CBC_EXPORT40_WITH_MD5 "EXP-RC2-CBC-MD5" ++#define SSL2_TXT_IDEA_128_CBC_WITH_MD5 "IDEA-CBC-MD5" ++#define SSL2_TXT_DES_64_CBC_WITH_MD5 "DES-CBC-MD5" ++#define SSL2_TXT_DES_64_CBC_WITH_SHA "DES-CBC-SHA" ++#define SSL2_TXT_DES_192_EDE3_CBC_WITH_MD5 "DES-CBC3-MD5" ++#define SSL2_TXT_DES_192_EDE3_CBC_WITH_SHA "DES-CBC3-SHA" ++#define SSL2_TXT_RC4_64_WITH_MD5 "RC4-64-MD5" ++ ++#define SSL2_TXT_NULL "NULL" ++ ++/* Flags for the SSL_CIPHER.algorithm2 field */ ++#define SSL2_CF_5_BYTE_ENC 0x01 ++#define SSL2_CF_8_BYTE_ENC 0x02 ++ ++/* Certificate Type Codes */ ++#define SSL2_CT_X509_CERTIFICATE 0x01 ++ ++/* Authentication Type Code */ ++#define SSL2_AT_MD5_WITH_RSA_ENCRYPTION 0x01 ++ ++#define SSL2_MAX_SSL_SESSION_ID_LENGTH 32 ++ ++/* Upper/Lower Bounds */ ++#define SSL2_MAX_MASTER_KEY_LENGTH_IN_BITS 256 ++#ifdef OPENSSL_SYS_MPE ++#define SSL2_MAX_RECORD_LENGTH_2_BYTE_HEADER 29998u ++#else ++#define SSL2_MAX_RECORD_LENGTH_2_BYTE_HEADER 32767u /* 2^15-1 */ ++#endif ++#define SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER 16383 /* 2^14-1 */ ++ ++#define SSL2_CHALLENGE_LENGTH 16 ++/*#define SSL2_CHALLENGE_LENGTH 32 */ ++#define SSL2_MIN_CHALLENGE_LENGTH 16 ++#define SSL2_MAX_CHALLENGE_LENGTH 32 ++#define SSL2_CONNECTION_ID_LENGTH 16 ++#define SSL2_MAX_CONNECTION_ID_LENGTH 16 ++#define SSL2_SSL_SESSION_ID_LENGTH 16 ++#define SSL2_MAX_CERT_CHALLENGE_LENGTH 32 ++#define SSL2_MIN_CERT_CHALLENGE_LENGTH 16 ++#define SSL2_MAX_KEY_MATERIAL_LENGTH 24 ++ ++#ifndef HEADER_SSL_LOCL_H ++#define CERT char ++#endif ++ ++typedef struct ssl2_state_st ++ { ++ int three_byte_header; ++ int clear_text; /* clear text */ ++ int escape; /* not used in SSLv2 */ ++ int ssl2_rollback; /* used if SSLv23 rolled back to SSLv2 */ ++ ++ /* non-blocking io info, used to make sure the same ++ * args were passwd */ ++ unsigned int wnum; /* number of bytes sent so far */ ++ int wpend_tot; ++ const unsigned char *wpend_buf; ++ ++ int wpend_off; /* offset to data to write */ ++ int wpend_len; /* number of bytes passwd to write */ ++ int wpend_ret; /* number of bytes to return to caller */ ++ ++ /* buffer raw data */ ++ int rbuf_left; ++ int rbuf_offs; ++ unsigned char *rbuf; ++ unsigned char *wbuf; ++ ++ unsigned char *write_ptr;/* used to point to the start due to ++ * 2/3 byte header. */ ++ ++ unsigned int padding; ++ unsigned int rlength; /* passed to ssl2_enc */ ++ int ract_data_length; /* Set when things are encrypted. */ ++ unsigned int wlength; /* passed to ssl2_enc */ ++ int wact_data_length; /* Set when things are decrypted. */ ++ unsigned char *ract_data; ++ unsigned char *wact_data; ++ unsigned char *mac_data; ++ ++ unsigned char *read_key; ++ unsigned char *write_key; ++ ++ /* Stuff specifically to do with this SSL session */ ++ unsigned int challenge_length; ++ unsigned char challenge[SSL2_MAX_CHALLENGE_LENGTH]; ++ unsigned int conn_id_length; ++ unsigned char conn_id[SSL2_MAX_CONNECTION_ID_LENGTH]; ++ unsigned int key_material_length; ++ unsigned char key_material[SSL2_MAX_KEY_MATERIAL_LENGTH*2]; ++ ++ unsigned long read_sequence; ++ unsigned long write_sequence; ++ ++ struct { ++ unsigned int conn_id_length; ++ unsigned int cert_type; ++ unsigned int cert_length; ++ unsigned int csl; ++ unsigned int clear; ++ unsigned int enc; ++ unsigned char ccl[SSL2_MAX_CERT_CHALLENGE_LENGTH]; ++ unsigned int cipher_spec_length; ++ unsigned int session_id_length; ++ unsigned int clen; ++ unsigned int rlen; ++ } tmp; ++ } SSL2_STATE; ++ ++/* SSLv2 */ ++/* client */ ++#define SSL2_ST_SEND_CLIENT_HELLO_A (0x10|SSL_ST_CONNECT) ++#define SSL2_ST_SEND_CLIENT_HELLO_B (0x11|SSL_ST_CONNECT) ++#define SSL2_ST_GET_SERVER_HELLO_A (0x20|SSL_ST_CONNECT) ++#define SSL2_ST_GET_SERVER_HELLO_B (0x21|SSL_ST_CONNECT) ++#define SSL2_ST_SEND_CLIENT_MASTER_KEY_A (0x30|SSL_ST_CONNECT) ++#define SSL2_ST_SEND_CLIENT_MASTER_KEY_B (0x31|SSL_ST_CONNECT) ++#define SSL2_ST_SEND_CLIENT_FINISHED_A (0x40|SSL_ST_CONNECT) ++#define SSL2_ST_SEND_CLIENT_FINISHED_B (0x41|SSL_ST_CONNECT) ++#define SSL2_ST_SEND_CLIENT_CERTIFICATE_A (0x50|SSL_ST_CONNECT) ++#define SSL2_ST_SEND_CLIENT_CERTIFICATE_B (0x51|SSL_ST_CONNECT) ++#define SSL2_ST_SEND_CLIENT_CERTIFICATE_C (0x52|SSL_ST_CONNECT) ++#define SSL2_ST_SEND_CLIENT_CERTIFICATE_D (0x53|SSL_ST_CONNECT) ++#define SSL2_ST_GET_SERVER_VERIFY_A (0x60|SSL_ST_CONNECT) ++#define SSL2_ST_GET_SERVER_VERIFY_B (0x61|SSL_ST_CONNECT) ++#define SSL2_ST_GET_SERVER_FINISHED_A (0x70|SSL_ST_CONNECT) ++#define SSL2_ST_GET_SERVER_FINISHED_B (0x71|SSL_ST_CONNECT) ++#define SSL2_ST_CLIENT_START_ENCRYPTION (0x80|SSL_ST_CONNECT) ++#define SSL2_ST_X509_GET_CLIENT_CERTIFICATE (0x90|SSL_ST_CONNECT) ++/* server */ ++#define SSL2_ST_GET_CLIENT_HELLO_A (0x10|SSL_ST_ACCEPT) ++#define SSL2_ST_GET_CLIENT_HELLO_B (0x11|SSL_ST_ACCEPT) ++#define SSL2_ST_GET_CLIENT_HELLO_C (0x12|SSL_ST_ACCEPT) ++#define SSL2_ST_SEND_SERVER_HELLO_A (0x20|SSL_ST_ACCEPT) ++#define SSL2_ST_SEND_SERVER_HELLO_B (0x21|SSL_ST_ACCEPT) ++#define SSL2_ST_GET_CLIENT_MASTER_KEY_A (0x30|SSL_ST_ACCEPT) ++#define SSL2_ST_GET_CLIENT_MASTER_KEY_B (0x31|SSL_ST_ACCEPT) ++#define SSL2_ST_SEND_SERVER_VERIFY_A (0x40|SSL_ST_ACCEPT) ++#define SSL2_ST_SEND_SERVER_VERIFY_B (0x41|SSL_ST_ACCEPT) ++#define SSL2_ST_SEND_SERVER_VERIFY_C (0x42|SSL_ST_ACCEPT) ++#define SSL2_ST_GET_CLIENT_FINISHED_A (0x50|SSL_ST_ACCEPT) ++#define SSL2_ST_GET_CLIENT_FINISHED_B (0x51|SSL_ST_ACCEPT) ++#define SSL2_ST_SEND_SERVER_FINISHED_A (0x60|SSL_ST_ACCEPT) ++#define SSL2_ST_SEND_SERVER_FINISHED_B (0x61|SSL_ST_ACCEPT) ++#define SSL2_ST_SEND_REQUEST_CERTIFICATE_A (0x70|SSL_ST_ACCEPT) ++#define SSL2_ST_SEND_REQUEST_CERTIFICATE_B (0x71|SSL_ST_ACCEPT) ++#define SSL2_ST_SEND_REQUEST_CERTIFICATE_C (0x72|SSL_ST_ACCEPT) ++#define SSL2_ST_SEND_REQUEST_CERTIFICATE_D (0x73|SSL_ST_ACCEPT) ++#define SSL2_ST_SERVER_START_ENCRYPTION (0x80|SSL_ST_ACCEPT) ++#define SSL2_ST_X509_GET_SERVER_CERTIFICATE (0x90|SSL_ST_ACCEPT) ++ ++#ifdef __cplusplus ++} ++#endif ++#endif ++ +diff -urN qt.orig/include/openssl/ssl23.h qt.patched/include/openssl/ssl23.h +--- qt.orig/include/openssl/ssl23.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/ssl23.h 2010-08-27 12:01:45.680767900 +0200 +@@ -0,0 +1,83 @@ ++/* ssl/ssl23.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_SSL23_H ++#define HEADER_SSL23_H ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/*client */ ++/* write to server */ ++#define SSL23_ST_CW_CLNT_HELLO_A (0x210|SSL_ST_CONNECT) ++#define SSL23_ST_CW_CLNT_HELLO_B (0x211|SSL_ST_CONNECT) ++/* read from server */ ++#define SSL23_ST_CR_SRVR_HELLO_A (0x220|SSL_ST_CONNECT) ++#define SSL23_ST_CR_SRVR_HELLO_B (0x221|SSL_ST_CONNECT) ++ ++/* server */ ++/* read from client */ ++#define SSL23_ST_SR_CLNT_HELLO_A (0x210|SSL_ST_ACCEPT) ++#define SSL23_ST_SR_CLNT_HELLO_B (0x211|SSL_ST_ACCEPT) ++ ++#ifdef __cplusplus ++} ++#endif ++#endif ++ +diff -urN qt.orig/include/openssl/ssl3.h qt.patched/include/openssl/ssl3.h +--- qt.orig/include/openssl/ssl3.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/ssl3.h 2010-08-27 12:01:45.680767900 +0200 +@@ -0,0 +1,637 @@ ++/* ssl/ssl3.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++/* ==================================================================== ++ * Copyright (c) 1998-2002 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * openssl-core@openssl.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.openssl.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++/* ==================================================================== ++ * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. ++ * ECC cipher suite support in OpenSSL originally developed by ++ * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project. ++ */ ++ ++#ifndef HEADER_SSL3_H ++#define HEADER_SSL3_H ++ ++#ifndef OPENSSL_NO_COMP ++#include ++#endif ++#include ++#include ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* Signalling cipher suite value: from draft-ietf-tls-renegotiation-03.txt */ ++#define SSL3_CK_SCSV 0x030000FF ++ ++#define SSL3_CK_RSA_NULL_MD5 0x03000001 ++#define SSL3_CK_RSA_NULL_SHA 0x03000002 ++#define SSL3_CK_RSA_RC4_40_MD5 0x03000003 ++#define SSL3_CK_RSA_RC4_128_MD5 0x03000004 ++#define SSL3_CK_RSA_RC4_128_SHA 0x03000005 ++#define SSL3_CK_RSA_RC2_40_MD5 0x03000006 ++#define SSL3_CK_RSA_IDEA_128_SHA 0x03000007 ++#define SSL3_CK_RSA_DES_40_CBC_SHA 0x03000008 ++#define SSL3_CK_RSA_DES_64_CBC_SHA 0x03000009 ++#define SSL3_CK_RSA_DES_192_CBC3_SHA 0x0300000A ++ ++#define SSL3_CK_DH_DSS_DES_40_CBC_SHA 0x0300000B ++#define SSL3_CK_DH_DSS_DES_64_CBC_SHA 0x0300000C ++#define SSL3_CK_DH_DSS_DES_192_CBC3_SHA 0x0300000D ++#define SSL3_CK_DH_RSA_DES_40_CBC_SHA 0x0300000E ++#define SSL3_CK_DH_RSA_DES_64_CBC_SHA 0x0300000F ++#define SSL3_CK_DH_RSA_DES_192_CBC3_SHA 0x03000010 ++ ++#define SSL3_CK_EDH_DSS_DES_40_CBC_SHA 0x03000011 ++#define SSL3_CK_EDH_DSS_DES_64_CBC_SHA 0x03000012 ++#define SSL3_CK_EDH_DSS_DES_192_CBC3_SHA 0x03000013 ++#define SSL3_CK_EDH_RSA_DES_40_CBC_SHA 0x03000014 ++#define SSL3_CK_EDH_RSA_DES_64_CBC_SHA 0x03000015 ++#define SSL3_CK_EDH_RSA_DES_192_CBC3_SHA 0x03000016 ++ ++#define SSL3_CK_ADH_RC4_40_MD5 0x03000017 ++#define SSL3_CK_ADH_RC4_128_MD5 0x03000018 ++#define SSL3_CK_ADH_DES_40_CBC_SHA 0x03000019 ++#define SSL3_CK_ADH_DES_64_CBC_SHA 0x0300001A ++#define SSL3_CK_ADH_DES_192_CBC_SHA 0x0300001B ++ ++#if 0 ++ #define SSL3_CK_FZA_DMS_NULL_SHA 0x0300001C ++ #define SSL3_CK_FZA_DMS_FZA_SHA 0x0300001D ++ #if 0 /* Because it clashes with KRB5, is never used any more, and is safe ++ to remove according to David Hopwood ++ of the ietf-tls list */ ++ #define SSL3_CK_FZA_DMS_RC4_SHA 0x0300001E ++ #endif ++#endif ++ ++/* VRS Additional Kerberos5 entries ++ */ ++#define SSL3_CK_KRB5_DES_64_CBC_SHA 0x0300001E ++#define SSL3_CK_KRB5_DES_192_CBC3_SHA 0x0300001F ++#define SSL3_CK_KRB5_RC4_128_SHA 0x03000020 ++#define SSL3_CK_KRB5_IDEA_128_CBC_SHA 0x03000021 ++#define SSL3_CK_KRB5_DES_64_CBC_MD5 0x03000022 ++#define SSL3_CK_KRB5_DES_192_CBC3_MD5 0x03000023 ++#define SSL3_CK_KRB5_RC4_128_MD5 0x03000024 ++#define SSL3_CK_KRB5_IDEA_128_CBC_MD5 0x03000025 ++ ++#define SSL3_CK_KRB5_DES_40_CBC_SHA 0x03000026 ++#define SSL3_CK_KRB5_RC2_40_CBC_SHA 0x03000027 ++#define SSL3_CK_KRB5_RC4_40_SHA 0x03000028 ++#define SSL3_CK_KRB5_DES_40_CBC_MD5 0x03000029 ++#define SSL3_CK_KRB5_RC2_40_CBC_MD5 0x0300002A ++#define SSL3_CK_KRB5_RC4_40_MD5 0x0300002B ++ ++#define SSL3_TXT_RSA_NULL_MD5 "NULL-MD5" ++#define SSL3_TXT_RSA_NULL_SHA "NULL-SHA" ++#define SSL3_TXT_RSA_RC4_40_MD5 "EXP-RC4-MD5" ++#define SSL3_TXT_RSA_RC4_128_MD5 "RC4-MD5" ++#define SSL3_TXT_RSA_RC4_128_SHA "RC4-SHA" ++#define SSL3_TXT_RSA_RC2_40_MD5 "EXP-RC2-CBC-MD5" ++#define SSL3_TXT_RSA_IDEA_128_SHA "IDEA-CBC-SHA" ++#define SSL3_TXT_RSA_DES_40_CBC_SHA "EXP-DES-CBC-SHA" ++#define SSL3_TXT_RSA_DES_64_CBC_SHA "DES-CBC-SHA" ++#define SSL3_TXT_RSA_DES_192_CBC3_SHA "DES-CBC3-SHA" ++ ++#define SSL3_TXT_DH_DSS_DES_40_CBC_SHA "EXP-DH-DSS-DES-CBC-SHA" ++#define SSL3_TXT_DH_DSS_DES_64_CBC_SHA "DH-DSS-DES-CBC-SHA" ++#define SSL3_TXT_DH_DSS_DES_192_CBC3_SHA "DH-DSS-DES-CBC3-SHA" ++#define SSL3_TXT_DH_RSA_DES_40_CBC_SHA "EXP-DH-RSA-DES-CBC-SHA" ++#define SSL3_TXT_DH_RSA_DES_64_CBC_SHA "DH-RSA-DES-CBC-SHA" ++#define SSL3_TXT_DH_RSA_DES_192_CBC3_SHA "DH-RSA-DES-CBC3-SHA" ++ ++#define SSL3_TXT_EDH_DSS_DES_40_CBC_SHA "EXP-EDH-DSS-DES-CBC-SHA" ++#define SSL3_TXT_EDH_DSS_DES_64_CBC_SHA "EDH-DSS-DES-CBC-SHA" ++#define SSL3_TXT_EDH_DSS_DES_192_CBC3_SHA "EDH-DSS-DES-CBC3-SHA" ++#define SSL3_TXT_EDH_RSA_DES_40_CBC_SHA "EXP-EDH-RSA-DES-CBC-SHA" ++#define SSL3_TXT_EDH_RSA_DES_64_CBC_SHA "EDH-RSA-DES-CBC-SHA" ++#define SSL3_TXT_EDH_RSA_DES_192_CBC3_SHA "EDH-RSA-DES-CBC3-SHA" ++ ++#define SSL3_TXT_ADH_RC4_40_MD5 "EXP-ADH-RC4-MD5" ++#define SSL3_TXT_ADH_RC4_128_MD5 "ADH-RC4-MD5" ++#define SSL3_TXT_ADH_DES_40_CBC_SHA "EXP-ADH-DES-CBC-SHA" ++#define SSL3_TXT_ADH_DES_64_CBC_SHA "ADH-DES-CBC-SHA" ++#define SSL3_TXT_ADH_DES_192_CBC_SHA "ADH-DES-CBC3-SHA" ++ ++#if 0 ++ #define SSL3_TXT_FZA_DMS_NULL_SHA "FZA-NULL-SHA" ++ #define SSL3_TXT_FZA_DMS_FZA_SHA "FZA-FZA-CBC-SHA" ++ #define SSL3_TXT_FZA_DMS_RC4_SHA "FZA-RC4-SHA" ++#endif ++ ++#define SSL3_TXT_KRB5_DES_64_CBC_SHA "KRB5-DES-CBC-SHA" ++#define SSL3_TXT_KRB5_DES_192_CBC3_SHA "KRB5-DES-CBC3-SHA" ++#define SSL3_TXT_KRB5_RC4_128_SHA "KRB5-RC4-SHA" ++#define SSL3_TXT_KRB5_IDEA_128_CBC_SHA "KRB5-IDEA-CBC-SHA" ++#define SSL3_TXT_KRB5_DES_64_CBC_MD5 "KRB5-DES-CBC-MD5" ++#define SSL3_TXT_KRB5_DES_192_CBC3_MD5 "KRB5-DES-CBC3-MD5" ++#define SSL3_TXT_KRB5_RC4_128_MD5 "KRB5-RC4-MD5" ++#define SSL3_TXT_KRB5_IDEA_128_CBC_MD5 "KRB5-IDEA-CBC-MD5" ++ ++#define SSL3_TXT_KRB5_DES_40_CBC_SHA "EXP-KRB5-DES-CBC-SHA" ++#define SSL3_TXT_KRB5_RC2_40_CBC_SHA "EXP-KRB5-RC2-CBC-SHA" ++#define SSL3_TXT_KRB5_RC4_40_SHA "EXP-KRB5-RC4-SHA" ++#define SSL3_TXT_KRB5_DES_40_CBC_MD5 "EXP-KRB5-DES-CBC-MD5" ++#define SSL3_TXT_KRB5_RC2_40_CBC_MD5 "EXP-KRB5-RC2-CBC-MD5" ++#define SSL3_TXT_KRB5_RC4_40_MD5 "EXP-KRB5-RC4-MD5" ++ ++#define SSL3_SSL_SESSION_ID_LENGTH 32 ++#define SSL3_MAX_SSL_SESSION_ID_LENGTH 32 ++ ++#define SSL3_MASTER_SECRET_SIZE 48 ++#define SSL3_RANDOM_SIZE 32 ++#define SSL3_SESSION_ID_SIZE 32 ++#define SSL3_RT_HEADER_LENGTH 5 ++ ++#ifndef SSL3_ALIGN_PAYLOAD ++ /* Some will argue that this increases memory footprint, but it's ++ * not actually true. Point is that malloc has to return at least ++ * 64-bit aligned pointers, meaning that allocating 5 bytes wastes ++ * 3 bytes in either case. Suggested pre-gaping simply moves these ++ * wasted bytes from the end of allocated region to its front, ++ * but makes data payload aligned, which improves performance:-) */ ++# define SSL3_ALIGN_PAYLOAD 8 ++#else ++# if (SSL3_ALIGN_PAYLOAD&(SSL3_ALIGN_PAYLOAD-1))!=0 ++# error "insane SSL3_ALIGN_PAYLOAD" ++# undef SSL3_ALIGN_PAYLOAD ++# endif ++#endif ++ ++/* This is the maximum MAC (digest) size used by the SSL library. ++ * Currently maximum of 20 is used by SHA1, but we reserve for ++ * future extension for 512-bit hashes. ++ */ ++ ++#define SSL3_RT_MAX_MD_SIZE 64 ++ ++/* Maximum block size used in all ciphersuites. Currently 16 for AES. ++ */ ++ ++#define SSL_RT_MAX_CIPHER_BLOCK_SIZE 16 ++ ++#define SSL3_RT_MAX_EXTRA (16384) ++ ++/* Maximum plaintext length: defined by SSL/TLS standards */ ++#define SSL3_RT_MAX_PLAIN_LENGTH 16384 ++/* Maximum compression overhead: defined by SSL/TLS standards */ ++#define SSL3_RT_MAX_COMPRESSED_OVERHEAD 1024 ++ ++/* The standards give a maximum encryption overhead of 1024 bytes. ++ * In practice the value is lower than this. The overhead is the maximum ++ * number of padding bytes (256) plus the mac size. ++ */ ++#define SSL3_RT_MAX_ENCRYPTED_OVERHEAD (256 + SSL3_RT_MAX_MD_SIZE) ++ ++/* OpenSSL currently only uses a padding length of at most one block so ++ * the send overhead is smaller. ++ */ ++ ++#define SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD \ ++ (SSL_RT_MAX_CIPHER_BLOCK_SIZE + SSL3_RT_MAX_MD_SIZE) ++ ++/* If compression isn't used don't include the compression overhead */ ++ ++#ifdef OPENSSL_NO_COMP ++#define SSL3_RT_MAX_COMPRESSED_LENGTH SSL3_RT_MAX_PLAIN_LENGTH ++#else ++#define SSL3_RT_MAX_COMPRESSED_LENGTH \ ++ (SSL3_RT_MAX_PLAIN_LENGTH+SSL3_RT_MAX_COMPRESSED_OVERHEAD) ++#endif ++#define SSL3_RT_MAX_ENCRYPTED_LENGTH \ ++ (SSL3_RT_MAX_ENCRYPTED_OVERHEAD+SSL3_RT_MAX_COMPRESSED_LENGTH) ++#define SSL3_RT_MAX_PACKET_SIZE \ ++ (SSL3_RT_MAX_ENCRYPTED_LENGTH+SSL3_RT_HEADER_LENGTH) ++ ++#define SSL3_MD_CLIENT_FINISHED_CONST "\x43\x4C\x4E\x54" ++#define SSL3_MD_SERVER_FINISHED_CONST "\x53\x52\x56\x52" ++ ++#define SSL3_VERSION 0x0300 ++#define SSL3_VERSION_MAJOR 0x03 ++#define SSL3_VERSION_MINOR 0x00 ++ ++#define SSL3_RT_CHANGE_CIPHER_SPEC 20 ++#define SSL3_RT_ALERT 21 ++#define SSL3_RT_HANDSHAKE 22 ++#define SSL3_RT_APPLICATION_DATA 23 ++ ++#define SSL3_AL_WARNING 1 ++#define SSL3_AL_FATAL 2 ++ ++#define SSL3_AD_CLOSE_NOTIFY 0 ++#define SSL3_AD_UNEXPECTED_MESSAGE 10 /* fatal */ ++#define SSL3_AD_BAD_RECORD_MAC 20 /* fatal */ ++#define SSL3_AD_DECOMPRESSION_FAILURE 30 /* fatal */ ++#define SSL3_AD_HANDSHAKE_FAILURE 40 /* fatal */ ++#define SSL3_AD_NO_CERTIFICATE 41 ++#define SSL3_AD_BAD_CERTIFICATE 42 ++#define SSL3_AD_UNSUPPORTED_CERTIFICATE 43 ++#define SSL3_AD_CERTIFICATE_REVOKED 44 ++#define SSL3_AD_CERTIFICATE_EXPIRED 45 ++#define SSL3_AD_CERTIFICATE_UNKNOWN 46 ++#define SSL3_AD_ILLEGAL_PARAMETER 47 /* fatal */ ++ ++typedef struct ssl3_record_st ++ { ++/*r */ int type; /* type of record */ ++/*rw*/ unsigned int length; /* How many bytes available */ ++/*r */ unsigned int off; /* read/write offset into 'buf' */ ++/*rw*/ unsigned char *data; /* pointer to the record data */ ++/*rw*/ unsigned char *input; /* where the decode bytes are */ ++/*r */ unsigned char *comp; /* only used with decompression - malloc()ed */ ++/*r */ unsigned long epoch; /* epoch number, needed by DTLS1 */ ++/*r */ unsigned char seq_num[8]; /* sequence number, needed by DTLS1 */ ++ } SSL3_RECORD; ++ ++typedef struct ssl3_buffer_st ++ { ++ unsigned char *buf; /* at least SSL3_RT_MAX_PACKET_SIZE bytes, ++ * see ssl3_setup_buffers() */ ++ size_t len; /* buffer size */ ++ int offset; /* where to 'copy from' */ ++ int left; /* how many bytes left */ ++ } SSL3_BUFFER; ++ ++#define SSL3_CT_RSA_SIGN 1 ++#define SSL3_CT_DSS_SIGN 2 ++#define SSL3_CT_RSA_FIXED_DH 3 ++#define SSL3_CT_DSS_FIXED_DH 4 ++#define SSL3_CT_RSA_EPHEMERAL_DH 5 ++#define SSL3_CT_DSS_EPHEMERAL_DH 6 ++#define SSL3_CT_FORTEZZA_DMS 20 ++/* SSL3_CT_NUMBER is used to size arrays and it must be large ++ * enough to contain all of the cert types defined either for ++ * SSLv3 and TLSv1. ++ */ ++#define SSL3_CT_NUMBER 9 ++ ++ ++#define SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS 0x0001 ++#define SSL3_FLAGS_DELAY_CLIENT_FINISHED 0x0002 ++#define SSL3_FLAGS_POP_BUFFER 0x0004 ++#define TLS1_FLAGS_TLS_PADDING_BUG 0x0008 ++#define TLS1_FLAGS_SKIP_CERT_VERIFY 0x0010 ++ ++typedef struct ssl3_state_st ++ { ++ long flags; ++ int delay_buf_pop_ret; ++ ++ unsigned char read_sequence[8]; ++ int read_mac_secret_size; ++ unsigned char read_mac_secret[EVP_MAX_MD_SIZE]; ++ unsigned char write_sequence[8]; ++ int write_mac_secret_size; ++ unsigned char write_mac_secret[EVP_MAX_MD_SIZE]; ++ ++ unsigned char server_random[SSL3_RANDOM_SIZE]; ++ unsigned char client_random[SSL3_RANDOM_SIZE]; ++ ++ /* flags for countermeasure against known-IV weakness */ ++ int need_empty_fragments; ++ int empty_fragment_done; ++ ++ /* The value of 'extra' when the buffers were initialized */ ++ int init_extra; ++ ++ SSL3_BUFFER rbuf; /* read IO goes into here */ ++ SSL3_BUFFER wbuf; /* write IO goes into here */ ++ ++ SSL3_RECORD rrec; /* each decoded record goes in here */ ++ SSL3_RECORD wrec; /* goes out from here */ ++ ++ /* storage for Alert/Handshake protocol data received but not ++ * yet processed by ssl3_read_bytes: */ ++ unsigned char alert_fragment[2]; ++ unsigned int alert_fragment_len; ++ unsigned char handshake_fragment[4]; ++ unsigned int handshake_fragment_len; ++ ++ /* partial write - check the numbers match */ ++ unsigned int wnum; /* number of bytes sent so far */ ++ int wpend_tot; /* number bytes written */ ++ int wpend_type; ++ int wpend_ret; /* number of bytes submitted */ ++ const unsigned char *wpend_buf; ++ ++ /* used during startup, digest all incoming/outgoing packets */ ++ BIO *handshake_buffer; ++ /* When set of handshake digests is determined, buffer is hashed ++ * and freed and MD_CTX-es for all required digests are stored in ++ * this array */ ++ EVP_MD_CTX **handshake_dgst; ++ /* this is set whenerver we see a change_cipher_spec message ++ * come in when we are not looking for one */ ++ int change_cipher_spec; ++ ++ int warn_alert; ++ int fatal_alert; ++ /* we allow one fatal and one warning alert to be outstanding, ++ * send close alert via the warning alert */ ++ int alert_dispatch; ++ unsigned char send_alert[2]; ++ ++ /* This flag is set when we should renegotiate ASAP, basically when ++ * there is no more data in the read or write buffers */ ++ int renegotiate; ++ int total_renegotiations; ++ int num_renegotiations; ++ ++ int in_read_app_data; ++ ++ /* Opaque PRF input as used for the current handshake. ++ * These fields are used only if TLSEXT_TYPE_opaque_prf_input is defined ++ * (otherwise, they are merely present to improve binary compatibility) */ ++ void *client_opaque_prf_input; ++ size_t client_opaque_prf_input_len; ++ void *server_opaque_prf_input; ++ size_t server_opaque_prf_input_len; ++ ++ struct { ++ /* actually only needs to be 16+20 */ ++ unsigned char cert_verify_md[EVP_MAX_MD_SIZE*2]; ++ ++ /* actually only need to be 16+20 for SSLv3 and 12 for TLS */ ++ unsigned char finish_md[EVP_MAX_MD_SIZE*2]; ++ int finish_md_len; ++ unsigned char peer_finish_md[EVP_MAX_MD_SIZE*2]; ++ int peer_finish_md_len; ++ ++ unsigned long message_size; ++ int message_type; ++ ++ /* used to hold the new cipher we are going to use */ ++ const SSL_CIPHER *new_cipher; ++#ifndef OPENSSL_NO_DH ++ DH *dh; ++#endif ++ ++#ifndef OPENSSL_NO_ECDH ++ EC_KEY *ecdh; /* holds short lived ECDH key */ ++#endif ++ ++ /* used when SSL_ST_FLUSH_DATA is entered */ ++ int next_state; ++ ++ int reuse_message; ++ ++ /* used for certificate requests */ ++ int cert_req; ++ int ctype_num; ++ char ctype[SSL3_CT_NUMBER]; ++ STACK_OF(X509_NAME) *ca_names; ++ ++ int use_rsa_tmp; ++ ++ int key_block_length; ++ unsigned char *key_block; ++ ++ const EVP_CIPHER *new_sym_enc; ++ const EVP_MD *new_hash; ++ int new_mac_pkey_type; ++ int new_mac_secret_size; ++#ifndef OPENSSL_NO_COMP ++ const SSL_COMP *new_compression; ++#else ++ char *new_compression; ++#endif ++ int cert_request; ++ } tmp; ++ ++ /* Connection binding to prevent renegotiation attacks */ ++ unsigned char previous_client_finished[EVP_MAX_MD_SIZE]; ++ unsigned char previous_client_finished_len; ++ unsigned char previous_server_finished[EVP_MAX_MD_SIZE]; ++ unsigned char previous_server_finished_len; ++ int send_connection_binding; /* TODOEKR */ ++ } SSL3_STATE; ++ ++ ++/* SSLv3 */ ++/*client */ ++/* extra state */ ++#define SSL3_ST_CW_FLUSH (0x100|SSL_ST_CONNECT) ++/* write to server */ ++#define SSL3_ST_CW_CLNT_HELLO_A (0x110|SSL_ST_CONNECT) ++#define SSL3_ST_CW_CLNT_HELLO_B (0x111|SSL_ST_CONNECT) ++/* read from server */ ++#define SSL3_ST_CR_SRVR_HELLO_A (0x120|SSL_ST_CONNECT) ++#define SSL3_ST_CR_SRVR_HELLO_B (0x121|SSL_ST_CONNECT) ++#define DTLS1_ST_CR_HELLO_VERIFY_REQUEST_A (0x126|SSL_ST_CONNECT) ++#define DTLS1_ST_CR_HELLO_VERIFY_REQUEST_B (0x127|SSL_ST_CONNECT) ++#define SSL3_ST_CR_CERT_A (0x130|SSL_ST_CONNECT) ++#define SSL3_ST_CR_CERT_B (0x131|SSL_ST_CONNECT) ++#define SSL3_ST_CR_KEY_EXCH_A (0x140|SSL_ST_CONNECT) ++#define SSL3_ST_CR_KEY_EXCH_B (0x141|SSL_ST_CONNECT) ++#define SSL3_ST_CR_CERT_REQ_A (0x150|SSL_ST_CONNECT) ++#define SSL3_ST_CR_CERT_REQ_B (0x151|SSL_ST_CONNECT) ++#define SSL3_ST_CR_SRVR_DONE_A (0x160|SSL_ST_CONNECT) ++#define SSL3_ST_CR_SRVR_DONE_B (0x161|SSL_ST_CONNECT) ++/* write to server */ ++#define SSL3_ST_CW_CERT_A (0x170|SSL_ST_CONNECT) ++#define SSL3_ST_CW_CERT_B (0x171|SSL_ST_CONNECT) ++#define SSL3_ST_CW_CERT_C (0x172|SSL_ST_CONNECT) ++#define SSL3_ST_CW_CERT_D (0x173|SSL_ST_CONNECT) ++#define SSL3_ST_CW_KEY_EXCH_A (0x180|SSL_ST_CONNECT) ++#define SSL3_ST_CW_KEY_EXCH_B (0x181|SSL_ST_CONNECT) ++#define SSL3_ST_CW_CERT_VRFY_A (0x190|SSL_ST_CONNECT) ++#define SSL3_ST_CW_CERT_VRFY_B (0x191|SSL_ST_CONNECT) ++#define SSL3_ST_CW_CHANGE_A (0x1A0|SSL_ST_CONNECT) ++#define SSL3_ST_CW_CHANGE_B (0x1A1|SSL_ST_CONNECT) ++#define SSL3_ST_CW_FINISHED_A (0x1B0|SSL_ST_CONNECT) ++#define SSL3_ST_CW_FINISHED_B (0x1B1|SSL_ST_CONNECT) ++/* read from server */ ++#define SSL3_ST_CR_CHANGE_A (0x1C0|SSL_ST_CONNECT) ++#define SSL3_ST_CR_CHANGE_B (0x1C1|SSL_ST_CONNECT) ++#define SSL3_ST_CR_FINISHED_A (0x1D0|SSL_ST_CONNECT) ++#define SSL3_ST_CR_FINISHED_B (0x1D1|SSL_ST_CONNECT) ++#define SSL3_ST_CR_SESSION_TICKET_A (0x1E0|SSL_ST_CONNECT) ++#define SSL3_ST_CR_SESSION_TICKET_B (0x1E1|SSL_ST_CONNECT) ++#define SSL3_ST_CR_CERT_STATUS_A (0x1F0|SSL_ST_CONNECT) ++#define SSL3_ST_CR_CERT_STATUS_B (0x1F1|SSL_ST_CONNECT) ++ ++/* server */ ++/* extra state */ ++#define SSL3_ST_SW_FLUSH (0x100|SSL_ST_ACCEPT) ++/* read from client */ ++/* Do not change the number values, they do matter */ ++#define SSL3_ST_SR_CLNT_HELLO_A (0x110|SSL_ST_ACCEPT) ++#define SSL3_ST_SR_CLNT_HELLO_B (0x111|SSL_ST_ACCEPT) ++#define SSL3_ST_SR_CLNT_HELLO_C (0x112|SSL_ST_ACCEPT) ++/* write to client */ ++#define DTLS1_ST_SW_HELLO_VERIFY_REQUEST_A (0x113|SSL_ST_ACCEPT) ++#define DTLS1_ST_SW_HELLO_VERIFY_REQUEST_B (0x114|SSL_ST_ACCEPT) ++#define SSL3_ST_SW_HELLO_REQ_A (0x120|SSL_ST_ACCEPT) ++#define SSL3_ST_SW_HELLO_REQ_B (0x121|SSL_ST_ACCEPT) ++#define SSL3_ST_SW_HELLO_REQ_C (0x122|SSL_ST_ACCEPT) ++#define SSL3_ST_SW_SRVR_HELLO_A (0x130|SSL_ST_ACCEPT) ++#define SSL3_ST_SW_SRVR_HELLO_B (0x131|SSL_ST_ACCEPT) ++#define SSL3_ST_SW_CERT_A (0x140|SSL_ST_ACCEPT) ++#define SSL3_ST_SW_CERT_B (0x141|SSL_ST_ACCEPT) ++#define SSL3_ST_SW_KEY_EXCH_A (0x150|SSL_ST_ACCEPT) ++#define SSL3_ST_SW_KEY_EXCH_B (0x151|SSL_ST_ACCEPT) ++#define SSL3_ST_SW_CERT_REQ_A (0x160|SSL_ST_ACCEPT) ++#define SSL3_ST_SW_CERT_REQ_B (0x161|SSL_ST_ACCEPT) ++#define SSL3_ST_SW_SRVR_DONE_A (0x170|SSL_ST_ACCEPT) ++#define SSL3_ST_SW_SRVR_DONE_B (0x171|SSL_ST_ACCEPT) ++/* read from client */ ++#define SSL3_ST_SR_CERT_A (0x180|SSL_ST_ACCEPT) ++#define SSL3_ST_SR_CERT_B (0x181|SSL_ST_ACCEPT) ++#define SSL3_ST_SR_KEY_EXCH_A (0x190|SSL_ST_ACCEPT) ++#define SSL3_ST_SR_KEY_EXCH_B (0x191|SSL_ST_ACCEPT) ++#define SSL3_ST_SR_CERT_VRFY_A (0x1A0|SSL_ST_ACCEPT) ++#define SSL3_ST_SR_CERT_VRFY_B (0x1A1|SSL_ST_ACCEPT) ++#define SSL3_ST_SR_CHANGE_A (0x1B0|SSL_ST_ACCEPT) ++#define SSL3_ST_SR_CHANGE_B (0x1B1|SSL_ST_ACCEPT) ++#define SSL3_ST_SR_FINISHED_A (0x1C0|SSL_ST_ACCEPT) ++#define SSL3_ST_SR_FINISHED_B (0x1C1|SSL_ST_ACCEPT) ++/* write to client */ ++#define SSL3_ST_SW_CHANGE_A (0x1D0|SSL_ST_ACCEPT) ++#define SSL3_ST_SW_CHANGE_B (0x1D1|SSL_ST_ACCEPT) ++#define SSL3_ST_SW_FINISHED_A (0x1E0|SSL_ST_ACCEPT) ++#define SSL3_ST_SW_FINISHED_B (0x1E1|SSL_ST_ACCEPT) ++#define SSL3_ST_SW_SESSION_TICKET_A (0x1F0|SSL_ST_ACCEPT) ++#define SSL3_ST_SW_SESSION_TICKET_B (0x1F1|SSL_ST_ACCEPT) ++#define SSL3_ST_SW_CERT_STATUS_A (0x200|SSL_ST_ACCEPT) ++#define SSL3_ST_SW_CERT_STATUS_B (0x201|SSL_ST_ACCEPT) ++ ++#define SSL3_MT_HELLO_REQUEST 0 ++#define SSL3_MT_CLIENT_HELLO 1 ++#define SSL3_MT_SERVER_HELLO 2 ++#define SSL3_MT_NEWSESSION_TICKET 4 ++#define SSL3_MT_CERTIFICATE 11 ++#define SSL3_MT_SERVER_KEY_EXCHANGE 12 ++#define SSL3_MT_CERTIFICATE_REQUEST 13 ++#define SSL3_MT_SERVER_DONE 14 ++#define SSL3_MT_CERTIFICATE_VERIFY 15 ++#define SSL3_MT_CLIENT_KEY_EXCHANGE 16 ++#define SSL3_MT_FINISHED 20 ++#define SSL3_MT_CERTIFICATE_STATUS 22 ++#define DTLS1_MT_HELLO_VERIFY_REQUEST 3 ++ ++ ++#define SSL3_MT_CCS 1 ++ ++/* These are used when changing over to a new cipher */ ++#define SSL3_CC_READ 0x01 ++#define SSL3_CC_WRITE 0x02 ++#define SSL3_CC_CLIENT 0x10 ++#define SSL3_CC_SERVER 0x20 ++#define SSL3_CHANGE_CIPHER_CLIENT_WRITE (SSL3_CC_CLIENT|SSL3_CC_WRITE) ++#define SSL3_CHANGE_CIPHER_SERVER_READ (SSL3_CC_SERVER|SSL3_CC_READ) ++#define SSL3_CHANGE_CIPHER_CLIENT_READ (SSL3_CC_CLIENT|SSL3_CC_READ) ++#define SSL3_CHANGE_CIPHER_SERVER_WRITE (SSL3_CC_SERVER|SSL3_CC_WRITE) ++ ++#ifdef __cplusplus ++} ++#endif ++#endif ++ +diff -urN qt.orig/include/openssl/stack.h qt.patched/include/openssl/stack.h +--- qt.orig/include/openssl/stack.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/stack.h 2010-08-27 12:01:45.696392300 +0200 +@@ -0,0 +1,108 @@ ++/* crypto/stack/stack.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_STACK_H ++#define HEADER_STACK_H ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++typedef struct stack_st ++ { ++ int num; ++ char **data; ++ int sorted; ++ ++ int num_alloc; ++ int (*comp)(const void *, const void *); ++ } _STACK; /* Use STACK_OF(...) instead */ ++ ++#define M_sk_num(sk) ((sk) ? (sk)->num:-1) ++#define M_sk_value(sk,n) ((sk) ? (sk)->data[n] : NULL) ++ ++int sk_num(const _STACK *); ++void *sk_value(const _STACK *, int); ++ ++void *sk_set(_STACK *, int, void *); ++ ++_STACK *sk_new(int (*cmp)(const void *, const void *)); ++_STACK *sk_new_null(void); ++void sk_free(_STACK *); ++void sk_pop_free(_STACK *st, void (*func)(void *)); ++int sk_insert(_STACK *sk, void *data, int where); ++void *sk_delete(_STACK *st, int loc); ++void *sk_delete_ptr(_STACK *st, void *p); ++int sk_find(_STACK *st, void *data); ++int sk_find_ex(_STACK *st, void *data); ++int sk_push(_STACK *st, void *data); ++int sk_unshift(_STACK *st, void *data); ++void *sk_shift(_STACK *st); ++void *sk_pop(_STACK *st); ++void sk_zero(_STACK *st); ++int (*sk_set_cmp_func(_STACK *sk, int (*c)(const void *, const void *))) ++ (const void *, const void *); ++_STACK *sk_dup(_STACK *st); ++void sk_sort(_STACK *st); ++int sk_is_sorted(const _STACK *st); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff -urN qt.orig/include/openssl/symhacks.h qt.patched/include/openssl/symhacks.h +--- qt.orig/include/openssl/symhacks.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/symhacks.h 2010-08-27 12:01:45.712016700 +0200 +@@ -0,0 +1,449 @@ ++/* ==================================================================== ++ * Copyright (c) 1999 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * openssl-core@openssl.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.openssl.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++ ++#ifndef HEADER_SYMHACKS_H ++#define HEADER_SYMHACKS_H ++ ++#include ++ ++/* Hacks to solve the problem with linkers incapable of handling very long ++ symbol names. In the case of VMS, the limit is 31 characters on VMS for ++ VAX. */ ++/* Note that this affects util/libeay.num and util/ssleay.num... you may ++ change those manually, but that's not recommended, as those files are ++ controlled centrally and updated on Unix, and the central definition ++ may disagree with yours, which in turn may come with shareable library ++ incompatibilities. */ ++#ifdef OPENSSL_SYS_VMS ++ ++/* Hack a long name in crypto/ex_data.c */ ++#undef CRYPTO_get_ex_data_implementation ++#define CRYPTO_get_ex_data_implementation CRYPTO_get_ex_data_impl ++#undef CRYPTO_set_ex_data_implementation ++#define CRYPTO_set_ex_data_implementation CRYPTO_set_ex_data_impl ++ ++/* Hack a long name in crypto/asn1/a_mbstr.c */ ++#undef ASN1_STRING_set_default_mask_asc ++#define ASN1_STRING_set_default_mask_asc ASN1_STRING_set_def_mask_asc ++ ++#if 0 /* No longer needed, since safestack macro magic does the job */ ++/* Hack the names created with DECLARE_ASN1_SET_OF(PKCS7_SIGNER_INFO) */ ++#undef i2d_ASN1_SET_OF_PKCS7_SIGNER_INFO ++#define i2d_ASN1_SET_OF_PKCS7_SIGNER_INFO i2d_ASN1_SET_OF_PKCS7_SIGINF ++#undef d2i_ASN1_SET_OF_PKCS7_SIGNER_INFO ++#define d2i_ASN1_SET_OF_PKCS7_SIGNER_INFO d2i_ASN1_SET_OF_PKCS7_SIGINF ++#endif ++ ++#if 0 /* No longer needed, since safestack macro magic does the job */ ++/* Hack the names created with DECLARE_ASN1_SET_OF(PKCS7_RECIP_INFO) */ ++#undef i2d_ASN1_SET_OF_PKCS7_RECIP_INFO ++#define i2d_ASN1_SET_OF_PKCS7_RECIP_INFO i2d_ASN1_SET_OF_PKCS7_RECINF ++#undef d2i_ASN1_SET_OF_PKCS7_RECIP_INFO ++#define d2i_ASN1_SET_OF_PKCS7_RECIP_INFO d2i_ASN1_SET_OF_PKCS7_RECINF ++#endif ++ ++#if 0 /* No longer needed, since safestack macro magic does the job */ ++/* Hack the names created with DECLARE_ASN1_SET_OF(ACCESS_DESCRIPTION) */ ++#undef i2d_ASN1_SET_OF_ACCESS_DESCRIPTION ++#define i2d_ASN1_SET_OF_ACCESS_DESCRIPTION i2d_ASN1_SET_OF_ACC_DESC ++#undef d2i_ASN1_SET_OF_ACCESS_DESCRIPTION ++#define d2i_ASN1_SET_OF_ACCESS_DESCRIPTION d2i_ASN1_SET_OF_ACC_DESC ++#endif ++ ++/* Hack the names created with DECLARE_PEM_rw(NETSCAPE_CERT_SEQUENCE) */ ++#undef PEM_read_NETSCAPE_CERT_SEQUENCE ++#define PEM_read_NETSCAPE_CERT_SEQUENCE PEM_read_NS_CERT_SEQ ++#undef PEM_write_NETSCAPE_CERT_SEQUENCE ++#define PEM_write_NETSCAPE_CERT_SEQUENCE PEM_write_NS_CERT_SEQ ++#undef PEM_read_bio_NETSCAPE_CERT_SEQUENCE ++#define PEM_read_bio_NETSCAPE_CERT_SEQUENCE PEM_read_bio_NS_CERT_SEQ ++#undef PEM_write_bio_NETSCAPE_CERT_SEQUENCE ++#define PEM_write_bio_NETSCAPE_CERT_SEQUENCE PEM_write_bio_NS_CERT_SEQ ++#undef PEM_write_cb_bio_NETSCAPE_CERT_SEQUENCE ++#define PEM_write_cb_bio_NETSCAPE_CERT_SEQUENCE PEM_write_cb_bio_NS_CERT_SEQ ++ ++/* Hack the names created with DECLARE_PEM_rw(PKCS8_PRIV_KEY_INFO) */ ++#undef PEM_read_PKCS8_PRIV_KEY_INFO ++#define PEM_read_PKCS8_PRIV_KEY_INFO PEM_read_P8_PRIV_KEY_INFO ++#undef PEM_write_PKCS8_PRIV_KEY_INFO ++#define PEM_write_PKCS8_PRIV_KEY_INFO PEM_write_P8_PRIV_KEY_INFO ++#undef PEM_read_bio_PKCS8_PRIV_KEY_INFO ++#define PEM_read_bio_PKCS8_PRIV_KEY_INFO PEM_read_bio_P8_PRIV_KEY_INFO ++#undef PEM_write_bio_PKCS8_PRIV_KEY_INFO ++#define PEM_write_bio_PKCS8_PRIV_KEY_INFO PEM_write_bio_P8_PRIV_KEY_INFO ++#undef PEM_write_cb_bio_PKCS8_PRIV_KEY_INFO ++#define PEM_write_cb_bio_PKCS8_PRIV_KEY_INFO PEM_wrt_cb_bio_P8_PRIV_KEY_INFO ++ ++/* Hack other PEM names */ ++#undef PEM_write_bio_PKCS8PrivateKey_nid ++#define PEM_write_bio_PKCS8PrivateKey_nid PEM_write_bio_PKCS8PrivKey_nid ++ ++/* Hack some long X509 names */ ++#undef X509_REVOKED_get_ext_by_critical ++#define X509_REVOKED_get_ext_by_critical X509_REVOKED_get_ext_by_critic ++#undef X509_policy_tree_get0_user_policies ++#define X509_policy_tree_get0_user_policies X509_pcy_tree_get0_usr_policies ++#undef X509_policy_node_get0_qualifiers ++#define X509_policy_node_get0_qualifiers X509_pcy_node_get0_qualifiers ++#undef X509_STORE_CTX_get_explicit_policy ++#define X509_STORE_CTX_get_explicit_policy X509_STORE_CTX_get_expl_policy ++#undef X509_STORE_CTX_get0_current_issuer ++#define X509_STORE_CTX_get0_current_issuer X509_STORE_CTX_get0_cur_issuer ++ ++/* Hack some long CRYPTO names */ ++#undef CRYPTO_set_dynlock_destroy_callback ++#define CRYPTO_set_dynlock_destroy_callback CRYPTO_set_dynlock_destroy_cb ++#undef CRYPTO_set_dynlock_create_callback ++#define CRYPTO_set_dynlock_create_callback CRYPTO_set_dynlock_create_cb ++#undef CRYPTO_set_dynlock_lock_callback ++#define CRYPTO_set_dynlock_lock_callback CRYPTO_set_dynlock_lock_cb ++#undef CRYPTO_get_dynlock_lock_callback ++#define CRYPTO_get_dynlock_lock_callback CRYPTO_get_dynlock_lock_cb ++#undef CRYPTO_get_dynlock_destroy_callback ++#define CRYPTO_get_dynlock_destroy_callback CRYPTO_get_dynlock_destroy_cb ++#undef CRYPTO_get_dynlock_create_callback ++#define CRYPTO_get_dynlock_create_callback CRYPTO_get_dynlock_create_cb ++#undef CRYPTO_set_locked_mem_ex_functions ++#define CRYPTO_set_locked_mem_ex_functions CRYPTO_set_locked_mem_ex_funcs ++#undef CRYPTO_get_locked_mem_ex_functions ++#define CRYPTO_get_locked_mem_ex_functions CRYPTO_get_locked_mem_ex_funcs ++ ++/* Hack some long SSL names */ ++#undef SSL_CTX_set_default_verify_paths ++#define SSL_CTX_set_default_verify_paths SSL_CTX_set_def_verify_paths ++#undef SSL_get_ex_data_X509_STORE_CTX_idx ++#define SSL_get_ex_data_X509_STORE_CTX_idx SSL_get_ex_d_X509_STORE_CTX_idx ++#undef SSL_add_file_cert_subjects_to_stack ++#define SSL_add_file_cert_subjects_to_stack SSL_add_file_cert_subjs_to_stk ++#undef SSL_add_dir_cert_subjects_to_stack ++#define SSL_add_dir_cert_subjects_to_stack SSL_add_dir_cert_subjs_to_stk ++#undef SSL_CTX_use_certificate_chain_file ++#define SSL_CTX_use_certificate_chain_file SSL_CTX_use_cert_chain_file ++#undef SSL_CTX_set_cert_verify_callback ++#define SSL_CTX_set_cert_verify_callback SSL_CTX_set_cert_verify_cb ++#undef SSL_CTX_set_default_passwd_cb_userdata ++#define SSL_CTX_set_default_passwd_cb_userdata SSL_CTX_set_def_passwd_cb_ud ++#undef SSL_COMP_get_compression_methods ++#define SSL_COMP_get_compression_methods SSL_COMP_get_compress_methods ++ ++#undef ssl_add_clienthello_renegotiate_ext ++#define ssl_add_clienthello_renegotiate_ext ssl_add_clienthello_reneg_ext ++#undef ssl_add_serverhello_renegotiate_ext ++#define ssl_add_serverhello_renegotiate_ext ssl_add_serverhello_reneg_ext ++#undef ssl_parse_clienthello_renegotiate_ext ++#define ssl_parse_clienthello_renegotiate_ext ssl_parse_clienthello_reneg_ext ++#undef ssl_parse_serverhello_renegotiate_ext ++#define ssl_parse_serverhello_renegotiate_ext ssl_parse_serverhello_reneg_ext ++ ++/* Hack some long ENGINE names */ ++#undef ENGINE_get_default_BN_mod_exp_crt ++#define ENGINE_get_default_BN_mod_exp_crt ENGINE_get_def_BN_mod_exp_crt ++#undef ENGINE_set_default_BN_mod_exp_crt ++#define ENGINE_set_default_BN_mod_exp_crt ENGINE_set_def_BN_mod_exp_crt ++#undef ENGINE_set_load_privkey_function ++#define ENGINE_set_load_privkey_function ENGINE_set_load_privkey_fn ++#undef ENGINE_get_load_privkey_function ++#define ENGINE_get_load_privkey_function ENGINE_get_load_privkey_fn ++#undef ENGINE_unregister_pkey_asn1_meths ++#define ENGINE_unregister_pkey_asn1_meths ENGINE_unreg_pkey_asn1_meths ++#undef ENGINE_register_all_pkey_asn1_meths ++#define ENGINE_register_all_pkey_asn1_meths ENGINE_reg_all_pkey_asn1_meths ++#undef ENGINE_set_default_pkey_asn1_meths ++#define ENGINE_set_default_pkey_asn1_meths ENGINE_set_def_pkey_asn1_meths ++#undef ENGINE_get_pkey_asn1_meth_engine ++#define ENGINE_get_pkey_asn1_meth_engine ENGINE_get_pkey_asn1_meth_eng ++#undef ENGINE_set_load_ssl_client_cert_function ++#define ENGINE_set_load_ssl_client_cert_function \ ++ ENGINE_set_ld_ssl_clnt_cert_fn ++#undef ENGINE_get_ssl_client_cert_function ++#define ENGINE_get_ssl_client_cert_function ENGINE_get_ssl_client_cert_fn ++ ++/* Hack some long OCSP names */ ++#undef OCSP_REQUEST_get_ext_by_critical ++#define OCSP_REQUEST_get_ext_by_critical OCSP_REQUEST_get_ext_by_crit ++#undef OCSP_BASICRESP_get_ext_by_critical ++#define OCSP_BASICRESP_get_ext_by_critical OCSP_BASICRESP_get_ext_by_crit ++#undef OCSP_SINGLERESP_get_ext_by_critical ++#define OCSP_SINGLERESP_get_ext_by_critical OCSP_SINGLERESP_get_ext_by_crit ++ ++/* Hack some long DES names */ ++#undef _ossl_old_des_ede3_cfb64_encrypt ++#define _ossl_old_des_ede3_cfb64_encrypt _ossl_odes_ede3_cfb64_encrypt ++#undef _ossl_old_des_ede3_ofb64_encrypt ++#define _ossl_old_des_ede3_ofb64_encrypt _ossl_odes_ede3_ofb64_encrypt ++ ++/* Hack some long EVP names */ ++#undef OPENSSL_add_all_algorithms_noconf ++#define OPENSSL_add_all_algorithms_noconf OPENSSL_add_all_algo_noconf ++#undef OPENSSL_add_all_algorithms_conf ++#define OPENSSL_add_all_algorithms_conf OPENSSL_add_all_algo_conf ++#undef EVP_PKEY_meth_set_verify_recover ++#define EVP_PKEY_meth_set_verify_recover EVP_PKEY_meth_set_vrfy_recover ++ ++/* Hack some long EC names */ ++#undef EC_GROUP_set_point_conversion_form ++#define EC_GROUP_set_point_conversion_form EC_GROUP_set_point_conv_form ++#undef EC_GROUP_get_point_conversion_form ++#define EC_GROUP_get_point_conversion_form EC_GROUP_get_point_conv_form ++#undef EC_GROUP_clear_free_all_extra_data ++#define EC_GROUP_clear_free_all_extra_data EC_GROUP_clr_free_all_xtra_data ++#undef EC_POINT_set_Jprojective_coordinates_GFp ++#define EC_POINT_set_Jprojective_coordinates_GFp \ ++ EC_POINT_set_Jproj_coords_GFp ++#undef EC_POINT_get_Jprojective_coordinates_GFp ++#define EC_POINT_get_Jprojective_coordinates_GFp \ ++ EC_POINT_get_Jproj_coords_GFp ++#undef EC_POINT_set_affine_coordinates_GFp ++#define EC_POINT_set_affine_coordinates_GFp EC_POINT_set_affine_coords_GFp ++#undef EC_POINT_get_affine_coordinates_GFp ++#define EC_POINT_get_affine_coordinates_GFp EC_POINT_get_affine_coords_GFp ++#undef EC_POINT_set_compressed_coordinates_GFp ++#define EC_POINT_set_compressed_coordinates_GFp EC_POINT_set_compr_coords_GFp ++#undef EC_POINT_set_affine_coordinates_GF2m ++#define EC_POINT_set_affine_coordinates_GF2m EC_POINT_set_affine_coords_GF2m ++#undef EC_POINT_get_affine_coordinates_GF2m ++#define EC_POINT_get_affine_coordinates_GF2m EC_POINT_get_affine_coords_GF2m ++#undef EC_POINT_set_compressed_coordinates_GF2m ++#define EC_POINT_set_compressed_coordinates_GF2m \ ++ EC_POINT_set_compr_coords_GF2m ++#undef ec_GF2m_simple_group_clear_finish ++#define ec_GF2m_simple_group_clear_finish ec_GF2m_simple_grp_clr_finish ++#undef ec_GF2m_simple_group_check_discriminant ++#define ec_GF2m_simple_group_check_discriminant ec_GF2m_simple_grp_chk_discrim ++#undef ec_GF2m_simple_point_clear_finish ++#define ec_GF2m_simple_point_clear_finish ec_GF2m_simple_pt_clr_finish ++#undef ec_GF2m_simple_point_set_to_infinity ++#define ec_GF2m_simple_point_set_to_infinity ec_GF2m_simple_pt_set_to_inf ++#undef ec_GF2m_simple_points_make_affine ++#define ec_GF2m_simple_points_make_affine ec_GF2m_simple_pts_make_affine ++#undef ec_GF2m_simple_point_set_affine_coordinates ++#define ec_GF2m_simple_point_set_affine_coordinates \ ++ ec_GF2m_smp_pt_set_af_coords ++#undef ec_GF2m_simple_point_get_affine_coordinates ++#define ec_GF2m_simple_point_get_affine_coordinates \ ++ ec_GF2m_smp_pt_get_af_coords ++#undef ec_GF2m_simple_set_compressed_coordinates ++#define ec_GF2m_simple_set_compressed_coordinates \ ++ ec_GF2m_smp_set_compr_coords ++#undef ec_GFp_simple_group_set_curve_GFp ++#define ec_GFp_simple_group_set_curve_GFp ec_GFp_simple_grp_set_curve_GFp ++#undef ec_GFp_simple_group_get_curve_GFp ++#define ec_GFp_simple_group_get_curve_GFp ec_GFp_simple_grp_get_curve_GFp ++#undef ec_GFp_simple_group_clear_finish ++#define ec_GFp_simple_group_clear_finish ec_GFp_simple_grp_clear_finish ++#undef ec_GFp_simple_group_set_generator ++#define ec_GFp_simple_group_set_generator ec_GFp_simple_grp_set_generator ++#undef ec_GFp_simple_group_get0_generator ++#define ec_GFp_simple_group_get0_generator ec_GFp_simple_grp_gt0_generator ++#undef ec_GFp_simple_group_get_cofactor ++#define ec_GFp_simple_group_get_cofactor ec_GFp_simple_grp_get_cofactor ++#undef ec_GFp_simple_point_clear_finish ++#define ec_GFp_simple_point_clear_finish ec_GFp_simple_pt_clear_finish ++#undef ec_GFp_simple_point_set_to_infinity ++#define ec_GFp_simple_point_set_to_infinity ec_GFp_simple_pt_set_to_inf ++#undef ec_GFp_simple_points_make_affine ++#define ec_GFp_simple_points_make_affine ec_GFp_simple_pts_make_affine ++#undef ec_GFp_simple_group_get_curve_GFp ++#define ec_GFp_simple_group_get_curve_GFp ec_GFp_simple_grp_get_curve_GFp ++#undef ec_GFp_simple_set_Jprojective_coordinates_GFp ++#define ec_GFp_simple_set_Jprojective_coordinates_GFp \ ++ ec_GFp_smp_set_Jproj_coords_GFp ++#undef ec_GFp_simple_get_Jprojective_coordinates_GFp ++#define ec_GFp_simple_get_Jprojective_coordinates_GFp \ ++ ec_GFp_smp_get_Jproj_coords_GFp ++#undef ec_GFp_simple_point_set_affine_coordinates_GFp ++#define ec_GFp_simple_point_set_affine_coordinates_GFp \ ++ ec_GFp_smp_pt_set_af_coords_GFp ++#undef ec_GFp_simple_point_get_affine_coordinates_GFp ++#define ec_GFp_simple_point_get_affine_coordinates_GFp \ ++ ec_GFp_smp_pt_get_af_coords_GFp ++#undef ec_GFp_simple_set_compressed_coordinates_GFp ++#define ec_GFp_simple_set_compressed_coordinates_GFp \ ++ ec_GFp_smp_set_compr_coords_GFp ++#undef ec_GFp_simple_point_set_affine_coordinates ++#define ec_GFp_simple_point_set_affine_coordinates \ ++ ec_GFp_smp_pt_set_af_coords ++#undef ec_GFp_simple_point_get_affine_coordinates ++#define ec_GFp_simple_point_get_affine_coordinates \ ++ ec_GFp_smp_pt_get_af_coords ++#undef ec_GFp_simple_set_compressed_coordinates ++#define ec_GFp_simple_set_compressed_coordinates \ ++ ec_GFp_smp_set_compr_coords ++#undef ec_GFp_simple_group_check_discriminant ++#define ec_GFp_simple_group_check_discriminant ec_GFp_simple_grp_chk_discrim ++ ++/* Hack som long STORE names */ ++#undef STORE_method_set_initialise_function ++#define STORE_method_set_initialise_function STORE_meth_set_initialise_fn ++#undef STORE_method_set_cleanup_function ++#define STORE_method_set_cleanup_function STORE_meth_set_cleanup_fn ++#undef STORE_method_set_generate_function ++#define STORE_method_set_generate_function STORE_meth_set_generate_fn ++#undef STORE_method_set_modify_function ++#define STORE_method_set_modify_function STORE_meth_set_modify_fn ++#undef STORE_method_set_revoke_function ++#define STORE_method_set_revoke_function STORE_meth_set_revoke_fn ++#undef STORE_method_set_delete_function ++#define STORE_method_set_delete_function STORE_meth_set_delete_fn ++#undef STORE_method_set_list_start_function ++#define STORE_method_set_list_start_function STORE_meth_set_list_start_fn ++#undef STORE_method_set_list_next_function ++#define STORE_method_set_list_next_function STORE_meth_set_list_next_fn ++#undef STORE_method_set_list_end_function ++#define STORE_method_set_list_end_function STORE_meth_set_list_end_fn ++#undef STORE_method_set_update_store_function ++#define STORE_method_set_update_store_function STORE_meth_set_update_store_fn ++#undef STORE_method_set_lock_store_function ++#define STORE_method_set_lock_store_function STORE_meth_set_lock_store_fn ++#undef STORE_method_set_unlock_store_function ++#define STORE_method_set_unlock_store_function STORE_meth_set_unlock_store_fn ++#undef STORE_method_get_initialise_function ++#define STORE_method_get_initialise_function STORE_meth_get_initialise_fn ++#undef STORE_method_get_cleanup_function ++#define STORE_method_get_cleanup_function STORE_meth_get_cleanup_fn ++#undef STORE_method_get_generate_function ++#define STORE_method_get_generate_function STORE_meth_get_generate_fn ++#undef STORE_method_get_modify_function ++#define STORE_method_get_modify_function STORE_meth_get_modify_fn ++#undef STORE_method_get_revoke_function ++#define STORE_method_get_revoke_function STORE_meth_get_revoke_fn ++#undef STORE_method_get_delete_function ++#define STORE_method_get_delete_function STORE_meth_get_delete_fn ++#undef STORE_method_get_list_start_function ++#define STORE_method_get_list_start_function STORE_meth_get_list_start_fn ++#undef STORE_method_get_list_next_function ++#define STORE_method_get_list_next_function STORE_meth_get_list_next_fn ++#undef STORE_method_get_list_end_function ++#define STORE_method_get_list_end_function STORE_meth_get_list_end_fn ++#undef STORE_method_get_update_store_function ++#define STORE_method_get_update_store_function STORE_meth_get_update_store_fn ++#undef STORE_method_get_lock_store_function ++#define STORE_method_get_lock_store_function STORE_meth_get_lock_store_fn ++#undef STORE_method_get_unlock_store_function ++#define STORE_method_get_unlock_store_function STORE_meth_get_unlock_store_fn ++ ++/* Hack some long TS names */ ++#undef TS_RESP_CTX_set_status_info_cond ++#define TS_RESP_CTX_set_status_info_cond TS_RESP_CTX_set_stat_info_cond ++#undef TS_RESP_CTX_set_clock_precision_digits ++#define TS_RESP_CTX_set_clock_precision_digits TS_RESP_CTX_set_clk_prec_digits ++#undef TS_CONF_set_clock_precision_digits ++#define TS_CONF_set_clock_precision_digits TS_CONF_set_clk_prec_digits ++ ++/* Hack some long CMS names */ ++#undef CMS_RecipientInfo_ktri_get0_algs ++#define CMS_RecipientInfo_ktri_get0_algs CMS_RecipInfo_ktri_get0_algs ++#undef CMS_RecipientInfo_ktri_get0_signer_id ++#define CMS_RecipientInfo_ktri_get0_signer_id CMS_RecipInfo_ktri_get0_sigr_id ++#undef CMS_OtherRevocationInfoFormat_it ++#define CMS_OtherRevocationInfoFormat_it CMS_OtherRevocInfoFormat_it ++#undef CMS_KeyAgreeRecipientIdentifier_it ++#define CMS_KeyAgreeRecipientIdentifier_it CMS_KeyAgreeRecipIdentifier_it ++#undef CMS_OriginatorIdentifierOrKey_it ++#define CMS_OriginatorIdentifierOrKey_it CMS_OriginatorIdOrKey_it ++#undef cms_SignerIdentifier_get0_signer_id ++#define cms_SignerIdentifier_get0_signer_id cms_SignerId_get0_signer_id ++ ++/* Hack some long DTLS1 names */ ++#undef dtls1_retransmit_buffered_messages ++#define dtls1_retransmit_buffered_messages dtls1_retransmit_buffered_msgs ++ ++/* Hack some long UI names */ ++#undef UI_method_get_prompt_constructor ++#define UI_method_get_prompt_constructor UI_method_get_prompt_constructr ++#undef UI_method_set_prompt_constructor ++#define UI_method_set_prompt_constructor UI_method_set_prompt_constructr ++ ++#endif /* defined OPENSSL_SYS_VMS */ ++ ++ ++/* Case insensitive linking causes problems.... */ ++#if defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_OS2) ++#undef ERR_load_CRYPTO_strings ++#define ERR_load_CRYPTO_strings ERR_load_CRYPTOlib_strings ++#undef OCSP_crlID_new ++#define OCSP_crlID_new OCSP_crlID2_new ++ ++#undef d2i_ECPARAMETERS ++#define d2i_ECPARAMETERS d2i_UC_ECPARAMETERS ++#undef i2d_ECPARAMETERS ++#define i2d_ECPARAMETERS i2d_UC_ECPARAMETERS ++#undef d2i_ECPKPARAMETERS ++#define d2i_ECPKPARAMETERS d2i_UC_ECPKPARAMETERS ++#undef i2d_ECPKPARAMETERS ++#define i2d_ECPKPARAMETERS i2d_UC_ECPKPARAMETERS ++ ++/* These functions do not seem to exist! However, I'm paranoid... ++ Original command in x509v3.h: ++ These functions are being redefined in another directory, ++ and clash when the linker is case-insensitive, so let's ++ hide them a little, by giving them an extra 'o' at the ++ beginning of the name... */ ++#undef X509v3_cleanup_extensions ++#define X509v3_cleanup_extensions oX509v3_cleanup_extensions ++#undef X509v3_add_extension ++#define X509v3_add_extension oX509v3_add_extension ++#undef X509v3_add_netscape_extensions ++#define X509v3_add_netscape_extensions oX509v3_add_netscape_extensions ++#undef X509v3_add_standard_extensions ++#define X509v3_add_standard_extensions oX509v3_add_standard_extensions ++ ++/* This one clashes with CMS_data_create */ ++#undef cms_Data_create ++#define cms_Data_create priv_cms_Data_create ++ ++#endif ++ ++ ++#endif /* ! defined HEADER_VMS_IDHACKS_H */ +diff -urN qt.orig/include/openssl/tls1.h qt.patched/include/openssl/tls1.h +--- qt.orig/include/openssl/tls1.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/tls1.h 2010-08-27 12:01:45.743265500 +0200 +@@ -0,0 +1,532 @@ ++/* ssl/tls1.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++/* ==================================================================== ++ * Copyright (c) 1998-2006 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * openssl-core@openssl.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.openssl.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++/* ==================================================================== ++ * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. ++ * ++ * Portions of the attached software ("Contribution") are developed by ++ * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project. ++ * ++ * The Contribution is licensed pursuant to the OpenSSL open source ++ * license provided above. ++ * ++ * ECC cipher suite support in OpenSSL originally written by ++ * Vipul Gupta and Sumit Gupta of Sun Microsystems Laboratories. ++ * ++ */ ++/* ==================================================================== ++ * Copyright 2005 Nokia. All rights reserved. ++ * ++ * The portions of the attached software ("Contribution") is developed by ++ * Nokia Corporation and is licensed pursuant to the OpenSSL open source ++ * license. ++ * ++ * The Contribution, originally written by Mika Kousa and Pasi Eronen of ++ * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites ++ * support (see RFC 4279) to OpenSSL. ++ * ++ * No patent licenses or other rights except those expressly stated in ++ * the OpenSSL open source license shall be deemed granted or received ++ * expressly, by implication, estoppel, or otherwise. ++ * ++ * No assurances are provided by Nokia that the Contribution does not ++ * infringe the patent or other intellectual property rights of any third ++ * party or that the license provides you with all the necessary rights ++ * to make use of the Contribution. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN ++ * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA ++ * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY ++ * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR ++ * OTHERWISE. ++ */ ++ ++#ifndef HEADER_TLS1_H ++#define HEADER_TLS1_H ++ ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#define TLS1_ALLOW_EXPERIMENTAL_CIPHERSUITES 0 ++ ++#define TLS1_VERSION 0x0301 ++#define TLS1_VERSION_MAJOR 0x03 ++#define TLS1_VERSION_MINOR 0x01 ++ ++#define TLS1_AD_DECRYPTION_FAILED 21 ++#define TLS1_AD_RECORD_OVERFLOW 22 ++#define TLS1_AD_UNKNOWN_CA 48 /* fatal */ ++#define TLS1_AD_ACCESS_DENIED 49 /* fatal */ ++#define TLS1_AD_DECODE_ERROR 50 /* fatal */ ++#define TLS1_AD_DECRYPT_ERROR 51 ++#define TLS1_AD_EXPORT_RESTRICTION 60 /* fatal */ ++#define TLS1_AD_PROTOCOL_VERSION 70 /* fatal */ ++#define TLS1_AD_INSUFFICIENT_SECURITY 71 /* fatal */ ++#define TLS1_AD_INTERNAL_ERROR 80 /* fatal */ ++#define TLS1_AD_USER_CANCELLED 90 ++#define TLS1_AD_NO_RENEGOTIATION 100 ++/* codes 110-114 are from RFC3546 */ ++#define TLS1_AD_UNSUPPORTED_EXTENSION 110 ++#define TLS1_AD_CERTIFICATE_UNOBTAINABLE 111 ++#define TLS1_AD_UNRECOGNIZED_NAME 112 ++#define TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE 113 ++#define TLS1_AD_BAD_CERTIFICATE_HASH_VALUE 114 ++#define TLS1_AD_UNKNOWN_PSK_IDENTITY 115 /* fatal */ ++ ++/* ExtensionType values from RFC3546 / RFC4366 */ ++#define TLSEXT_TYPE_server_name 0 ++#define TLSEXT_TYPE_max_fragment_length 1 ++#define TLSEXT_TYPE_client_certificate_url 2 ++#define TLSEXT_TYPE_trusted_ca_keys 3 ++#define TLSEXT_TYPE_truncated_hmac 4 ++#define TLSEXT_TYPE_status_request 5 ++/* ExtensionType values from RFC4492 */ ++#define TLSEXT_TYPE_elliptic_curves 10 ++#define TLSEXT_TYPE_ec_point_formats 11 ++#define TLSEXT_TYPE_session_ticket 35 ++/* ExtensionType value from draft-rescorla-tls-opaque-prf-input-00.txt */ ++#if 0 /* will have to be provided externally for now , ++ * i.e. build with -DTLSEXT_TYPE_opaque_prf_input=38183 ++ * using whatever extension number you'd like to try */ ++# define TLSEXT_TYPE_opaque_prf_input ?? */ ++#endif ++ ++/* Temporary extension type */ ++#define TLSEXT_TYPE_renegotiate 0xff01 ++ ++/* NameType value from RFC 3546 */ ++#define TLSEXT_NAMETYPE_host_name 0 ++/* status request value from RFC 3546 */ ++#define TLSEXT_STATUSTYPE_ocsp 1 ++ ++/* ECPointFormat values from draft-ietf-tls-ecc-12 */ ++#define TLSEXT_ECPOINTFORMAT_first 0 ++#define TLSEXT_ECPOINTFORMAT_uncompressed 0 ++#define TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime 1 ++#define TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2 2 ++#define TLSEXT_ECPOINTFORMAT_last 2 ++ ++#ifndef OPENSSL_NO_TLSEXT ++ ++#define TLSEXT_MAXLEN_host_name 255 ++ ++const char *SSL_get_servername(const SSL *s, const int type) ; ++int SSL_get_servername_type(const SSL *s) ; ++ ++#define SSL_set_tlsext_host_name(s,name) \ ++SSL_ctrl(s,SSL_CTRL_SET_TLSEXT_HOSTNAME,TLSEXT_NAMETYPE_host_name,(char *)name) ++ ++#define SSL_set_tlsext_debug_callback(ssl, cb) \ ++SSL_callback_ctrl(ssl,SSL_CTRL_SET_TLSEXT_DEBUG_CB,(void (*)(void))cb) ++ ++#define SSL_set_tlsext_debug_arg(ssl, arg) \ ++SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_DEBUG_ARG,0, (void *)arg) ++ ++#define SSL_set_tlsext_status_type(ssl, type) \ ++SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE,type, NULL) ++ ++#define SSL_get_tlsext_status_exts(ssl, arg) \ ++SSL_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_EXTS,0, (void *)arg) ++ ++#define SSL_set_tlsext_status_exts(ssl, arg) \ ++SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_EXTS,0, (void *)arg) ++ ++#define SSL_get_tlsext_status_ids(ssl, arg) \ ++SSL_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_IDS,0, (void *)arg) ++ ++#define SSL_set_tlsext_status_ids(ssl, arg) \ ++SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_IDS,0, (void *)arg) ++ ++#define SSL_get_tlsext_status_ocsp_resp(ssl, arg) \ ++SSL_ctrl(ssl,SSL_CTRL_GET_TLSEXT_STATUS_REQ_OCSP_RESP,0, (void *)arg) ++ ++#define SSL_set_tlsext_status_ocsp_resp(ssl, arg, arglen) \ ++SSL_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_OCSP_RESP,arglen, (void *)arg) ++ ++#define SSL_CTX_set_tlsext_servername_callback(ctx, cb) \ ++SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TLSEXT_SERVERNAME_CB,(void (*)(void))cb) ++ ++#define SSL_TLSEXT_ERR_OK 0 ++#define SSL_TLSEXT_ERR_ALERT_WARNING 1 ++#define SSL_TLSEXT_ERR_ALERT_FATAL 2 ++#define SSL_TLSEXT_ERR_NOACK 3 ++ ++#define SSL_CTX_set_tlsext_servername_arg(ctx, arg) \ ++SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG,0, (void *)arg) ++ ++#define SSL_CTX_get_tlsext_ticket_keys(ctx, keys, keylen) \ ++ SSL_CTX_ctrl((ctx),SSL_CTRL_GET_TLSEXT_TICKET_KEYS,(keylen),(keys)) ++#define SSL_CTX_set_tlsext_ticket_keys(ctx, keys, keylen) \ ++ SSL_CTX_ctrl((ctx),SSL_CTRL_SET_TLSEXT_TICKET_KEYS,(keylen),(keys)) ++ ++#define SSL_CTX_set_tlsext_status_cb(ssl, cb) \ ++SSL_CTX_callback_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB,(void (*)(void))cb) ++ ++#define SSL_CTX_set_tlsext_status_arg(ssl, arg) \ ++SSL_CTX_ctrl(ssl,SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB_ARG,0, (void *)arg) ++ ++#define SSL_set_tlsext_opaque_prf_input(s, src, len) \ ++SSL_ctrl(s,SSL_CTRL_SET_TLSEXT_OPAQUE_PRF_INPUT, len, src) ++#define SSL_CTX_set_tlsext_opaque_prf_input_callback(ctx, cb) \ ++SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TLSEXT_OPAQUE_PRF_INPUT_CB, (void (*)(void))cb) ++#define SSL_CTX_set_tlsext_opaque_prf_input_callback_arg(ctx, arg) \ ++SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TLSEXT_OPAQUE_PRF_INPUT_CB_ARG, 0, arg) ++ ++#define SSL_CTX_set_tlsext_ticket_key_cb(ssl, cb) \ ++SSL_CTX_callback_ctrl(ssl,SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB,(void (*)(void))cb) ++ ++#endif ++ ++/* PSK ciphersuites from 4279 */ ++#define TLS1_CK_PSK_WITH_RC4_128_SHA 0x0300008A ++#define TLS1_CK_PSK_WITH_3DES_EDE_CBC_SHA 0x0300008B ++#define TLS1_CK_PSK_WITH_AES_128_CBC_SHA 0x0300008C ++#define TLS1_CK_PSK_WITH_AES_256_CBC_SHA 0x0300008D ++ ++/* Additional TLS ciphersuites from expired Internet Draft ++ * draft-ietf-tls-56-bit-ciphersuites-01.txt ++ * (available if TLS1_ALLOW_EXPERIMENTAL_CIPHERSUITES is defined, see ++ * s3_lib.c). We actually treat them like SSL 3.0 ciphers, which we probably ++ * shouldn't. Note that the first two are actually not in the IDs. */ ++#define TLS1_CK_RSA_EXPORT1024_WITH_RC4_56_MD5 0x03000060 /* not in ID */ ++#define TLS1_CK_RSA_EXPORT1024_WITH_RC2_CBC_56_MD5 0x03000061 /* not in ID */ ++#define TLS1_CK_RSA_EXPORT1024_WITH_DES_CBC_SHA 0x03000062 ++#define TLS1_CK_DHE_DSS_EXPORT1024_WITH_DES_CBC_SHA 0x03000063 ++#define TLS1_CK_RSA_EXPORT1024_WITH_RC4_56_SHA 0x03000064 ++#define TLS1_CK_DHE_DSS_EXPORT1024_WITH_RC4_56_SHA 0x03000065 ++#define TLS1_CK_DHE_DSS_WITH_RC4_128_SHA 0x03000066 ++ ++/* AES ciphersuites from RFC3268 */ ++ ++#define TLS1_CK_RSA_WITH_AES_128_SHA 0x0300002F ++#define TLS1_CK_DH_DSS_WITH_AES_128_SHA 0x03000030 ++#define TLS1_CK_DH_RSA_WITH_AES_128_SHA 0x03000031 ++#define TLS1_CK_DHE_DSS_WITH_AES_128_SHA 0x03000032 ++#define TLS1_CK_DHE_RSA_WITH_AES_128_SHA 0x03000033 ++#define TLS1_CK_ADH_WITH_AES_128_SHA 0x03000034 ++ ++#define TLS1_CK_RSA_WITH_AES_256_SHA 0x03000035 ++#define TLS1_CK_DH_DSS_WITH_AES_256_SHA 0x03000036 ++#define TLS1_CK_DH_RSA_WITH_AES_256_SHA 0x03000037 ++#define TLS1_CK_DHE_DSS_WITH_AES_256_SHA 0x03000038 ++#define TLS1_CK_DHE_RSA_WITH_AES_256_SHA 0x03000039 ++#define TLS1_CK_ADH_WITH_AES_256_SHA 0x0300003A ++ ++/* Camellia ciphersuites from RFC4132 */ ++#define TLS1_CK_RSA_WITH_CAMELLIA_128_CBC_SHA 0x03000041 ++#define TLS1_CK_DH_DSS_WITH_CAMELLIA_128_CBC_SHA 0x03000042 ++#define TLS1_CK_DH_RSA_WITH_CAMELLIA_128_CBC_SHA 0x03000043 ++#define TLS1_CK_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA 0x03000044 ++#define TLS1_CK_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA 0x03000045 ++#define TLS1_CK_ADH_WITH_CAMELLIA_128_CBC_SHA 0x03000046 ++ ++#define TLS1_CK_RSA_WITH_CAMELLIA_256_CBC_SHA 0x03000084 ++#define TLS1_CK_DH_DSS_WITH_CAMELLIA_256_CBC_SHA 0x03000085 ++#define TLS1_CK_DH_RSA_WITH_CAMELLIA_256_CBC_SHA 0x03000086 ++#define TLS1_CK_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA 0x03000087 ++#define TLS1_CK_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA 0x03000088 ++#define TLS1_CK_ADH_WITH_CAMELLIA_256_CBC_SHA 0x03000089 ++ ++/* SEED ciphersuites from RFC4162 */ ++#define TLS1_CK_RSA_WITH_SEED_SHA 0x03000096 ++#define TLS1_CK_DH_DSS_WITH_SEED_SHA 0x03000097 ++#define TLS1_CK_DH_RSA_WITH_SEED_SHA 0x03000098 ++#define TLS1_CK_DHE_DSS_WITH_SEED_SHA 0x03000099 ++#define TLS1_CK_DHE_RSA_WITH_SEED_SHA 0x0300009A ++#define TLS1_CK_ADH_WITH_SEED_SHA 0x0300009B ++ ++/* ECC ciphersuites from draft-ietf-tls-ecc-12.txt with changes soon to be in draft 13 */ ++#define TLS1_CK_ECDH_ECDSA_WITH_NULL_SHA 0x0300C001 ++#define TLS1_CK_ECDH_ECDSA_WITH_RC4_128_SHA 0x0300C002 ++#define TLS1_CK_ECDH_ECDSA_WITH_DES_192_CBC3_SHA 0x0300C003 ++#define TLS1_CK_ECDH_ECDSA_WITH_AES_128_CBC_SHA 0x0300C004 ++#define TLS1_CK_ECDH_ECDSA_WITH_AES_256_CBC_SHA 0x0300C005 ++ ++#define TLS1_CK_ECDHE_ECDSA_WITH_NULL_SHA 0x0300C006 ++#define TLS1_CK_ECDHE_ECDSA_WITH_RC4_128_SHA 0x0300C007 ++#define TLS1_CK_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA 0x0300C008 ++#define TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CBC_SHA 0x0300C009 ++#define TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CBC_SHA 0x0300C00A ++ ++#define TLS1_CK_ECDH_RSA_WITH_NULL_SHA 0x0300C00B ++#define TLS1_CK_ECDH_RSA_WITH_RC4_128_SHA 0x0300C00C ++#define TLS1_CK_ECDH_RSA_WITH_DES_192_CBC3_SHA 0x0300C00D ++#define TLS1_CK_ECDH_RSA_WITH_AES_128_CBC_SHA 0x0300C00E ++#define TLS1_CK_ECDH_RSA_WITH_AES_256_CBC_SHA 0x0300C00F ++ ++#define TLS1_CK_ECDHE_RSA_WITH_NULL_SHA 0x0300C010 ++#define TLS1_CK_ECDHE_RSA_WITH_RC4_128_SHA 0x0300C011 ++#define TLS1_CK_ECDHE_RSA_WITH_DES_192_CBC3_SHA 0x0300C012 ++#define TLS1_CK_ECDHE_RSA_WITH_AES_128_CBC_SHA 0x0300C013 ++#define TLS1_CK_ECDHE_RSA_WITH_AES_256_CBC_SHA 0x0300C014 ++ ++#define TLS1_CK_ECDH_anon_WITH_NULL_SHA 0x0300C015 ++#define TLS1_CK_ECDH_anon_WITH_RC4_128_SHA 0x0300C016 ++#define TLS1_CK_ECDH_anon_WITH_DES_192_CBC3_SHA 0x0300C017 ++#define TLS1_CK_ECDH_anon_WITH_AES_128_CBC_SHA 0x0300C018 ++#define TLS1_CK_ECDH_anon_WITH_AES_256_CBC_SHA 0x0300C019 ++ ++/* XXX ++ * Inconsistency alert: ++ * The OpenSSL names of ciphers with ephemeral DH here include the string ++ * "DHE", while elsewhere it has always been "EDH". ++ * (The alias for the list of all such ciphers also is "EDH".) ++ * The specifications speak of "EDH"; maybe we should allow both forms ++ * for everything. */ ++#define TLS1_TXT_RSA_EXPORT1024_WITH_RC4_56_MD5 "EXP1024-RC4-MD5" ++#define TLS1_TXT_RSA_EXPORT1024_WITH_RC2_CBC_56_MD5 "EXP1024-RC2-CBC-MD5" ++#define TLS1_TXT_RSA_EXPORT1024_WITH_DES_CBC_SHA "EXP1024-DES-CBC-SHA" ++#define TLS1_TXT_DHE_DSS_EXPORT1024_WITH_DES_CBC_SHA "EXP1024-DHE-DSS-DES-CBC-SHA" ++#define TLS1_TXT_RSA_EXPORT1024_WITH_RC4_56_SHA "EXP1024-RC4-SHA" ++#define TLS1_TXT_DHE_DSS_EXPORT1024_WITH_RC4_56_SHA "EXP1024-DHE-DSS-RC4-SHA" ++#define TLS1_TXT_DHE_DSS_WITH_RC4_128_SHA "DHE-DSS-RC4-SHA" ++ ++/* AES ciphersuites from RFC3268 */ ++#define TLS1_TXT_RSA_WITH_AES_128_SHA "AES128-SHA" ++#define TLS1_TXT_DH_DSS_WITH_AES_128_SHA "DH-DSS-AES128-SHA" ++#define TLS1_TXT_DH_RSA_WITH_AES_128_SHA "DH-RSA-AES128-SHA" ++#define TLS1_TXT_DHE_DSS_WITH_AES_128_SHA "DHE-DSS-AES128-SHA" ++#define TLS1_TXT_DHE_RSA_WITH_AES_128_SHA "DHE-RSA-AES128-SHA" ++#define TLS1_TXT_ADH_WITH_AES_128_SHA "ADH-AES128-SHA" ++ ++#define TLS1_TXT_RSA_WITH_AES_256_SHA "AES256-SHA" ++#define TLS1_TXT_DH_DSS_WITH_AES_256_SHA "DH-DSS-AES256-SHA" ++#define TLS1_TXT_DH_RSA_WITH_AES_256_SHA "DH-RSA-AES256-SHA" ++#define TLS1_TXT_DHE_DSS_WITH_AES_256_SHA "DHE-DSS-AES256-SHA" ++#define TLS1_TXT_DHE_RSA_WITH_AES_256_SHA "DHE-RSA-AES256-SHA" ++#define TLS1_TXT_ADH_WITH_AES_256_SHA "ADH-AES256-SHA" ++ ++/* ECC ciphersuites from draft-ietf-tls-ecc-01.txt (Mar 15, 2001) */ ++#define TLS1_TXT_ECDH_ECDSA_WITH_NULL_SHA "ECDH-ECDSA-NULL-SHA" ++#define TLS1_TXT_ECDH_ECDSA_WITH_RC4_128_SHA "ECDH-ECDSA-RC4-SHA" ++#define TLS1_TXT_ECDH_ECDSA_WITH_DES_192_CBC3_SHA "ECDH-ECDSA-DES-CBC3-SHA" ++#define TLS1_TXT_ECDH_ECDSA_WITH_AES_128_CBC_SHA "ECDH-ECDSA-AES128-SHA" ++#define TLS1_TXT_ECDH_ECDSA_WITH_AES_256_CBC_SHA "ECDH-ECDSA-AES256-SHA" ++ ++#define TLS1_TXT_ECDHE_ECDSA_WITH_NULL_SHA "ECDHE-ECDSA-NULL-SHA" ++#define TLS1_TXT_ECDHE_ECDSA_WITH_RC4_128_SHA "ECDHE-ECDSA-RC4-SHA" ++#define TLS1_TXT_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA "ECDHE-ECDSA-DES-CBC3-SHA" ++#define TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CBC_SHA "ECDHE-ECDSA-AES128-SHA" ++#define TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CBC_SHA "ECDHE-ECDSA-AES256-SHA" ++ ++#define TLS1_TXT_ECDH_RSA_WITH_NULL_SHA "ECDH-RSA-NULL-SHA" ++#define TLS1_TXT_ECDH_RSA_WITH_RC4_128_SHA "ECDH-RSA-RC4-SHA" ++#define TLS1_TXT_ECDH_RSA_WITH_DES_192_CBC3_SHA "ECDH-RSA-DES-CBC3-SHA" ++#define TLS1_TXT_ECDH_RSA_WITH_AES_128_CBC_SHA "ECDH-RSA-AES128-SHA" ++#define TLS1_TXT_ECDH_RSA_WITH_AES_256_CBC_SHA "ECDH-RSA-AES256-SHA" ++ ++#define TLS1_TXT_ECDHE_RSA_WITH_NULL_SHA "ECDHE-RSA-NULL-SHA" ++#define TLS1_TXT_ECDHE_RSA_WITH_RC4_128_SHA "ECDHE-RSA-RC4-SHA" ++#define TLS1_TXT_ECDHE_RSA_WITH_DES_192_CBC3_SHA "ECDHE-RSA-DES-CBC3-SHA" ++#define TLS1_TXT_ECDHE_RSA_WITH_AES_128_CBC_SHA "ECDHE-RSA-AES128-SHA" ++#define TLS1_TXT_ECDHE_RSA_WITH_AES_256_CBC_SHA "ECDHE-RSA-AES256-SHA" ++ ++#define TLS1_TXT_ECDH_anon_WITH_NULL_SHA "AECDH-NULL-SHA" ++#define TLS1_TXT_ECDH_anon_WITH_RC4_128_SHA "AECDH-RC4-SHA" ++#define TLS1_TXT_ECDH_anon_WITH_DES_192_CBC3_SHA "AECDH-DES-CBC3-SHA" ++#define TLS1_TXT_ECDH_anon_WITH_AES_128_CBC_SHA "AECDH-AES128-SHA" ++#define TLS1_TXT_ECDH_anon_WITH_AES_256_CBC_SHA "AECDH-AES256-SHA" ++ ++/* PSK ciphersuites from RFC 4279 */ ++#define TLS1_TXT_PSK_WITH_RC4_128_SHA "PSK-RC4-SHA" ++#define TLS1_TXT_PSK_WITH_3DES_EDE_CBC_SHA "PSK-3DES-EDE-CBC-SHA" ++#define TLS1_TXT_PSK_WITH_AES_128_CBC_SHA "PSK-AES128-CBC-SHA" ++#define TLS1_TXT_PSK_WITH_AES_256_CBC_SHA "PSK-AES256-CBC-SHA" ++ ++/* Camellia ciphersuites from RFC4132 */ ++#define TLS1_TXT_RSA_WITH_CAMELLIA_128_CBC_SHA "CAMELLIA128-SHA" ++#define TLS1_TXT_DH_DSS_WITH_CAMELLIA_128_CBC_SHA "DH-DSS-CAMELLIA128-SHA" ++#define TLS1_TXT_DH_RSA_WITH_CAMELLIA_128_CBC_SHA "DH-RSA-CAMELLIA128-SHA" ++#define TLS1_TXT_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA "DHE-DSS-CAMELLIA128-SHA" ++#define TLS1_TXT_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA "DHE-RSA-CAMELLIA128-SHA" ++#define TLS1_TXT_ADH_WITH_CAMELLIA_128_CBC_SHA "ADH-CAMELLIA128-SHA" ++ ++#define TLS1_TXT_RSA_WITH_CAMELLIA_256_CBC_SHA "CAMELLIA256-SHA" ++#define TLS1_TXT_DH_DSS_WITH_CAMELLIA_256_CBC_SHA "DH-DSS-CAMELLIA256-SHA" ++#define TLS1_TXT_DH_RSA_WITH_CAMELLIA_256_CBC_SHA "DH-RSA-CAMELLIA256-SHA" ++#define TLS1_TXT_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA "DHE-DSS-CAMELLIA256-SHA" ++#define TLS1_TXT_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA "DHE-RSA-CAMELLIA256-SHA" ++#define TLS1_TXT_ADH_WITH_CAMELLIA_256_CBC_SHA "ADH-CAMELLIA256-SHA" ++ ++/* SEED ciphersuites from RFC4162 */ ++#define TLS1_TXT_RSA_WITH_SEED_SHA "SEED-SHA" ++#define TLS1_TXT_DH_DSS_WITH_SEED_SHA "DH-DSS-SEED-SHA" ++#define TLS1_TXT_DH_RSA_WITH_SEED_SHA "DH-RSA-SEED-SHA" ++#define TLS1_TXT_DHE_DSS_WITH_SEED_SHA "DHE-DSS-SEED-SHA" ++#define TLS1_TXT_DHE_RSA_WITH_SEED_SHA "DHE-RSA-SEED-SHA" ++#define TLS1_TXT_ADH_WITH_SEED_SHA "ADH-SEED-SHA" ++ ++ ++#define TLS_CT_RSA_SIGN 1 ++#define TLS_CT_DSS_SIGN 2 ++#define TLS_CT_RSA_FIXED_DH 3 ++#define TLS_CT_DSS_FIXED_DH 4 ++#define TLS_CT_ECDSA_SIGN 64 ++#define TLS_CT_RSA_FIXED_ECDH 65 ++#define TLS_CT_ECDSA_FIXED_ECDH 66 ++#define TLS_CT_GOST94_SIGN 21 ++#define TLS_CT_GOST01_SIGN 22 ++/* when correcting this number, correct also SSL3_CT_NUMBER in ssl3.h (see ++ * comment there) */ ++#define TLS_CT_NUMBER 9 ++ ++#define TLS1_FINISH_MAC_LENGTH 12 ++ ++#define TLS_MD_MAX_CONST_SIZE 20 ++#define TLS_MD_CLIENT_FINISH_CONST "client finished" ++#define TLS_MD_CLIENT_FINISH_CONST_SIZE 15 ++#define TLS_MD_SERVER_FINISH_CONST "server finished" ++#define TLS_MD_SERVER_FINISH_CONST_SIZE 15 ++#define TLS_MD_SERVER_WRITE_KEY_CONST "server write key" ++#define TLS_MD_SERVER_WRITE_KEY_CONST_SIZE 16 ++#define TLS_MD_KEY_EXPANSION_CONST "key expansion" ++#define TLS_MD_KEY_EXPANSION_CONST_SIZE 13 ++#define TLS_MD_CLIENT_WRITE_KEY_CONST "client write key" ++#define TLS_MD_CLIENT_WRITE_KEY_CONST_SIZE 16 ++#define TLS_MD_SERVER_WRITE_KEY_CONST "server write key" ++#define TLS_MD_SERVER_WRITE_KEY_CONST_SIZE 16 ++#define TLS_MD_IV_BLOCK_CONST "IV block" ++#define TLS_MD_IV_BLOCK_CONST_SIZE 8 ++#define TLS_MD_MASTER_SECRET_CONST "master secret" ++#define TLS_MD_MASTER_SECRET_CONST_SIZE 13 ++ ++#ifdef CHARSET_EBCDIC ++#undef TLS_MD_CLIENT_FINISH_CONST ++#define TLS_MD_CLIENT_FINISH_CONST "\x63\x6c\x69\x65\x6e\x74\x20\x66\x69\x6e\x69\x73\x68\x65\x64" /*client finished*/ ++#undef TLS_MD_SERVER_FINISH_CONST ++#define TLS_MD_SERVER_FINISH_CONST "\x73\x65\x72\x76\x65\x72\x20\x66\x69\x6e\x69\x73\x68\x65\x64" /*server finished*/ ++#undef TLS_MD_SERVER_WRITE_KEY_CONST ++#define TLS_MD_SERVER_WRITE_KEY_CONST "\x73\x65\x72\x76\x65\x72\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79" /*server write key*/ ++#undef TLS_MD_KEY_EXPANSION_CONST ++#define TLS_MD_KEY_EXPANSION_CONST "\x6b\x65\x79\x20\x65\x78\x70\x61\x6e\x73\x69\x6f\x6e" /*key expansion*/ ++#undef TLS_MD_CLIENT_WRITE_KEY_CONST ++#define TLS_MD_CLIENT_WRITE_KEY_CONST "\x63\x6c\x69\x65\x6e\x74\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79" /*client write key*/ ++#undef TLS_MD_SERVER_WRITE_KEY_CONST ++#define TLS_MD_SERVER_WRITE_KEY_CONST "\x73\x65\x72\x76\x65\x72\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79" /*server write key*/ ++#undef TLS_MD_IV_BLOCK_CONST ++#define TLS_MD_IV_BLOCK_CONST "\x49\x56\x20\x62\x6c\x6f\x63\x6b" /*IV block*/ ++#undef TLS_MD_MASTER_SECRET_CONST ++#define TLS_MD_MASTER_SECRET_CONST "\x6d\x61\x73\x74\x65\x72\x20\x73\x65\x63\x72\x65\x74" /*master secret*/ ++#endif ++ ++/* TLS Session Ticket extension struct */ ++struct tls_session_ticket_ext_st ++ { ++ unsigned short length; ++ void *data; ++ }; ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/ts.h qt.patched/include/openssl/ts.h +--- qt.orig/include/openssl/ts.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/ts.h 2010-08-27 12:01:45.743265500 +0200 +@@ -0,0 +1,861 @@ ++/* crypto/ts/ts.h */ ++/* Written by Zoltan Glozik (zglozik@opentsa.org) for the OpenSSL ++ * project 2002, 2003, 2004. ++ */ ++/* ==================================================================== ++ * Copyright (c) 2006 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * licensing@OpenSSL.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++ ++#ifndef HEADER_TS_H ++#define HEADER_TS_H ++ ++#include ++#include ++#ifndef OPENSSL_NO_BUFFER ++#include ++#endif ++#ifndef OPENSSL_NO_EVP ++#include ++#endif ++#ifndef OPENSSL_NO_BIO ++#include ++#endif ++#include ++#include ++#include ++ ++#ifndef OPENSSL_NO_RSA ++#include ++#endif ++ ++#ifndef OPENSSL_NO_DSA ++#include ++#endif ++ ++#ifndef OPENSSL_NO_DH ++#include ++#endif ++ ++#include ++ ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#ifdef WIN32 ++/* Under Win32 this is defined in wincrypt.h */ ++#undef X509_NAME ++#endif ++ ++#include ++#include ++ ++/* ++MessageImprint ::= SEQUENCE { ++ hashAlgorithm AlgorithmIdentifier, ++ hashedMessage OCTET STRING } ++*/ ++ ++typedef struct TS_msg_imprint_st ++ { ++ X509_ALGOR *hash_algo; ++ ASN1_OCTET_STRING *hashed_msg; ++ } TS_MSG_IMPRINT; ++ ++/* ++TimeStampReq ::= SEQUENCE { ++ version INTEGER { v1(1) }, ++ messageImprint MessageImprint, ++ --a hash algorithm OID and the hash value of the data to be ++ --time-stamped ++ reqPolicy TSAPolicyId OPTIONAL, ++ nonce INTEGER OPTIONAL, ++ certReq BOOLEAN DEFAULT FALSE, ++ extensions [0] IMPLICIT Extensions OPTIONAL } ++*/ ++ ++typedef struct TS_req_st ++ { ++ ASN1_INTEGER *version; ++ TS_MSG_IMPRINT *msg_imprint; ++ ASN1_OBJECT *policy_id; /* OPTIONAL */ ++ ASN1_INTEGER *nonce; /* OPTIONAL */ ++ ASN1_BOOLEAN cert_req; /* DEFAULT FALSE */ ++ STACK_OF(X509_EXTENSION) *extensions; /* [0] OPTIONAL */ ++ } TS_REQ; ++ ++/* ++Accuracy ::= SEQUENCE { ++ seconds INTEGER OPTIONAL, ++ millis [0] INTEGER (1..999) OPTIONAL, ++ micros [1] INTEGER (1..999) OPTIONAL } ++*/ ++ ++typedef struct TS_accuracy_st ++ { ++ ASN1_INTEGER *seconds; ++ ASN1_INTEGER *millis; ++ ASN1_INTEGER *micros; ++ } TS_ACCURACY; ++ ++/* ++TSTInfo ::= SEQUENCE { ++ version INTEGER { v1(1) }, ++ policy TSAPolicyId, ++ messageImprint MessageImprint, ++ -- MUST have the same value as the similar field in ++ -- TimeStampReq ++ serialNumber INTEGER, ++ -- Time-Stamping users MUST be ready to accommodate integers ++ -- up to 160 bits. ++ genTime GeneralizedTime, ++ accuracy Accuracy OPTIONAL, ++ ordering BOOLEAN DEFAULT FALSE, ++ nonce INTEGER OPTIONAL, ++ -- MUST be present if the similar field was present ++ -- in TimeStampReq. In that case it MUST have the same value. ++ tsa [0] GeneralName OPTIONAL, ++ extensions [1] IMPLICIT Extensions OPTIONAL } ++*/ ++ ++typedef struct TS_tst_info_st ++ { ++ ASN1_INTEGER *version; ++ ASN1_OBJECT *policy_id; ++ TS_MSG_IMPRINT *msg_imprint; ++ ASN1_INTEGER *serial; ++ ASN1_GENERALIZEDTIME *time; ++ TS_ACCURACY *accuracy; ++ ASN1_BOOLEAN ordering; ++ ASN1_INTEGER *nonce; ++ GENERAL_NAME *tsa; ++ STACK_OF(X509_EXTENSION) *extensions; ++ } TS_TST_INFO; ++ ++/* ++PKIStatusInfo ::= SEQUENCE { ++ status PKIStatus, ++ statusString PKIFreeText OPTIONAL, ++ failInfo PKIFailureInfo OPTIONAL } ++ ++From RFC 1510 - section 3.1.1: ++PKIFreeText ::= SEQUENCE SIZE (1..MAX) OF UTF8String ++ -- text encoded as UTF-8 String (note: each UTF8String SHOULD ++ -- include an RFC 1766 language tag to indicate the language ++ -- of the contained text) ++*/ ++ ++/* Possible values for status. See ts_resp_print.c && ts_resp_verify.c. */ ++ ++#define TS_STATUS_GRANTED 0 ++#define TS_STATUS_GRANTED_WITH_MODS 1 ++#define TS_STATUS_REJECTION 2 ++#define TS_STATUS_WAITING 3 ++#define TS_STATUS_REVOCATION_WARNING 4 ++#define TS_STATUS_REVOCATION_NOTIFICATION 5 ++ ++/* Possible values for failure_info. See ts_resp_print.c && ts_resp_verify.c */ ++ ++#define TS_INFO_BAD_ALG 0 ++#define TS_INFO_BAD_REQUEST 2 ++#define TS_INFO_BAD_DATA_FORMAT 5 ++#define TS_INFO_TIME_NOT_AVAILABLE 14 ++#define TS_INFO_UNACCEPTED_POLICY 15 ++#define TS_INFO_UNACCEPTED_EXTENSION 16 ++#define TS_INFO_ADD_INFO_NOT_AVAILABLE 17 ++#define TS_INFO_SYSTEM_FAILURE 25 ++ ++typedef struct TS_status_info_st ++ { ++ ASN1_INTEGER *status; ++ STACK_OF(ASN1_UTF8STRING) *text; ++ ASN1_BIT_STRING *failure_info; ++ } TS_STATUS_INFO; ++ ++DECLARE_STACK_OF(ASN1_UTF8STRING) ++DECLARE_ASN1_SET_OF(ASN1_UTF8STRING) ++ ++/* ++TimeStampResp ::= SEQUENCE { ++ status PKIStatusInfo, ++ timeStampToken TimeStampToken OPTIONAL } ++*/ ++ ++typedef struct TS_resp_st ++ { ++ TS_STATUS_INFO *status_info; ++ PKCS7 *token; ++ TS_TST_INFO *tst_info; ++ } TS_RESP; ++ ++/* The structure below would belong to the ESS component. */ ++ ++/* ++IssuerSerial ::= SEQUENCE { ++ issuer GeneralNames, ++ serialNumber CertificateSerialNumber ++ } ++*/ ++ ++typedef struct ESS_issuer_serial ++ { ++ STACK_OF(GENERAL_NAME) *issuer; ++ ASN1_INTEGER *serial; ++ } ESS_ISSUER_SERIAL; ++ ++/* ++ESSCertID ::= SEQUENCE { ++ certHash Hash, ++ issuerSerial IssuerSerial OPTIONAL ++} ++*/ ++ ++typedef struct ESS_cert_id ++ { ++ ASN1_OCTET_STRING *hash; /* Always SHA-1 digest. */ ++ ESS_ISSUER_SERIAL *issuer_serial; ++ } ESS_CERT_ID; ++ ++DECLARE_STACK_OF(ESS_CERT_ID) ++DECLARE_ASN1_SET_OF(ESS_CERT_ID) ++ ++/* ++SigningCertificate ::= SEQUENCE { ++ certs SEQUENCE OF ESSCertID, ++ policies SEQUENCE OF PolicyInformation OPTIONAL ++} ++*/ ++ ++typedef struct ESS_signing_cert ++ { ++ STACK_OF(ESS_CERT_ID) *cert_ids; ++ STACK_OF(POLICYINFO) *policy_info; ++ } ESS_SIGNING_CERT; ++ ++ ++TS_REQ *TS_REQ_new(void); ++void TS_REQ_free(TS_REQ *a); ++int i2d_TS_REQ(const TS_REQ *a, unsigned char **pp); ++TS_REQ *d2i_TS_REQ(TS_REQ **a, const unsigned char **pp, long length); ++ ++TS_REQ *TS_REQ_dup(TS_REQ *a); ++ ++TS_REQ *d2i_TS_REQ_fp(FILE *fp, TS_REQ **a); ++int i2d_TS_REQ_fp(FILE *fp, TS_REQ *a); ++TS_REQ *d2i_TS_REQ_bio(BIO *fp, TS_REQ **a); ++int i2d_TS_REQ_bio(BIO *fp, TS_REQ *a); ++ ++TS_MSG_IMPRINT *TS_MSG_IMPRINT_new(void); ++void TS_MSG_IMPRINT_free(TS_MSG_IMPRINT *a); ++int i2d_TS_MSG_IMPRINT(const TS_MSG_IMPRINT *a, unsigned char **pp); ++TS_MSG_IMPRINT *d2i_TS_MSG_IMPRINT(TS_MSG_IMPRINT **a, ++ const unsigned char **pp, long length); ++ ++TS_MSG_IMPRINT *TS_MSG_IMPRINT_dup(TS_MSG_IMPRINT *a); ++ ++TS_MSG_IMPRINT *d2i_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT **a); ++int i2d_TS_MSG_IMPRINT_fp(FILE *fp, TS_MSG_IMPRINT *a); ++TS_MSG_IMPRINT *d2i_TS_MSG_IMPRINT_bio(BIO *fp, TS_MSG_IMPRINT **a); ++int i2d_TS_MSG_IMPRINT_bio(BIO *fp, TS_MSG_IMPRINT *a); ++ ++TS_RESP *TS_RESP_new(void); ++void TS_RESP_free(TS_RESP *a); ++int i2d_TS_RESP(const TS_RESP *a, unsigned char **pp); ++TS_RESP *d2i_TS_RESP(TS_RESP **a, const unsigned char **pp, long length); ++TS_TST_INFO *PKCS7_to_TS_TST_INFO(PKCS7 *token); ++TS_RESP *TS_RESP_dup(TS_RESP *a); ++ ++TS_RESP *d2i_TS_RESP_fp(FILE *fp, TS_RESP **a); ++int i2d_TS_RESP_fp(FILE *fp, TS_RESP *a); ++TS_RESP *d2i_TS_RESP_bio(BIO *fp, TS_RESP **a); ++int i2d_TS_RESP_bio(BIO *fp, TS_RESP *a); ++ ++TS_STATUS_INFO *TS_STATUS_INFO_new(void); ++void TS_STATUS_INFO_free(TS_STATUS_INFO *a); ++int i2d_TS_STATUS_INFO(const TS_STATUS_INFO *a, unsigned char **pp); ++TS_STATUS_INFO *d2i_TS_STATUS_INFO(TS_STATUS_INFO **a, ++ const unsigned char **pp, long length); ++TS_STATUS_INFO *TS_STATUS_INFO_dup(TS_STATUS_INFO *a); ++ ++TS_TST_INFO *TS_TST_INFO_new(void); ++void TS_TST_INFO_free(TS_TST_INFO *a); ++int i2d_TS_TST_INFO(const TS_TST_INFO *a, unsigned char **pp); ++TS_TST_INFO *d2i_TS_TST_INFO(TS_TST_INFO **a, const unsigned char **pp, ++ long length); ++TS_TST_INFO *TS_TST_INFO_dup(TS_TST_INFO *a); ++ ++TS_TST_INFO *d2i_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO **a); ++int i2d_TS_TST_INFO_fp(FILE *fp, TS_TST_INFO *a); ++TS_TST_INFO *d2i_TS_TST_INFO_bio(BIO *fp, TS_TST_INFO **a); ++int i2d_TS_TST_INFO_bio(BIO *fp, TS_TST_INFO *a); ++ ++TS_ACCURACY *TS_ACCURACY_new(void); ++void TS_ACCURACY_free(TS_ACCURACY *a); ++int i2d_TS_ACCURACY(const TS_ACCURACY *a, unsigned char **pp); ++TS_ACCURACY *d2i_TS_ACCURACY(TS_ACCURACY **a, const unsigned char **pp, ++ long length); ++TS_ACCURACY *TS_ACCURACY_dup(TS_ACCURACY *a); ++ ++ESS_ISSUER_SERIAL *ESS_ISSUER_SERIAL_new(void); ++void ESS_ISSUER_SERIAL_free(ESS_ISSUER_SERIAL *a); ++int i2d_ESS_ISSUER_SERIAL(const ESS_ISSUER_SERIAL *a, ++ unsigned char **pp); ++ESS_ISSUER_SERIAL *d2i_ESS_ISSUER_SERIAL(ESS_ISSUER_SERIAL **a, ++ const unsigned char **pp, long length); ++ESS_ISSUER_SERIAL *ESS_ISSUER_SERIAL_dup(ESS_ISSUER_SERIAL *a); ++ ++ESS_CERT_ID *ESS_CERT_ID_new(void); ++void ESS_CERT_ID_free(ESS_CERT_ID *a); ++int i2d_ESS_CERT_ID(const ESS_CERT_ID *a, unsigned char **pp); ++ESS_CERT_ID *d2i_ESS_CERT_ID(ESS_CERT_ID **a, const unsigned char **pp, ++ long length); ++ESS_CERT_ID *ESS_CERT_ID_dup(ESS_CERT_ID *a); ++ ++ESS_SIGNING_CERT *ESS_SIGNING_CERT_new(void); ++void ESS_SIGNING_CERT_free(ESS_SIGNING_CERT *a); ++int i2d_ESS_SIGNING_CERT(const ESS_SIGNING_CERT *a, ++ unsigned char **pp); ++ESS_SIGNING_CERT *d2i_ESS_SIGNING_CERT(ESS_SIGNING_CERT **a, ++ const unsigned char **pp, long length); ++ESS_SIGNING_CERT *ESS_SIGNING_CERT_dup(ESS_SIGNING_CERT *a); ++ ++void ERR_load_TS_strings(void); ++ ++int TS_REQ_set_version(TS_REQ *a, long version); ++long TS_REQ_get_version(const TS_REQ *a); ++ ++int TS_REQ_set_msg_imprint(TS_REQ *a, TS_MSG_IMPRINT *msg_imprint); ++TS_MSG_IMPRINT *TS_REQ_get_msg_imprint(TS_REQ *a); ++ ++int TS_MSG_IMPRINT_set_algo(TS_MSG_IMPRINT *a, X509_ALGOR *alg); ++X509_ALGOR *TS_MSG_IMPRINT_get_algo(TS_MSG_IMPRINT *a); ++ ++int TS_MSG_IMPRINT_set_msg(TS_MSG_IMPRINT *a, unsigned char *d, int len); ++ASN1_OCTET_STRING *TS_MSG_IMPRINT_get_msg(TS_MSG_IMPRINT *a); ++ ++int TS_REQ_set_policy_id(TS_REQ *a, ASN1_OBJECT *policy); ++ASN1_OBJECT *TS_REQ_get_policy_id(TS_REQ *a); ++ ++int TS_REQ_set_nonce(TS_REQ *a, const ASN1_INTEGER *nonce); ++const ASN1_INTEGER *TS_REQ_get_nonce(const TS_REQ *a); ++ ++int TS_REQ_set_cert_req(TS_REQ *a, int cert_req); ++int TS_REQ_get_cert_req(const TS_REQ *a); ++ ++STACK_OF(X509_EXTENSION) *TS_REQ_get_exts(TS_REQ *a); ++void TS_REQ_ext_free(TS_REQ *a); ++int TS_REQ_get_ext_count(TS_REQ *a); ++int TS_REQ_get_ext_by_NID(TS_REQ *a, int nid, int lastpos); ++int TS_REQ_get_ext_by_OBJ(TS_REQ *a, ASN1_OBJECT *obj, int lastpos); ++int TS_REQ_get_ext_by_critical(TS_REQ *a, int crit, int lastpos); ++X509_EXTENSION *TS_REQ_get_ext(TS_REQ *a, int loc); ++X509_EXTENSION *TS_REQ_delete_ext(TS_REQ *a, int loc); ++int TS_REQ_add_ext(TS_REQ *a, X509_EXTENSION *ex, int loc); ++void *TS_REQ_get_ext_d2i(TS_REQ *a, int nid, int *crit, int *idx); ++ ++/* Function declarations for TS_REQ defined in ts/ts_req_print.c */ ++ ++int TS_REQ_print_bio(BIO *bio, TS_REQ *a); ++ ++/* Function declarations for TS_RESP defined in ts/ts_resp_utils.c */ ++ ++int TS_RESP_set_status_info(TS_RESP *a, TS_STATUS_INFO *info); ++TS_STATUS_INFO *TS_RESP_get_status_info(TS_RESP *a); ++ ++/* Caller loses ownership of PKCS7 and TS_TST_INFO objects. */ ++void TS_RESP_set_tst_info(TS_RESP *a, PKCS7 *p7, TS_TST_INFO *tst_info); ++PKCS7 *TS_RESP_get_token(TS_RESP *a); ++TS_TST_INFO *TS_RESP_get_tst_info(TS_RESP *a); ++ ++int TS_TST_INFO_set_version(TS_TST_INFO *a, long version); ++long TS_TST_INFO_get_version(const TS_TST_INFO *a); ++ ++int TS_TST_INFO_set_policy_id(TS_TST_INFO *a, ASN1_OBJECT *policy_id); ++ASN1_OBJECT *TS_TST_INFO_get_policy_id(TS_TST_INFO *a); ++ ++int TS_TST_INFO_set_msg_imprint(TS_TST_INFO *a, TS_MSG_IMPRINT *msg_imprint); ++TS_MSG_IMPRINT *TS_TST_INFO_get_msg_imprint(TS_TST_INFO *a); ++ ++int TS_TST_INFO_set_serial(TS_TST_INFO *a, const ASN1_INTEGER *serial); ++const ASN1_INTEGER *TS_TST_INFO_get_serial(const TS_TST_INFO *a); ++ ++int TS_TST_INFO_set_time(TS_TST_INFO *a, const ASN1_GENERALIZEDTIME *gtime); ++const ASN1_GENERALIZEDTIME *TS_TST_INFO_get_time(const TS_TST_INFO *a); ++ ++int TS_TST_INFO_set_accuracy(TS_TST_INFO *a, TS_ACCURACY *accuracy); ++TS_ACCURACY *TS_TST_INFO_get_accuracy(TS_TST_INFO *a); ++ ++int TS_ACCURACY_set_seconds(TS_ACCURACY *a, const ASN1_INTEGER *seconds); ++const ASN1_INTEGER *TS_ACCURACY_get_seconds(const TS_ACCURACY *a); ++ ++int TS_ACCURACY_set_millis(TS_ACCURACY *a, const ASN1_INTEGER *millis); ++const ASN1_INTEGER *TS_ACCURACY_get_millis(const TS_ACCURACY *a); ++ ++int TS_ACCURACY_set_micros(TS_ACCURACY *a, const ASN1_INTEGER *micros); ++const ASN1_INTEGER *TS_ACCURACY_get_micros(const TS_ACCURACY *a); ++ ++int TS_TST_INFO_set_ordering(TS_TST_INFO *a, int ordering); ++int TS_TST_INFO_get_ordering(const TS_TST_INFO *a); ++ ++int TS_TST_INFO_set_nonce(TS_TST_INFO *a, const ASN1_INTEGER *nonce); ++const ASN1_INTEGER *TS_TST_INFO_get_nonce(const TS_TST_INFO *a); ++ ++int TS_TST_INFO_set_tsa(TS_TST_INFO *a, GENERAL_NAME *tsa); ++GENERAL_NAME *TS_TST_INFO_get_tsa(TS_TST_INFO *a); ++ ++STACK_OF(X509_EXTENSION) *TS_TST_INFO_get_exts(TS_TST_INFO *a); ++void TS_TST_INFO_ext_free(TS_TST_INFO *a); ++int TS_TST_INFO_get_ext_count(TS_TST_INFO *a); ++int TS_TST_INFO_get_ext_by_NID(TS_TST_INFO *a, int nid, int lastpos); ++int TS_TST_INFO_get_ext_by_OBJ(TS_TST_INFO *a, ASN1_OBJECT *obj, int lastpos); ++int TS_TST_INFO_get_ext_by_critical(TS_TST_INFO *a, int crit, int lastpos); ++X509_EXTENSION *TS_TST_INFO_get_ext(TS_TST_INFO *a, int loc); ++X509_EXTENSION *TS_TST_INFO_delete_ext(TS_TST_INFO *a, int loc); ++int TS_TST_INFO_add_ext(TS_TST_INFO *a, X509_EXTENSION *ex, int loc); ++void *TS_TST_INFO_get_ext_d2i(TS_TST_INFO *a, int nid, int *crit, int *idx); ++ ++/* Declarations related to response generation, defined in ts/ts_resp_sign.c. */ ++ ++/* Optional flags for response generation. */ ++ ++/* Don't include the TSA name in response. */ ++#define TS_TSA_NAME 0x01 ++ ++/* Set ordering to true in response. */ ++#define TS_ORDERING 0x02 ++ ++/* ++ * Include the signer certificate and the other specified certificates in ++ * the ESS signing certificate attribute beside the PKCS7 signed data. ++ * Only the signer certificates is included by default. ++ */ ++#define TS_ESS_CERT_ID_CHAIN 0x04 ++ ++/* Forward declaration. */ ++struct TS_resp_ctx; ++ ++/* This must return a unique number less than 160 bits long. */ ++typedef ASN1_INTEGER *(*TS_serial_cb)(struct TS_resp_ctx *, void *); ++ ++/* This must return the seconds and microseconds since Jan 1, 1970 in ++ the sec and usec variables allocated by the caller. ++ Return non-zero for success and zero for failure. */ ++typedef int (*TS_time_cb)(struct TS_resp_ctx *, void *, long *sec, long *usec); ++ ++/* This must process the given extension. ++ * It can modify the TS_TST_INFO object of the context. ++ * Return values: !0 (processed), 0 (error, it must set the ++ * status info/failure info of the response). ++ */ ++typedef int (*TS_extension_cb)(struct TS_resp_ctx *, X509_EXTENSION *, void *); ++ ++typedef struct TS_resp_ctx ++ { ++ X509 *signer_cert; ++ EVP_PKEY *signer_key; ++ STACK_OF(X509) *certs; /* Certs to include in signed data. */ ++ STACK_OF(ASN1_OBJECT) *policies; /* Acceptable policies. */ ++ ASN1_OBJECT *default_policy; /* It may appear in policies, too. */ ++ STACK_OF(EVP_MD) *mds; /* Acceptable message digests. */ ++ ASN1_INTEGER *seconds; /* accuracy, 0 means not specified. */ ++ ASN1_INTEGER *millis; /* accuracy, 0 means not specified. */ ++ ASN1_INTEGER *micros; /* accuracy, 0 means not specified. */ ++ unsigned clock_precision_digits; /* fraction of seconds in ++ time stamp token. */ ++ unsigned flags; /* Optional info, see values above. */ ++ ++ /* Callback functions. */ ++ TS_serial_cb serial_cb; ++ void *serial_cb_data; /* User data for serial_cb. */ ++ ++ TS_time_cb time_cb; ++ void *time_cb_data; /* User data for time_cb. */ ++ ++ TS_extension_cb extension_cb; ++ void *extension_cb_data; /* User data for extension_cb. */ ++ ++ /* These members are used only while creating the response. */ ++ TS_REQ *request; ++ TS_RESP *response; ++ TS_TST_INFO *tst_info; ++ } TS_RESP_CTX; ++ ++DECLARE_STACK_OF(EVP_MD) ++DECLARE_ASN1_SET_OF(EVP_MD) ++ ++/* Creates a response context that can be used for generating responses. */ ++TS_RESP_CTX *TS_RESP_CTX_new(void); ++void TS_RESP_CTX_free(TS_RESP_CTX *ctx); ++ ++/* This parameter must be set. */ ++int TS_RESP_CTX_set_signer_cert(TS_RESP_CTX *ctx, X509 *signer); ++ ++/* This parameter must be set. */ ++int TS_RESP_CTX_set_signer_key(TS_RESP_CTX *ctx, EVP_PKEY *key); ++ ++/* This parameter must be set. */ ++int TS_RESP_CTX_set_def_policy(TS_RESP_CTX *ctx, ASN1_OBJECT *def_policy); ++ ++/* No additional certs are included in the response by default. */ ++int TS_RESP_CTX_set_certs(TS_RESP_CTX *ctx, STACK_OF(X509) *certs); ++ ++/* Adds a new acceptable policy, only the default policy ++ is accepted by default. */ ++int TS_RESP_CTX_add_policy(TS_RESP_CTX *ctx, ASN1_OBJECT *policy); ++ ++/* Adds a new acceptable message digest. Note that no message digests ++ are accepted by default. The md argument is shared with the caller. */ ++int TS_RESP_CTX_add_md(TS_RESP_CTX *ctx, const EVP_MD *md); ++ ++/* Accuracy is not included by default. */ ++int TS_RESP_CTX_set_accuracy(TS_RESP_CTX *ctx, ++ int secs, int millis, int micros); ++ ++/* Clock precision digits, i.e. the number of decimal digits: ++ '0' means sec, '3' msec, '6' usec, and so on. Default is 0. */ ++int TS_RESP_CTX_set_clock_precision_digits(TS_RESP_CTX *ctx, ++ unsigned clock_precision_digits); ++/* At most we accept usec precision. */ ++#define TS_MAX_CLOCK_PRECISION_DIGITS 6 ++ ++/* No flags are set by default. */ ++void TS_RESP_CTX_add_flags(TS_RESP_CTX *ctx, int flags); ++ ++/* Default callback always returns a constant. */ ++void TS_RESP_CTX_set_serial_cb(TS_RESP_CTX *ctx, TS_serial_cb cb, void *data); ++ ++/* Default callback uses the gettimeofday() and gmtime() system calls. */ ++void TS_RESP_CTX_set_time_cb(TS_RESP_CTX *ctx, TS_time_cb cb, void *data); ++ ++/* Default callback rejects all extensions. The extension callback is called ++ * when the TS_TST_INFO object is already set up and not signed yet. */ ++/* FIXME: extension handling is not tested yet. */ ++void TS_RESP_CTX_set_extension_cb(TS_RESP_CTX *ctx, ++ TS_extension_cb cb, void *data); ++ ++/* The following methods can be used in the callbacks. */ ++int TS_RESP_CTX_set_status_info(TS_RESP_CTX *ctx, ++ int status, const char *text); ++ ++/* Sets the status info only if it is still TS_STATUS_GRANTED. */ ++int TS_RESP_CTX_set_status_info_cond(TS_RESP_CTX *ctx, ++ int status, const char *text); ++ ++int TS_RESP_CTX_add_failure_info(TS_RESP_CTX *ctx, int failure); ++ ++/* The get methods below can be used in the extension callback. */ ++TS_REQ *TS_RESP_CTX_get_request(TS_RESP_CTX *ctx); ++ ++TS_TST_INFO *TS_RESP_CTX_get_tst_info(TS_RESP_CTX *ctx); ++ ++/* ++ * Creates the signed TS_TST_INFO and puts it in TS_RESP. ++ * In case of errors it sets the status info properly. ++ * Returns NULL only in case of memory allocation/fatal error. ++ */ ++TS_RESP *TS_RESP_create_response(TS_RESP_CTX *ctx, BIO *req_bio); ++ ++/* ++ * Declarations related to response verification, ++ * they are defined in ts/ts_resp_verify.c. ++ */ ++ ++int TS_RESP_verify_signature(PKCS7 *token, STACK_OF(X509) *certs, ++ X509_STORE *store, X509 **signer_out); ++ ++/* Context structure for the generic verify method. */ ++ ++/* Verify the signer's certificate and the signature of the response. */ ++#define TS_VFY_SIGNATURE (1u << 0) ++/* Verify the version number of the response. */ ++#define TS_VFY_VERSION (1u << 1) ++/* Verify if the policy supplied by the user matches the policy of the TSA. */ ++#define TS_VFY_POLICY (1u << 2) ++/* Verify the message imprint provided by the user. This flag should not be ++ specified with TS_VFY_DATA. */ ++#define TS_VFY_IMPRINT (1u << 3) ++/* Verify the message imprint computed by the verify method from the user ++ provided data and the MD algorithm of the response. This flag should not be ++ specified with TS_VFY_IMPRINT. */ ++#define TS_VFY_DATA (1u << 4) ++/* Verify the nonce value. */ ++#define TS_VFY_NONCE (1u << 5) ++/* Verify if the TSA name field matches the signer certificate. */ ++#define TS_VFY_SIGNER (1u << 6) ++/* Verify if the TSA name field equals to the user provided name. */ ++#define TS_VFY_TSA_NAME (1u << 7) ++ ++/* You can use the following convenience constants. */ ++#define TS_VFY_ALL_IMPRINT (TS_VFY_SIGNATURE \ ++ | TS_VFY_VERSION \ ++ | TS_VFY_POLICY \ ++ | TS_VFY_IMPRINT \ ++ | TS_VFY_NONCE \ ++ | TS_VFY_SIGNER \ ++ | TS_VFY_TSA_NAME) ++#define TS_VFY_ALL_DATA (TS_VFY_SIGNATURE \ ++ | TS_VFY_VERSION \ ++ | TS_VFY_POLICY \ ++ | TS_VFY_DATA \ ++ | TS_VFY_NONCE \ ++ | TS_VFY_SIGNER \ ++ | TS_VFY_TSA_NAME) ++ ++typedef struct TS_verify_ctx ++ { ++ /* Set this to the union of TS_VFY_... flags you want to carry out. */ ++ unsigned flags; ++ ++ /* Must be set only with TS_VFY_SIGNATURE. certs is optional. */ ++ X509_STORE *store; ++ STACK_OF(X509) *certs; ++ ++ /* Must be set only with TS_VFY_POLICY. */ ++ ASN1_OBJECT *policy; ++ ++ /* Must be set only with TS_VFY_IMPRINT. If md_alg is NULL, ++ the algorithm from the response is used. */ ++ X509_ALGOR *md_alg; ++ unsigned char *imprint; ++ unsigned imprint_len; ++ ++ /* Must be set only with TS_VFY_DATA. */ ++ BIO *data; ++ ++ /* Must be set only with TS_VFY_TSA_NAME. */ ++ ASN1_INTEGER *nonce; ++ ++ /* Must be set only with TS_VFY_TSA_NAME. */ ++ GENERAL_NAME *tsa_name; ++ } TS_VERIFY_CTX; ++ ++int TS_RESP_verify_response(TS_VERIFY_CTX *ctx, TS_RESP *response); ++int TS_RESP_verify_token(TS_VERIFY_CTX *ctx, PKCS7 *token); ++ ++/* ++ * Declarations related to response verification context, ++ * they are defined in ts/ts_verify_ctx.c. ++ */ ++ ++/* Set all fields to zero. */ ++TS_VERIFY_CTX *TS_VERIFY_CTX_new(void); ++void TS_VERIFY_CTX_init(TS_VERIFY_CTX *ctx); ++void TS_VERIFY_CTX_free(TS_VERIFY_CTX *ctx); ++void TS_VERIFY_CTX_cleanup(TS_VERIFY_CTX *ctx); ++ ++/* ++ * If ctx is NULL, it allocates and returns a new object, otherwise ++ * it returns ctx. It initialises all the members as follows: ++ * flags = TS_VFY_ALL_IMPRINT & ~(TS_VFY_TSA_NAME | TS_VFY_SIGNATURE) ++ * certs = NULL ++ * store = NULL ++ * policy = policy from the request or NULL if absent (in this case ++ * TS_VFY_POLICY is cleared from flags as well) ++ * md_alg = MD algorithm from request ++ * imprint, imprint_len = imprint from request ++ * data = NULL ++ * nonce, nonce_len = nonce from the request or NULL if absent (in this case ++ * TS_VFY_NONCE is cleared from flags as well) ++ * tsa_name = NULL ++ * Important: after calling this method TS_VFY_SIGNATURE should be added! ++ */ ++TS_VERIFY_CTX *TS_REQ_to_TS_VERIFY_CTX(TS_REQ *req, TS_VERIFY_CTX *ctx); ++ ++/* Function declarations for TS_RESP defined in ts/ts_resp_print.c */ ++ ++int TS_RESP_print_bio(BIO *bio, TS_RESP *a); ++int TS_STATUS_INFO_print_bio(BIO *bio, TS_STATUS_INFO *a); ++int TS_TST_INFO_print_bio(BIO *bio, TS_TST_INFO *a); ++ ++/* Common utility functions defined in ts/ts_lib.c */ ++ ++int TS_ASN1_INTEGER_print_bio(BIO *bio, const ASN1_INTEGER *num); ++int TS_OBJ_print_bio(BIO *bio, const ASN1_OBJECT *obj); ++int TS_ext_print_bio(BIO *bio, const STACK_OF(X509_EXTENSION) *extensions); ++int TS_X509_ALGOR_print_bio(BIO *bio, const X509_ALGOR *alg); ++int TS_MSG_IMPRINT_print_bio(BIO *bio, TS_MSG_IMPRINT *msg); ++ ++/* Function declarations for handling configuration options, ++ defined in ts/ts_conf.c */ ++ ++X509 *TS_CONF_load_cert(const char *file); ++STACK_OF(X509) *TS_CONF_load_certs(const char *file); ++EVP_PKEY *TS_CONF_load_key(const char *file, const char *pass); ++const char *TS_CONF_get_tsa_section(CONF *conf, const char *section); ++int TS_CONF_set_serial(CONF *conf, const char *section, TS_serial_cb cb, ++ TS_RESP_CTX *ctx); ++int TS_CONF_set_crypto_device(CONF *conf, const char *section, ++ const char *device); ++int TS_CONF_set_default_engine(const char *name); ++int TS_CONF_set_signer_cert(CONF *conf, const char *section, ++ const char *cert, TS_RESP_CTX *ctx); ++int TS_CONF_set_certs(CONF *conf, const char *section, const char *certs, ++ TS_RESP_CTX *ctx); ++int TS_CONF_set_signer_key(CONF *conf, const char *section, ++ const char *key, const char *pass, TS_RESP_CTX *ctx); ++int TS_CONF_set_def_policy(CONF *conf, const char *section, ++ const char *policy, TS_RESP_CTX *ctx); ++int TS_CONF_set_policies(CONF *conf, const char *section, TS_RESP_CTX *ctx); ++int TS_CONF_set_digests(CONF *conf, const char *section, TS_RESP_CTX *ctx); ++int TS_CONF_set_accuracy(CONF *conf, const char *section, TS_RESP_CTX *ctx); ++int TS_CONF_set_clock_precision_digits(CONF *conf, const char *section, ++ TS_RESP_CTX *ctx); ++int TS_CONF_set_ordering(CONF *conf, const char *section, TS_RESP_CTX *ctx); ++int TS_CONF_set_tsa_name(CONF *conf, const char *section, TS_RESP_CTX *ctx); ++int TS_CONF_set_ess_cert_id_chain(CONF *conf, const char *section, ++ TS_RESP_CTX *ctx); ++ ++/* -------------------------------------------------- */ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_TS_strings(void); ++ ++/* Error codes for the TS functions. */ ++ ++/* Function codes. */ ++#define TS_F_D2I_TS_RESP 147 ++#define TS_F_DEF_SERIAL_CB 110 ++#define TS_F_DEF_TIME_CB 111 ++#define TS_F_ESS_ADD_SIGNING_CERT 112 ++#define TS_F_ESS_CERT_ID_NEW_INIT 113 ++#define TS_F_ESS_SIGNING_CERT_NEW_INIT 114 ++#define TS_F_INT_TS_RESP_VERIFY_TOKEN 149 ++#define TS_F_PKCS7_TO_TS_TST_INFO 148 ++#define TS_F_TS_ACCURACY_SET_MICROS 115 ++#define TS_F_TS_ACCURACY_SET_MILLIS 116 ++#define TS_F_TS_ACCURACY_SET_SECONDS 117 ++#define TS_F_TS_CHECK_IMPRINTS 100 ++#define TS_F_TS_CHECK_NONCES 101 ++#define TS_F_TS_CHECK_POLICY 102 ++#define TS_F_TS_CHECK_SIGNING_CERTS 103 ++#define TS_F_TS_CHECK_STATUS_INFO 104 ++#define TS_F_TS_COMPUTE_IMPRINT 145 ++#define TS_F_TS_CONF_SET_DEFAULT_ENGINE 146 ++#define TS_F_TS_GET_STATUS_TEXT 105 ++#define TS_F_TS_MSG_IMPRINT_SET_ALGO 118 ++#define TS_F_TS_REQ_SET_MSG_IMPRINT 119 ++#define TS_F_TS_REQ_SET_NONCE 120 ++#define TS_F_TS_REQ_SET_POLICY_ID 121 ++#define TS_F_TS_RESP_CREATE_RESPONSE 122 ++#define TS_F_TS_RESP_CREATE_TST_INFO 123 ++#define TS_F_TS_RESP_CTX_ADD_FAILURE_INFO 124 ++#define TS_F_TS_RESP_CTX_ADD_MD 125 ++#define TS_F_TS_RESP_CTX_ADD_POLICY 126 ++#define TS_F_TS_RESP_CTX_NEW 127 ++#define TS_F_TS_RESP_CTX_SET_ACCURACY 128 ++#define TS_F_TS_RESP_CTX_SET_CERTS 129 ++#define TS_F_TS_RESP_CTX_SET_DEF_POLICY 130 ++#define TS_F_TS_RESP_CTX_SET_SIGNER_CERT 131 ++#define TS_F_TS_RESP_CTX_SET_STATUS_INFO 132 ++#define TS_F_TS_RESP_GET_POLICY 133 ++#define TS_F_TS_RESP_SET_GENTIME_WITH_PRECISION 134 ++#define TS_F_TS_RESP_SET_STATUS_INFO 135 ++#define TS_F_TS_RESP_SET_TST_INFO 150 ++#define TS_F_TS_RESP_SIGN 136 ++#define TS_F_TS_RESP_VERIFY_SIGNATURE 106 ++#define TS_F_TS_RESP_VERIFY_TOKEN 107 ++#define TS_F_TS_TST_INFO_SET_ACCURACY 137 ++#define TS_F_TS_TST_INFO_SET_MSG_IMPRINT 138 ++#define TS_F_TS_TST_INFO_SET_NONCE 139 ++#define TS_F_TS_TST_INFO_SET_POLICY_ID 140 ++#define TS_F_TS_TST_INFO_SET_SERIAL 141 ++#define TS_F_TS_TST_INFO_SET_TIME 142 ++#define TS_F_TS_TST_INFO_SET_TSA 143 ++#define TS_F_TS_VERIFY 108 ++#define TS_F_TS_VERIFY_CERT 109 ++#define TS_F_TS_VERIFY_CTX_NEW 144 ++ ++/* Reason codes. */ ++#define TS_R_BAD_PKCS7_TYPE 132 ++#define TS_R_BAD_TYPE 133 ++#define TS_R_CERTIFICATE_VERIFY_ERROR 100 ++#define TS_R_COULD_NOT_SET_ENGINE 127 ++#define TS_R_COULD_NOT_SET_TIME 115 ++#define TS_R_D2I_TS_RESP_INT_FAILED 128 ++#define TS_R_DETACHED_CONTENT 134 ++#define TS_R_ESS_ADD_SIGNING_CERT_ERROR 116 ++#define TS_R_ESS_SIGNING_CERTIFICATE_ERROR 101 ++#define TS_R_INVALID_NULL_POINTER 102 ++#define TS_R_INVALID_SIGNER_CERTIFICATE_PURPOSE 117 ++#define TS_R_MESSAGE_IMPRINT_MISMATCH 103 ++#define TS_R_NONCE_MISMATCH 104 ++#define TS_R_NONCE_NOT_RETURNED 105 ++#define TS_R_NO_CONTENT 106 ++#define TS_R_NO_TIME_STAMP_TOKEN 107 ++#define TS_R_PKCS7_ADD_SIGNATURE_ERROR 118 ++#define TS_R_PKCS7_ADD_SIGNED_ATTR_ERROR 119 ++#define TS_R_PKCS7_TO_TS_TST_INFO_FAILED 129 ++#define TS_R_POLICY_MISMATCH 108 ++#define TS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 120 ++#define TS_R_RESPONSE_SETUP_ERROR 121 ++#define TS_R_SIGNATURE_FAILURE 109 ++#define TS_R_THERE_MUST_BE_ONE_SIGNER 110 ++#define TS_R_TIME_SYSCALL_ERROR 122 ++#define TS_R_TOKEN_NOT_PRESENT 130 ++#define TS_R_TOKEN_PRESENT 131 ++#define TS_R_TSA_NAME_MISMATCH 111 ++#define TS_R_TSA_UNTRUSTED 112 ++#define TS_R_TST_INFO_SETUP_ERROR 123 ++#define TS_R_TS_DATASIGN 124 ++#define TS_R_UNACCEPTABLE_POLICY 125 ++#define TS_R_UNSUPPORTED_MD_ALGORITHM 126 ++#define TS_R_UNSUPPORTED_VERSION 113 ++#define TS_R_WRONG_CONTENT_TYPE 114 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/txt_db.h qt.patched/include/openssl/txt_db.h +--- qt.orig/include/openssl/txt_db.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/txt_db.h 2010-08-27 12:01:45.758889900 +0200 +@@ -0,0 +1,112 @@ ++/* crypto/txt_db/txt_db.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_TXT_DB_H ++#define HEADER_TXT_DB_H ++ ++#include ++#ifndef OPENSSL_NO_BIO ++#include ++#endif ++#include ++#include ++ ++#define DB_ERROR_OK 0 ++#define DB_ERROR_MALLOC 1 ++#define DB_ERROR_INDEX_CLASH 2 ++#define DB_ERROR_INDEX_OUT_OF_RANGE 3 ++#define DB_ERROR_NO_INDEX 4 ++#define DB_ERROR_INSERT_INDEX_CLASH 5 ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++typedef OPENSSL_STRING *OPENSSL_PSTRING; ++DECLARE_SPECIAL_STACK_OF(OPENSSL_PSTRING, OPENSSL_STRING) ++ ++typedef struct txt_db_st ++ { ++ int num_fields; ++ STACK_OF(OPENSSL_PSTRING) *data; ++ LHASH_OF(OPENSSL_STRING) **index; ++ int (**qual)(OPENSSL_STRING *); ++ long error; ++ long arg1; ++ long arg2; ++ OPENSSL_STRING *arg_row; ++ } TXT_DB; ++ ++#ifndef OPENSSL_NO_BIO ++TXT_DB *TXT_DB_read(BIO *in, int num); ++long TXT_DB_write(BIO *out, TXT_DB *db); ++#else ++TXT_DB *TXT_DB_read(char *in, int num); ++long TXT_DB_write(char *out, TXT_DB *db); ++#endif ++int TXT_DB_create_index(TXT_DB *db,int field,int (*qual)(OPENSSL_STRING *), ++ LHASH_HASH_FN_TYPE hash, LHASH_COMP_FN_TYPE cmp); ++void TXT_DB_free(TXT_DB *db); ++OPENSSL_STRING *TXT_DB_get_by_index(TXT_DB *db, int idx, OPENSSL_STRING *value); ++int TXT_DB_insert(TXT_DB *db, OPENSSL_STRING *value); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff -urN qt.orig/include/openssl/ui.h qt.patched/include/openssl/ui.h +--- qt.orig/include/openssl/ui.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/ui.h 2010-08-27 12:01:45.774514300 +0200 +@@ -0,0 +1,383 @@ ++/* crypto/ui/ui.h -*- mode:C; c-file-style: "eay" -*- */ ++/* Written by Richard Levitte (richard@levitte.org) for the OpenSSL ++ * project 2001. ++ */ ++/* ==================================================================== ++ * Copyright (c) 2001 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * openssl-core@openssl.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.openssl.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++ ++#ifndef HEADER_UI_H ++#define HEADER_UI_H ++ ++#ifndef OPENSSL_NO_DEPRECATED ++#include ++#endif ++#include ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* Declared already in ossl_typ.h */ ++/* typedef struct ui_st UI; */ ++/* typedef struct ui_method_st UI_METHOD; */ ++ ++ ++/* All the following functions return -1 or NULL on error and in some cases ++ (UI_process()) -2 if interrupted or in some other way cancelled. ++ When everything is fine, they return 0, a positive value or a non-NULL ++ pointer, all depending on their purpose. */ ++ ++/* Creators and destructor. */ ++UI *UI_new(void); ++UI *UI_new_method(const UI_METHOD *method); ++void UI_free(UI *ui); ++ ++/* The following functions are used to add strings to be printed and prompt ++ strings to prompt for data. The names are UI_{add,dup}__string ++ and UI_{add,dup}_input_boolean. ++ ++ UI_{add,dup}__string have the following meanings: ++ add add a text or prompt string. The pointers given to these ++ functions are used verbatim, no copying is done. ++ dup make a copy of the text or prompt string, then add the copy ++ to the collection of strings in the user interface. ++ ++ The function is a name for the functionality that the given ++ string shall be used for. It can be one of: ++ input use the string as data prompt. ++ verify use the string as verification prompt. This ++ is used to verify a previous input. ++ info use the string for informational output. ++ error use the string for error output. ++ Honestly, there's currently no difference between info and error for the ++ moment. ++ ++ UI_{add,dup}_input_boolean have the same semantics for "add" and "dup", ++ and are typically used when one wants to prompt for a yes/no response. ++ ++ ++ All of the functions in this group take a UI and a prompt string. ++ The string input and verify addition functions also take a flag argument, ++ a buffer for the result to end up with, a minimum input size and a maximum ++ input size (the result buffer MUST be large enough to be able to contain ++ the maximum number of characters). Additionally, the verify addition ++ functions takes another buffer to compare the result against. ++ The boolean input functions take an action description string (which should ++ be safe to ignore if the expected user action is obvious, for example with ++ a dialog box with an OK button and a Cancel button), a string of acceptable ++ characters to mean OK and to mean Cancel. The two last strings are checked ++ to make sure they don't have common characters. Additionally, the same ++ flag argument as for the string input is taken, as well as a result buffer. ++ The result buffer is required to be at least one byte long. Depending on ++ the answer, the first character from the OK or the Cancel character strings ++ will be stored in the first byte of the result buffer. No NUL will be ++ added, so the result is *not* a string. ++ ++ On success, the all return an index of the added information. That index ++ is usefull when retrieving results with UI_get0_result(). */ ++int UI_add_input_string(UI *ui, const char *prompt, int flags, ++ char *result_buf, int minsize, int maxsize); ++int UI_dup_input_string(UI *ui, const char *prompt, int flags, ++ char *result_buf, int minsize, int maxsize); ++int UI_add_verify_string(UI *ui, const char *prompt, int flags, ++ char *result_buf, int minsize, int maxsize, const char *test_buf); ++int UI_dup_verify_string(UI *ui, const char *prompt, int flags, ++ char *result_buf, int minsize, int maxsize, const char *test_buf); ++int UI_add_input_boolean(UI *ui, const char *prompt, const char *action_desc, ++ const char *ok_chars, const char *cancel_chars, ++ int flags, char *result_buf); ++int UI_dup_input_boolean(UI *ui, const char *prompt, const char *action_desc, ++ const char *ok_chars, const char *cancel_chars, ++ int flags, char *result_buf); ++int UI_add_info_string(UI *ui, const char *text); ++int UI_dup_info_string(UI *ui, const char *text); ++int UI_add_error_string(UI *ui, const char *text); ++int UI_dup_error_string(UI *ui, const char *text); ++ ++/* These are the possible flags. They can be or'ed together. */ ++/* Use to have echoing of input */ ++#define UI_INPUT_FLAG_ECHO 0x01 ++/* Use a default password. Where that password is found is completely ++ up to the application, it might for example be in the user data set ++ with UI_add_user_data(). It is not recommended to have more than ++ one input in each UI being marked with this flag, or the application ++ might get confused. */ ++#define UI_INPUT_FLAG_DEFAULT_PWD 0x02 ++ ++/* The user of these routines may want to define flags of their own. The core ++ UI won't look at those, but will pass them on to the method routines. They ++ must use higher bits so they don't get confused with the UI bits above. ++ UI_INPUT_FLAG_USER_BASE tells which is the lowest bit to use. A good ++ example of use is this: ++ ++ #define MY_UI_FLAG1 (0x01 << UI_INPUT_FLAG_USER_BASE) ++ ++*/ ++#define UI_INPUT_FLAG_USER_BASE 16 ++ ++ ++/* The following function helps construct a prompt. object_desc is a ++ textual short description of the object, for example "pass phrase", ++ and object_name is the name of the object (might be a card name or ++ a file name. ++ The returned string shall always be allocated on the heap with ++ OPENSSL_malloc(), and need to be free'd with OPENSSL_free(). ++ ++ If the ui_method doesn't contain a pointer to a user-defined prompt ++ constructor, a default string is built, looking like this: ++ ++ "Enter {object_desc} for {object_name}:" ++ ++ So, if object_desc has the value "pass phrase" and object_name has ++ the value "foo.key", the resulting string is: ++ ++ "Enter pass phrase for foo.key:" ++*/ ++char *UI_construct_prompt(UI *ui_method, ++ const char *object_desc, const char *object_name); ++ ++ ++/* The following function is used to store a pointer to user-specific data. ++ Any previous such pointer will be returned and replaced. ++ ++ For callback purposes, this function makes a lot more sense than using ++ ex_data, since the latter requires that different parts of OpenSSL or ++ applications share the same ex_data index. ++ ++ Note that the UI_OpenSSL() method completely ignores the user data. ++ Other methods may not, however. */ ++void *UI_add_user_data(UI *ui, void *user_data); ++/* We need a user data retrieving function as well. */ ++void *UI_get0_user_data(UI *ui); ++ ++/* Return the result associated with a prompt given with the index i. */ ++const char *UI_get0_result(UI *ui, int i); ++ ++/* When all strings have been added, process the whole thing. */ ++int UI_process(UI *ui); ++ ++/* Give a user interface parametrised control commands. This can be used to ++ send down an integer, a data pointer or a function pointer, as well as ++ be used to get information from a UI. */ ++int UI_ctrl(UI *ui, int cmd, long i, void *p, void (*f)(void)); ++ ++/* The commands */ ++/* Use UI_CONTROL_PRINT_ERRORS with the value 1 to have UI_process print the ++ OpenSSL error stack before printing any info or added error messages and ++ before any prompting. */ ++#define UI_CTRL_PRINT_ERRORS 1 ++/* Check if a UI_process() is possible to do again with the same instance of ++ a user interface. This makes UI_ctrl() return 1 if it is redoable, and 0 ++ if not. */ ++#define UI_CTRL_IS_REDOABLE 2 ++ ++ ++/* Some methods may use extra data */ ++#define UI_set_app_data(s,arg) UI_set_ex_data(s,0,arg) ++#define UI_get_app_data(s) UI_get_ex_data(s,0) ++int UI_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, ++ CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func); ++int UI_set_ex_data(UI *r,int idx,void *arg); ++void *UI_get_ex_data(UI *r, int idx); ++ ++/* Use specific methods instead of the built-in one */ ++void UI_set_default_method(const UI_METHOD *meth); ++const UI_METHOD *UI_get_default_method(void); ++const UI_METHOD *UI_get_method(UI *ui); ++const UI_METHOD *UI_set_method(UI *ui, const UI_METHOD *meth); ++ ++/* The method with all the built-in thingies */ ++UI_METHOD *UI_OpenSSL(void); ++ ++ ++/* ---------- For method writers ---------- */ ++/* A method contains a number of functions that implement the low level ++ of the User Interface. The functions are: ++ ++ an opener This function starts a session, maybe by opening ++ a channel to a tty, or by opening a window. ++ a writer This function is called to write a given string, ++ maybe to the tty, maybe as a field label in a ++ window. ++ a flusher This function is called to flush everything that ++ has been output so far. It can be used to actually ++ display a dialog box after it has been built. ++ a reader This function is called to read a given prompt, ++ maybe from the tty, maybe from a field in a ++ window. Note that it's called wth all string ++ structures, not only the prompt ones, so it must ++ check such things itself. ++ a closer This function closes the session, maybe by closing ++ the channel to the tty, or closing the window. ++ ++ All these functions are expected to return: ++ ++ 0 on error. ++ 1 on success. ++ -1 on out-of-band events, for example if some prompting has ++ been canceled (by pressing Ctrl-C, for example). This is ++ only checked when returned by the flusher or the reader. ++ ++ The way this is used, the opener is first called, then the writer for all ++ strings, then the flusher, then the reader for all strings and finally the ++ closer. Note that if you want to prompt from a terminal or other command ++ line interface, the best is to have the reader also write the prompts ++ instead of having the writer do it. If you want to prompt from a dialog ++ box, the writer can be used to build up the contents of the box, and the ++ flusher to actually display the box and run the event loop until all data ++ has been given, after which the reader only grabs the given data and puts ++ them back into the UI strings. ++ ++ All method functions take a UI as argument. Additionally, the writer and ++ the reader take a UI_STRING. ++*/ ++ ++/* The UI_STRING type is the data structure that contains all the needed info ++ about a string or a prompt, including test data for a verification prompt. ++*/ ++typedef struct ui_string_st UI_STRING; ++DECLARE_STACK_OF(UI_STRING) ++ ++/* The different types of strings that are currently supported. ++ This is only needed by method authors. */ ++enum UI_string_types ++ { ++ UIT_NONE=0, ++ UIT_PROMPT, /* Prompt for a string */ ++ UIT_VERIFY, /* Prompt for a string and verify */ ++ UIT_BOOLEAN, /* Prompt for a yes/no response */ ++ UIT_INFO, /* Send info to the user */ ++ UIT_ERROR /* Send an error message to the user */ ++ }; ++ ++/* Create and manipulate methods */ ++UI_METHOD *UI_create_method(char *name); ++void UI_destroy_method(UI_METHOD *ui_method); ++int UI_method_set_opener(UI_METHOD *method, int (*opener)(UI *ui)); ++int UI_method_set_writer(UI_METHOD *method, int (*writer)(UI *ui, UI_STRING *uis)); ++int UI_method_set_flusher(UI_METHOD *method, int (*flusher)(UI *ui)); ++int UI_method_set_reader(UI_METHOD *method, int (*reader)(UI *ui, UI_STRING *uis)); ++int UI_method_set_closer(UI_METHOD *method, int (*closer)(UI *ui)); ++int UI_method_set_prompt_constructor(UI_METHOD *method, char *(*prompt_constructor)(UI* ui, const char* object_desc, const char* object_name)); ++int (*UI_method_get_opener(UI_METHOD *method))(UI*); ++int (*UI_method_get_writer(UI_METHOD *method))(UI*,UI_STRING*); ++int (*UI_method_get_flusher(UI_METHOD *method))(UI*); ++int (*UI_method_get_reader(UI_METHOD *method))(UI*,UI_STRING*); ++int (*UI_method_get_closer(UI_METHOD *method))(UI*); ++char* (*UI_method_get_prompt_constructor(UI_METHOD *method))(UI*, const char*, const char*); ++ ++/* The following functions are helpers for method writers to access relevant ++ data from a UI_STRING. */ ++ ++/* Return type of the UI_STRING */ ++enum UI_string_types UI_get_string_type(UI_STRING *uis); ++/* Return input flags of the UI_STRING */ ++int UI_get_input_flags(UI_STRING *uis); ++/* Return the actual string to output (the prompt, info or error) */ ++const char *UI_get0_output_string(UI_STRING *uis); ++/* Return the optional action string to output (the boolean promtp instruction) */ ++const char *UI_get0_action_string(UI_STRING *uis); ++/* Return the result of a prompt */ ++const char *UI_get0_result_string(UI_STRING *uis); ++/* Return the string to test the result against. Only useful with verifies. */ ++const char *UI_get0_test_string(UI_STRING *uis); ++/* Return the required minimum size of the result */ ++int UI_get_result_minsize(UI_STRING *uis); ++/* Return the required maximum size of the result */ ++int UI_get_result_maxsize(UI_STRING *uis); ++/* Set the result of a UI_STRING. */ ++int UI_set_result(UI *ui, UI_STRING *uis, const char *result); ++ ++ ++/* A couple of popular utility functions */ ++int UI_UTIL_read_pw_string(char *buf,int length,const char *prompt,int verify); ++int UI_UTIL_read_pw(char *buf,char *buff,int size,const char *prompt,int verify); ++ ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_UI_strings(void); ++ ++/* Error codes for the UI functions. */ ++ ++/* Function codes. */ ++#define UI_F_GENERAL_ALLOCATE_BOOLEAN 108 ++#define UI_F_GENERAL_ALLOCATE_PROMPT 109 ++#define UI_F_GENERAL_ALLOCATE_STRING 100 ++#define UI_F_UI_CTRL 111 ++#define UI_F_UI_DUP_ERROR_STRING 101 ++#define UI_F_UI_DUP_INFO_STRING 102 ++#define UI_F_UI_DUP_INPUT_BOOLEAN 110 ++#define UI_F_UI_DUP_INPUT_STRING 103 ++#define UI_F_UI_DUP_VERIFY_STRING 106 ++#define UI_F_UI_GET0_RESULT 107 ++#define UI_F_UI_NEW_METHOD 104 ++#define UI_F_UI_SET_RESULT 105 ++ ++/* Reason codes. */ ++#define UI_R_COMMON_OK_AND_CANCEL_CHARACTERS 104 ++#define UI_R_INDEX_TOO_LARGE 102 ++#define UI_R_INDEX_TOO_SMALL 103 ++#define UI_R_NO_RESULT_BUFFER 105 ++#define UI_R_RESULT_TOO_LARGE 100 ++#define UI_R_RESULT_TOO_SMALL 101 ++#define UI_R_UNKNOWN_CONTROL_COMMAND 106 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/ui_compat.h qt.patched/include/openssl/ui_compat.h +--- qt.orig/include/openssl/ui_compat.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/ui_compat.h 2010-08-27 12:01:45.790138700 +0200 +@@ -0,0 +1,83 @@ ++/* crypto/ui/ui.h -*- mode:C; c-file-style: "eay" -*- */ ++/* Written by Richard Levitte (richard@levitte.org) for the OpenSSL ++ * project 2001. ++ */ ++/* ==================================================================== ++ * Copyright (c) 2001 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * openssl-core@openssl.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.openssl.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++ ++#ifndef HEADER_UI_COMPAT_H ++#define HEADER_UI_COMPAT_H ++ ++#include ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* The following functions were previously part of the DES section, ++ and are provided here for backward compatibility reasons. */ ++ ++#define des_read_pw_string(b,l,p,v) \ ++ _ossl_old_des_read_pw_string((b),(l),(p),(v)) ++#define des_read_pw(b,bf,s,p,v) \ ++ _ossl_old_des_read_pw((b),(bf),(s),(p),(v)) ++ ++int _ossl_old_des_read_pw_string(char *buf,int length,const char *prompt,int verify); ++int _ossl_old_des_read_pw(char *buf,char *buff,int size,const char *prompt,int verify); ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/whrlpool.h qt.patched/include/openssl/whrlpool.h +--- qt.orig/include/openssl/whrlpool.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/whrlpool.h 2010-08-27 12:01:45.790138700 +0200 +@@ -0,0 +1,38 @@ ++#ifndef HEADER_WHRLPOOL_H ++#define HEADER_WHRLPOOL_H ++ ++#include ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#define WHIRLPOOL_DIGEST_LENGTH (512/8) ++#define WHIRLPOOL_BBLOCK 512 ++#define WHIRLPOOL_COUNTER (256/8) ++ ++typedef struct { ++ union { ++ unsigned char c[WHIRLPOOL_DIGEST_LENGTH]; ++ /* double q is here to ensure 64-bit alignment */ ++ double q[WHIRLPOOL_DIGEST_LENGTH/sizeof(double)]; ++ } H; ++ unsigned char data[WHIRLPOOL_BBLOCK/8]; ++ unsigned int bitoff; ++ size_t bitlen[WHIRLPOOL_COUNTER/sizeof(size_t)]; ++ } WHIRLPOOL_CTX; ++ ++#ifndef OPENSSL_NO_WHIRLPOOL ++int WHIRLPOOL_Init (WHIRLPOOL_CTX *c); ++int WHIRLPOOL_Update (WHIRLPOOL_CTX *c,const void *inp,size_t bytes); ++void WHIRLPOOL_BitUpdate(WHIRLPOOL_CTX *c,const void *inp,size_t bits); ++int WHIRLPOOL_Final (unsigned char *md,WHIRLPOOL_CTX *c); ++unsigned char *WHIRLPOOL(const void *inp,size_t bytes,unsigned char *md); ++#endif ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff -urN qt.orig/include/openssl/x509.h qt.patched/include/openssl/x509.h +--- qt.orig/include/openssl/x509.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/x509.h 2010-08-27 12:01:45.805763100 +0200 +@@ -0,0 +1,1285 @@ ++/* crypto/x509/x509.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++/* ==================================================================== ++ * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. ++ * ECDH support in OpenSSL originally developed by ++ * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project. ++ */ ++ ++#ifndef HEADER_X509_H ++#define HEADER_X509_H ++ ++#include ++#include ++#ifndef OPENSSL_NO_BUFFER ++#include ++#endif ++#ifndef OPENSSL_NO_EVP ++#include ++#endif ++#ifndef OPENSSL_NO_BIO ++#include ++#endif ++#include ++#include ++#include ++ ++#ifndef OPENSSL_NO_EC ++#include ++#endif ++ ++#ifndef OPENSSL_NO_ECDSA ++#include ++#endif ++ ++#ifndef OPENSSL_NO_ECDH ++#include ++#endif ++ ++#ifndef OPENSSL_NO_DEPRECATED ++#ifndef OPENSSL_NO_RSA ++#include ++#endif ++#ifndef OPENSSL_NO_DSA ++#include ++#endif ++#ifndef OPENSSL_NO_DH ++#include ++#endif ++#endif ++ ++#ifndef OPENSSL_NO_SHA ++#include ++#endif ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#ifdef OPENSSL_SYS_WIN32 ++/* Under Win32 these are defined in wincrypt.h */ ++#undef X509_NAME ++#undef X509_CERT_PAIR ++#undef X509_EXTENSIONS ++#endif ++ ++#define X509_FILETYPE_PEM 1 ++#define X509_FILETYPE_ASN1 2 ++#define X509_FILETYPE_DEFAULT 3 ++ ++#define X509v3_KU_DIGITAL_SIGNATURE 0x0080 ++#define X509v3_KU_NON_REPUDIATION 0x0040 ++#define X509v3_KU_KEY_ENCIPHERMENT 0x0020 ++#define X509v3_KU_DATA_ENCIPHERMENT 0x0010 ++#define X509v3_KU_KEY_AGREEMENT 0x0008 ++#define X509v3_KU_KEY_CERT_SIGN 0x0004 ++#define X509v3_KU_CRL_SIGN 0x0002 ++#define X509v3_KU_ENCIPHER_ONLY 0x0001 ++#define X509v3_KU_DECIPHER_ONLY 0x8000 ++#define X509v3_KU_UNDEF 0xffff ++ ++typedef struct X509_objects_st ++ { ++ int nid; ++ int (*a2i)(void); ++ int (*i2a)(void); ++ } X509_OBJECTS; ++ ++struct X509_algor_st ++ { ++ ASN1_OBJECT *algorithm; ++ ASN1_TYPE *parameter; ++ } /* X509_ALGOR */; ++ ++DECLARE_ASN1_SET_OF(X509_ALGOR) ++ ++typedef STACK_OF(X509_ALGOR) X509_ALGORS; ++ ++typedef struct X509_val_st ++ { ++ ASN1_TIME *notBefore; ++ ASN1_TIME *notAfter; ++ } X509_VAL; ++ ++struct X509_pubkey_st ++ { ++ X509_ALGOR *algor; ++ ASN1_BIT_STRING *public_key; ++ EVP_PKEY *pkey; ++ }; ++ ++typedef struct X509_sig_st ++ { ++ X509_ALGOR *algor; ++ ASN1_OCTET_STRING *digest; ++ } X509_SIG; ++ ++typedef struct X509_name_entry_st ++ { ++ ASN1_OBJECT *object; ++ ASN1_STRING *value; ++ int set; ++ int size; /* temp variable */ ++ } X509_NAME_ENTRY; ++ ++DECLARE_STACK_OF(X509_NAME_ENTRY) ++DECLARE_ASN1_SET_OF(X509_NAME_ENTRY) ++ ++/* we always keep X509_NAMEs in 2 forms. */ ++struct X509_name_st ++ { ++ STACK_OF(X509_NAME_ENTRY) *entries; ++ int modified; /* true if 'bytes' needs to be built */ ++#ifndef OPENSSL_NO_BUFFER ++ BUF_MEM *bytes; ++#else ++ char *bytes; ++#endif ++/* unsigned long hash; Keep the hash around for lookups */ ++ unsigned char *canon_enc; ++ int canon_enclen; ++ } /* X509_NAME */; ++ ++DECLARE_STACK_OF(X509_NAME) ++ ++#define X509_EX_V_NETSCAPE_HACK 0x8000 ++#define X509_EX_V_INIT 0x0001 ++typedef struct X509_extension_st ++ { ++ ASN1_OBJECT *object; ++ ASN1_BOOLEAN critical; ++ ASN1_OCTET_STRING *value; ++ } X509_EXTENSION; ++ ++typedef STACK_OF(X509_EXTENSION) X509_EXTENSIONS; ++ ++DECLARE_STACK_OF(X509_EXTENSION) ++DECLARE_ASN1_SET_OF(X509_EXTENSION) ++ ++/* a sequence of these are used */ ++typedef struct x509_attributes_st ++ { ++ ASN1_OBJECT *object; ++ int single; /* 0 for a set, 1 for a single item (which is wrong) */ ++ union { ++ char *ptr; ++/* 0 */ STACK_OF(ASN1_TYPE) *set; ++/* 1 */ ASN1_TYPE *single; ++ } value; ++ } X509_ATTRIBUTE; ++ ++DECLARE_STACK_OF(X509_ATTRIBUTE) ++DECLARE_ASN1_SET_OF(X509_ATTRIBUTE) ++ ++ ++typedef struct X509_req_info_st ++ { ++ ASN1_ENCODING enc; ++ ASN1_INTEGER *version; ++ X509_NAME *subject; ++ X509_PUBKEY *pubkey; ++ /* d=2 hl=2 l= 0 cons: cont: 00 */ ++ STACK_OF(X509_ATTRIBUTE) *attributes; /* [ 0 ] */ ++ } X509_REQ_INFO; ++ ++typedef struct X509_req_st ++ { ++ X509_REQ_INFO *req_info; ++ X509_ALGOR *sig_alg; ++ ASN1_BIT_STRING *signature; ++ int references; ++ } X509_REQ; ++ ++typedef struct x509_cinf_st ++ { ++ ASN1_INTEGER *version; /* [ 0 ] default of v1 */ ++ ASN1_INTEGER *serialNumber; ++ X509_ALGOR *signature; ++ X509_NAME *issuer; ++ X509_VAL *validity; ++ X509_NAME *subject; ++ X509_PUBKEY *key; ++ ASN1_BIT_STRING *issuerUID; /* [ 1 ] optional in v2 */ ++ ASN1_BIT_STRING *subjectUID; /* [ 2 ] optional in v2 */ ++ STACK_OF(X509_EXTENSION) *extensions; /* [ 3 ] optional in v3 */ ++ } X509_CINF; ++ ++/* This stuff is certificate "auxiliary info" ++ * it contains details which are useful in certificate ++ * stores and databases. When used this is tagged onto ++ * the end of the certificate itself ++ */ ++ ++typedef struct x509_cert_aux_st ++ { ++ STACK_OF(ASN1_OBJECT) *trust; /* trusted uses */ ++ STACK_OF(ASN1_OBJECT) *reject; /* rejected uses */ ++ ASN1_UTF8STRING *alias; /* "friendly name" */ ++ ASN1_OCTET_STRING *keyid; /* key id of private key */ ++ STACK_OF(X509_ALGOR) *other; /* other unspecified info */ ++ } X509_CERT_AUX; ++ ++struct x509_st ++ { ++ X509_CINF *cert_info; ++ X509_ALGOR *sig_alg; ++ ASN1_BIT_STRING *signature; ++ int valid; ++ int references; ++ char *name; ++ CRYPTO_EX_DATA ex_data; ++ /* These contain copies of various extension values */ ++ long ex_pathlen; ++ long ex_pcpathlen; ++ unsigned long ex_flags; ++ unsigned long ex_kusage; ++ unsigned long ex_xkusage; ++ unsigned long ex_nscert; ++ ASN1_OCTET_STRING *skid; ++ AUTHORITY_KEYID *akid; ++ X509_POLICY_CACHE *policy_cache; ++ STACK_OF(DIST_POINT) *crldp; ++ STACK_OF(GENERAL_NAME) *altname; ++ NAME_CONSTRAINTS *nc; ++#ifndef OPENSSL_NO_RFC3779 ++ STACK_OF(IPAddressFamily) *rfc3779_addr; ++ struct ASIdentifiers_st *rfc3779_asid; ++#endif ++#ifndef OPENSSL_NO_SHA ++ unsigned char sha1_hash[SHA_DIGEST_LENGTH]; ++#endif ++ X509_CERT_AUX *aux; ++ } /* X509 */; ++ ++DECLARE_STACK_OF(X509) ++DECLARE_ASN1_SET_OF(X509) ++ ++/* This is used for a table of trust checking functions */ ++ ++typedef struct x509_trust_st { ++ int trust; ++ int flags; ++ int (*check_trust)(struct x509_trust_st *, X509 *, int); ++ char *name; ++ int arg1; ++ void *arg2; ++} X509_TRUST; ++ ++DECLARE_STACK_OF(X509_TRUST) ++ ++typedef struct x509_cert_pair_st { ++ X509 *forward; ++ X509 *reverse; ++} X509_CERT_PAIR; ++ ++/* standard trust ids */ ++ ++#define X509_TRUST_DEFAULT -1 /* Only valid in purpose settings */ ++ ++#define X509_TRUST_COMPAT 1 ++#define X509_TRUST_SSL_CLIENT 2 ++#define X509_TRUST_SSL_SERVER 3 ++#define X509_TRUST_EMAIL 4 ++#define X509_TRUST_OBJECT_SIGN 5 ++#define X509_TRUST_OCSP_SIGN 6 ++#define X509_TRUST_OCSP_REQUEST 7 ++#define X509_TRUST_TSA 8 ++ ++/* Keep these up to date! */ ++#define X509_TRUST_MIN 1 ++#define X509_TRUST_MAX 8 ++ ++ ++/* trust_flags values */ ++#define X509_TRUST_DYNAMIC 1 ++#define X509_TRUST_DYNAMIC_NAME 2 ++ ++/* check_trust return codes */ ++ ++#define X509_TRUST_TRUSTED 1 ++#define X509_TRUST_REJECTED 2 ++#define X509_TRUST_UNTRUSTED 3 ++ ++/* Flags for X509_print_ex() */ ++ ++#define X509_FLAG_COMPAT 0 ++#define X509_FLAG_NO_HEADER 1L ++#define X509_FLAG_NO_VERSION (1L << 1) ++#define X509_FLAG_NO_SERIAL (1L << 2) ++#define X509_FLAG_NO_SIGNAME (1L << 3) ++#define X509_FLAG_NO_ISSUER (1L << 4) ++#define X509_FLAG_NO_VALIDITY (1L << 5) ++#define X509_FLAG_NO_SUBJECT (1L << 6) ++#define X509_FLAG_NO_PUBKEY (1L << 7) ++#define X509_FLAG_NO_EXTENSIONS (1L << 8) ++#define X509_FLAG_NO_SIGDUMP (1L << 9) ++#define X509_FLAG_NO_AUX (1L << 10) ++#define X509_FLAG_NO_ATTRIBUTES (1L << 11) ++ ++/* Flags specific to X509_NAME_print_ex() */ ++ ++/* The field separator information */ ++ ++#define XN_FLAG_SEP_MASK (0xf << 16) ++ ++#define XN_FLAG_COMPAT 0 /* Traditional SSLeay: use old X509_NAME_print */ ++#define XN_FLAG_SEP_COMMA_PLUS (1 << 16) /* RFC2253 ,+ */ ++#define XN_FLAG_SEP_CPLUS_SPC (2 << 16) /* ,+ spaced: more readable */ ++#define XN_FLAG_SEP_SPLUS_SPC (3 << 16) /* ;+ spaced */ ++#define XN_FLAG_SEP_MULTILINE (4 << 16) /* One line per field */ ++ ++#define XN_FLAG_DN_REV (1 << 20) /* Reverse DN order */ ++ ++/* How the field name is shown */ ++ ++#define XN_FLAG_FN_MASK (0x3 << 21) ++ ++#define XN_FLAG_FN_SN 0 /* Object short name */ ++#define XN_FLAG_FN_LN (1 << 21) /* Object long name */ ++#define XN_FLAG_FN_OID (2 << 21) /* Always use OIDs */ ++#define XN_FLAG_FN_NONE (3 << 21) /* No field names */ ++ ++#define XN_FLAG_SPC_EQ (1 << 23) /* Put spaces round '=' */ ++ ++/* This determines if we dump fields we don't recognise: ++ * RFC2253 requires this. ++ */ ++ ++#define XN_FLAG_DUMP_UNKNOWN_FIELDS (1 << 24) ++ ++#define XN_FLAG_FN_ALIGN (1 << 25) /* Align field names to 20 characters */ ++ ++/* Complete set of RFC2253 flags */ ++ ++#define XN_FLAG_RFC2253 (ASN1_STRFLGS_RFC2253 | \ ++ XN_FLAG_SEP_COMMA_PLUS | \ ++ XN_FLAG_DN_REV | \ ++ XN_FLAG_FN_SN | \ ++ XN_FLAG_DUMP_UNKNOWN_FIELDS) ++ ++/* readable oneline form */ ++ ++#define XN_FLAG_ONELINE (ASN1_STRFLGS_RFC2253 | \ ++ ASN1_STRFLGS_ESC_QUOTE | \ ++ XN_FLAG_SEP_CPLUS_SPC | \ ++ XN_FLAG_SPC_EQ | \ ++ XN_FLAG_FN_SN) ++ ++/* readable multiline form */ ++ ++#define XN_FLAG_MULTILINE (ASN1_STRFLGS_ESC_CTRL | \ ++ ASN1_STRFLGS_ESC_MSB | \ ++ XN_FLAG_SEP_MULTILINE | \ ++ XN_FLAG_SPC_EQ | \ ++ XN_FLAG_FN_LN | \ ++ XN_FLAG_FN_ALIGN) ++ ++struct x509_revoked_st ++ { ++ ASN1_INTEGER *serialNumber; ++ ASN1_TIME *revocationDate; ++ STACK_OF(X509_EXTENSION) /* optional */ *extensions; ++ /* Set up if indirect CRL */ ++ STACK_OF(GENERAL_NAME) *issuer; ++ /* Revocation reason */ ++ int reason; ++ int sequence; /* load sequence */ ++ }; ++ ++DECLARE_STACK_OF(X509_REVOKED) ++DECLARE_ASN1_SET_OF(X509_REVOKED) ++ ++typedef struct X509_crl_info_st ++ { ++ ASN1_INTEGER *version; ++ X509_ALGOR *sig_alg; ++ X509_NAME *issuer; ++ ASN1_TIME *lastUpdate; ++ ASN1_TIME *nextUpdate; ++ STACK_OF(X509_REVOKED) *revoked; ++ STACK_OF(X509_EXTENSION) /* [0] */ *extensions; ++ ASN1_ENCODING enc; ++ } X509_CRL_INFO; ++ ++struct X509_crl_st ++ { ++ /* actual signature */ ++ X509_CRL_INFO *crl; ++ X509_ALGOR *sig_alg; ++ ASN1_BIT_STRING *signature; ++ int references; ++ int flags; ++ /* Copies of various extensions */ ++ AUTHORITY_KEYID *akid; ++ ISSUING_DIST_POINT *idp; ++ /* Convenient breakdown of IDP */ ++ int idp_flags; ++ int idp_reasons; ++ /* CRL and base CRL numbers for delta processing */ ++ ASN1_INTEGER *crl_number; ++ ASN1_INTEGER *base_crl_number; ++#ifndef OPENSSL_NO_SHA ++ unsigned char sha1_hash[SHA_DIGEST_LENGTH]; ++#endif ++ STACK_OF(GENERAL_NAMES) *issuers; ++ const X509_CRL_METHOD *meth; ++ void *meth_data; ++ } /* X509_CRL */; ++ ++DECLARE_STACK_OF(X509_CRL) ++DECLARE_ASN1_SET_OF(X509_CRL) ++ ++typedef struct private_key_st ++ { ++ int version; ++ /* The PKCS#8 data types */ ++ X509_ALGOR *enc_algor; ++ ASN1_OCTET_STRING *enc_pkey; /* encrypted pub key */ ++ ++ /* When decrypted, the following will not be NULL */ ++ EVP_PKEY *dec_pkey; ++ ++ /* used to encrypt and decrypt */ ++ int key_length; ++ char *key_data; ++ int key_free; /* true if we should auto free key_data */ ++ ++ /* expanded version of 'enc_algor' */ ++ EVP_CIPHER_INFO cipher; ++ ++ int references; ++ } X509_PKEY; ++ ++#ifndef OPENSSL_NO_EVP ++typedef struct X509_info_st ++ { ++ X509 *x509; ++ X509_CRL *crl; ++ X509_PKEY *x_pkey; ++ ++ EVP_CIPHER_INFO enc_cipher; ++ int enc_len; ++ char *enc_data; ++ ++ int references; ++ } X509_INFO; ++ ++DECLARE_STACK_OF(X509_INFO) ++#endif ++ ++/* The next 2 structures and their 8 routines were sent to me by ++ * Pat Richard and are used to manipulate ++ * Netscapes spki structures - useful if you are writing a CA web page ++ */ ++typedef struct Netscape_spkac_st ++ { ++ X509_PUBKEY *pubkey; ++ ASN1_IA5STRING *challenge; /* challenge sent in atlas >= PR2 */ ++ } NETSCAPE_SPKAC; ++ ++typedef struct Netscape_spki_st ++ { ++ NETSCAPE_SPKAC *spkac; /* signed public key and challenge */ ++ X509_ALGOR *sig_algor; ++ ASN1_BIT_STRING *signature; ++ } NETSCAPE_SPKI; ++ ++/* Netscape certificate sequence structure */ ++typedef struct Netscape_certificate_sequence ++ { ++ ASN1_OBJECT *type; ++ STACK_OF(X509) *certs; ++ } NETSCAPE_CERT_SEQUENCE; ++ ++/* Unused (and iv length is wrong) ++typedef struct CBCParameter_st ++ { ++ unsigned char iv[8]; ++ } CBC_PARAM; ++*/ ++ ++/* Password based encryption structure */ ++ ++typedef struct PBEPARAM_st { ++ASN1_OCTET_STRING *salt; ++ASN1_INTEGER *iter; ++} PBEPARAM; ++ ++/* Password based encryption V2 structures */ ++ ++typedef struct PBE2PARAM_st { ++X509_ALGOR *keyfunc; ++X509_ALGOR *encryption; ++} PBE2PARAM; ++ ++typedef struct PBKDF2PARAM_st { ++ASN1_TYPE *salt; /* Usually OCTET STRING but could be anything */ ++ASN1_INTEGER *iter; ++ASN1_INTEGER *keylength; ++X509_ALGOR *prf; ++} PBKDF2PARAM; ++ ++ ++/* PKCS#8 private key info structure */ ++ ++struct pkcs8_priv_key_info_st ++ { ++ int broken; /* Flag for various broken formats */ ++#define PKCS8_OK 0 ++#define PKCS8_NO_OCTET 1 ++#define PKCS8_EMBEDDED_PARAM 2 ++#define PKCS8_NS_DB 3 ++#define PKCS8_NEG_PRIVKEY 4 ++ ASN1_INTEGER *version; ++ X509_ALGOR *pkeyalg; ++ ASN1_TYPE *pkey; /* Should be OCTET STRING but some are broken */ ++ STACK_OF(X509_ATTRIBUTE) *attributes; ++ }; ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#include ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#define X509_EXT_PACK_UNKNOWN 1 ++#define X509_EXT_PACK_STRING 2 ++ ++#define X509_get_version(x) ASN1_INTEGER_get((x)->cert_info->version) ++/* #define X509_get_serialNumber(x) ((x)->cert_info->serialNumber) */ ++#define X509_get_notBefore(x) ((x)->cert_info->validity->notBefore) ++#define X509_get_notAfter(x) ((x)->cert_info->validity->notAfter) ++#define X509_extract_key(x) X509_get_pubkey(x) /*****/ ++#define X509_REQ_get_version(x) ASN1_INTEGER_get((x)->req_info->version) ++#define X509_REQ_get_subject_name(x) ((x)->req_info->subject) ++#define X509_REQ_extract_key(a) X509_REQ_get_pubkey(a) ++#define X509_name_cmp(a,b) X509_NAME_cmp((a),(b)) ++#define X509_get_signature_type(x) EVP_PKEY_type(OBJ_obj2nid((x)->sig_alg->algorithm)) ++ ++#define X509_CRL_get_version(x) ASN1_INTEGER_get((x)->crl->version) ++#define X509_CRL_get_lastUpdate(x) ((x)->crl->lastUpdate) ++#define X509_CRL_get_nextUpdate(x) ((x)->crl->nextUpdate) ++#define X509_CRL_get_issuer(x) ((x)->crl->issuer) ++#define X509_CRL_get_REVOKED(x) ((x)->crl->revoked) ++ ++void X509_CRL_set_default_method(const X509_CRL_METHOD *meth); ++X509_CRL_METHOD *X509_CRL_METHOD_new( ++ int (*crl_init)(X509_CRL *crl), ++ int (*crl_free)(X509_CRL *crl), ++ int (*crl_lookup)(X509_CRL *crl, X509_REVOKED **ret, ++ ASN1_INTEGER *ser, X509_NAME *issuer), ++ int (*crl_verify)(X509_CRL *crl, EVP_PKEY *pk)); ++void X509_CRL_METHOD_free(X509_CRL_METHOD *m); ++ ++void X509_CRL_set_meth_data(X509_CRL *crl, void *dat); ++void *X509_CRL_get_meth_data(X509_CRL *crl); ++ ++/* This one is only used so that a binary form can output, as in ++ * i2d_X509_NAME(X509_get_X509_PUBKEY(x),&buf) */ ++#define X509_get_X509_PUBKEY(x) ((x)->cert_info->key) ++ ++ ++const char *X509_verify_cert_error_string(long n); ++ ++#ifndef OPENSSL_NO_EVP ++int X509_verify(X509 *a, EVP_PKEY *r); ++ ++int X509_REQ_verify(X509_REQ *a, EVP_PKEY *r); ++int X509_CRL_verify(X509_CRL *a, EVP_PKEY *r); ++int NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r); ++ ++NETSCAPE_SPKI * NETSCAPE_SPKI_b64_decode(const char *str, int len); ++char * NETSCAPE_SPKI_b64_encode(NETSCAPE_SPKI *x); ++EVP_PKEY *NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI *x); ++int NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI *x, EVP_PKEY *pkey); ++ ++int NETSCAPE_SPKI_print(BIO *out, NETSCAPE_SPKI *spki); ++ ++int X509_signature_print(BIO *bp,X509_ALGOR *alg, ASN1_STRING *sig); ++ ++int X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md); ++int X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md); ++int X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md); ++int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md); ++ ++int X509_pubkey_digest(const X509 *data,const EVP_MD *type, ++ unsigned char *md, unsigned int *len); ++int X509_digest(const X509 *data,const EVP_MD *type, ++ unsigned char *md, unsigned int *len); ++int X509_CRL_digest(const X509_CRL *data,const EVP_MD *type, ++ unsigned char *md, unsigned int *len); ++int X509_REQ_digest(const X509_REQ *data,const EVP_MD *type, ++ unsigned char *md, unsigned int *len); ++int X509_NAME_digest(const X509_NAME *data,const EVP_MD *type, ++ unsigned char *md, unsigned int *len); ++#endif ++ ++#ifndef OPENSSL_NO_FP_API ++X509 *d2i_X509_fp(FILE *fp, X509 **x509); ++int i2d_X509_fp(FILE *fp,X509 *x509); ++X509_CRL *d2i_X509_CRL_fp(FILE *fp,X509_CRL **crl); ++int i2d_X509_CRL_fp(FILE *fp,X509_CRL *crl); ++X509_REQ *d2i_X509_REQ_fp(FILE *fp,X509_REQ **req); ++int i2d_X509_REQ_fp(FILE *fp,X509_REQ *req); ++#ifndef OPENSSL_NO_RSA ++RSA *d2i_RSAPrivateKey_fp(FILE *fp,RSA **rsa); ++int i2d_RSAPrivateKey_fp(FILE *fp,RSA *rsa); ++RSA *d2i_RSAPublicKey_fp(FILE *fp,RSA **rsa); ++int i2d_RSAPublicKey_fp(FILE *fp,RSA *rsa); ++RSA *d2i_RSA_PUBKEY_fp(FILE *fp,RSA **rsa); ++int i2d_RSA_PUBKEY_fp(FILE *fp,RSA *rsa); ++#endif ++#ifndef OPENSSL_NO_DSA ++DSA *d2i_DSA_PUBKEY_fp(FILE *fp, DSA **dsa); ++int i2d_DSA_PUBKEY_fp(FILE *fp, DSA *dsa); ++DSA *d2i_DSAPrivateKey_fp(FILE *fp, DSA **dsa); ++int i2d_DSAPrivateKey_fp(FILE *fp, DSA *dsa); ++#endif ++#ifndef OPENSSL_NO_EC ++EC_KEY *d2i_EC_PUBKEY_fp(FILE *fp, EC_KEY **eckey); ++int i2d_EC_PUBKEY_fp(FILE *fp, EC_KEY *eckey); ++EC_KEY *d2i_ECPrivateKey_fp(FILE *fp, EC_KEY **eckey); ++int i2d_ECPrivateKey_fp(FILE *fp, EC_KEY *eckey); ++#endif ++X509_SIG *d2i_PKCS8_fp(FILE *fp,X509_SIG **p8); ++int i2d_PKCS8_fp(FILE *fp,X509_SIG *p8); ++PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, ++ PKCS8_PRIV_KEY_INFO **p8inf); ++int i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp,PKCS8_PRIV_KEY_INFO *p8inf); ++int i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, EVP_PKEY *key); ++int i2d_PrivateKey_fp(FILE *fp, EVP_PKEY *pkey); ++EVP_PKEY *d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a); ++int i2d_PUBKEY_fp(FILE *fp, EVP_PKEY *pkey); ++EVP_PKEY *d2i_PUBKEY_fp(FILE *fp, EVP_PKEY **a); ++#endif ++ ++#ifndef OPENSSL_NO_BIO ++X509 *d2i_X509_bio(BIO *bp,X509 **x509); ++int i2d_X509_bio(BIO *bp,X509 *x509); ++X509_CRL *d2i_X509_CRL_bio(BIO *bp,X509_CRL **crl); ++int i2d_X509_CRL_bio(BIO *bp,X509_CRL *crl); ++X509_REQ *d2i_X509_REQ_bio(BIO *bp,X509_REQ **req); ++int i2d_X509_REQ_bio(BIO *bp,X509_REQ *req); ++#ifndef OPENSSL_NO_RSA ++RSA *d2i_RSAPrivateKey_bio(BIO *bp,RSA **rsa); ++int i2d_RSAPrivateKey_bio(BIO *bp,RSA *rsa); ++RSA *d2i_RSAPublicKey_bio(BIO *bp,RSA **rsa); ++int i2d_RSAPublicKey_bio(BIO *bp,RSA *rsa); ++RSA *d2i_RSA_PUBKEY_bio(BIO *bp,RSA **rsa); ++int i2d_RSA_PUBKEY_bio(BIO *bp,RSA *rsa); ++#endif ++#ifndef OPENSSL_NO_DSA ++DSA *d2i_DSA_PUBKEY_bio(BIO *bp, DSA **dsa); ++int i2d_DSA_PUBKEY_bio(BIO *bp, DSA *dsa); ++DSA *d2i_DSAPrivateKey_bio(BIO *bp, DSA **dsa); ++int i2d_DSAPrivateKey_bio(BIO *bp, DSA *dsa); ++#endif ++#ifndef OPENSSL_NO_EC ++EC_KEY *d2i_EC_PUBKEY_bio(BIO *bp, EC_KEY **eckey); ++int i2d_EC_PUBKEY_bio(BIO *bp, EC_KEY *eckey); ++EC_KEY *d2i_ECPrivateKey_bio(BIO *bp, EC_KEY **eckey); ++int i2d_ECPrivateKey_bio(BIO *bp, EC_KEY *eckey); ++#endif ++X509_SIG *d2i_PKCS8_bio(BIO *bp,X509_SIG **p8); ++int i2d_PKCS8_bio(BIO *bp,X509_SIG *p8); ++PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, ++ PKCS8_PRIV_KEY_INFO **p8inf); ++int i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp,PKCS8_PRIV_KEY_INFO *p8inf); ++int i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, EVP_PKEY *key); ++int i2d_PrivateKey_bio(BIO *bp, EVP_PKEY *pkey); ++EVP_PKEY *d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a); ++int i2d_PUBKEY_bio(BIO *bp, EVP_PKEY *pkey); ++EVP_PKEY *d2i_PUBKEY_bio(BIO *bp, EVP_PKEY **a); ++#endif ++ ++X509 *X509_dup(X509 *x509); ++X509_ATTRIBUTE *X509_ATTRIBUTE_dup(X509_ATTRIBUTE *xa); ++X509_EXTENSION *X509_EXTENSION_dup(X509_EXTENSION *ex); ++X509_CRL *X509_CRL_dup(X509_CRL *crl); ++X509_REQ *X509_REQ_dup(X509_REQ *req); ++X509_ALGOR *X509_ALGOR_dup(X509_ALGOR *xn); ++int X509_ALGOR_set0(X509_ALGOR *alg, ASN1_OBJECT *aobj, int ptype, void *pval); ++void X509_ALGOR_get0(ASN1_OBJECT **paobj, int *pptype, void **ppval, ++ X509_ALGOR *algor); ++ ++X509_NAME *X509_NAME_dup(X509_NAME *xn); ++X509_NAME_ENTRY *X509_NAME_ENTRY_dup(X509_NAME_ENTRY *ne); ++ ++int X509_cmp_time(const ASN1_TIME *s, time_t *t); ++int X509_cmp_current_time(const ASN1_TIME *s); ++ASN1_TIME * X509_time_adj(ASN1_TIME *s, long adj, time_t *t); ++ASN1_TIME * X509_time_adj_ex(ASN1_TIME *s, ++ int offset_day, long offset_sec, time_t *t); ++ASN1_TIME * X509_gmtime_adj(ASN1_TIME *s, long adj); ++ ++const char * X509_get_default_cert_area(void ); ++const char * X509_get_default_cert_dir(void ); ++const char * X509_get_default_cert_file(void ); ++const char * X509_get_default_cert_dir_env(void ); ++const char * X509_get_default_cert_file_env(void ); ++const char * X509_get_default_private_dir(void ); ++ ++X509_REQ * X509_to_X509_REQ(X509 *x, EVP_PKEY *pkey, const EVP_MD *md); ++X509 * X509_REQ_to_X509(X509_REQ *r, int days,EVP_PKEY *pkey); ++ ++DECLARE_ASN1_FUNCTIONS(X509_ALGOR) ++DECLARE_ASN1_ENCODE_FUNCTIONS(X509_ALGORS, X509_ALGORS, X509_ALGORS) ++DECLARE_ASN1_FUNCTIONS(X509_VAL) ++ ++DECLARE_ASN1_FUNCTIONS(X509_PUBKEY) ++ ++int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey); ++EVP_PKEY * X509_PUBKEY_get(X509_PUBKEY *key); ++int X509_get_pubkey_parameters(EVP_PKEY *pkey, ++ STACK_OF(X509) *chain); ++int i2d_PUBKEY(EVP_PKEY *a,unsigned char **pp); ++EVP_PKEY * d2i_PUBKEY(EVP_PKEY **a,const unsigned char **pp, ++ long length); ++#ifndef OPENSSL_NO_RSA ++int i2d_RSA_PUBKEY(RSA *a,unsigned char **pp); ++RSA * d2i_RSA_PUBKEY(RSA **a,const unsigned char **pp, ++ long length); ++#endif ++#ifndef OPENSSL_NO_DSA ++int i2d_DSA_PUBKEY(DSA *a,unsigned char **pp); ++DSA * d2i_DSA_PUBKEY(DSA **a,const unsigned char **pp, ++ long length); ++#endif ++#ifndef OPENSSL_NO_EC ++int i2d_EC_PUBKEY(EC_KEY *a, unsigned char **pp); ++EC_KEY *d2i_EC_PUBKEY(EC_KEY **a, const unsigned char **pp, ++ long length); ++#endif ++ ++DECLARE_ASN1_FUNCTIONS(X509_SIG) ++DECLARE_ASN1_FUNCTIONS(X509_REQ_INFO) ++DECLARE_ASN1_FUNCTIONS(X509_REQ) ++ ++DECLARE_ASN1_FUNCTIONS(X509_ATTRIBUTE) ++X509_ATTRIBUTE *X509_ATTRIBUTE_create(int nid, int atrtype, void *value); ++ ++DECLARE_ASN1_FUNCTIONS(X509_EXTENSION) ++DECLARE_ASN1_ENCODE_FUNCTIONS(X509_EXTENSIONS, X509_EXTENSIONS, X509_EXTENSIONS) ++ ++DECLARE_ASN1_FUNCTIONS(X509_NAME_ENTRY) ++ ++DECLARE_ASN1_FUNCTIONS(X509_NAME) ++ ++int X509_NAME_set(X509_NAME **xn, X509_NAME *name); ++ ++DECLARE_ASN1_FUNCTIONS(X509_CINF) ++ ++DECLARE_ASN1_FUNCTIONS(X509) ++DECLARE_ASN1_FUNCTIONS(X509_CERT_AUX) ++ ++DECLARE_ASN1_FUNCTIONS(X509_CERT_PAIR) ++ ++int X509_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, ++ CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func); ++int X509_set_ex_data(X509 *r, int idx, void *arg); ++void *X509_get_ex_data(X509 *r, int idx); ++int i2d_X509_AUX(X509 *a,unsigned char **pp); ++X509 * d2i_X509_AUX(X509 **a,const unsigned char **pp,long length); ++ ++int X509_alias_set1(X509 *x, unsigned char *name, int len); ++int X509_keyid_set1(X509 *x, unsigned char *id, int len); ++unsigned char * X509_alias_get0(X509 *x, int *len); ++unsigned char * X509_keyid_get0(X509 *x, int *len); ++int (*X509_TRUST_set_default(int (*trust)(int , X509 *, int)))(int, X509 *, int); ++int X509_TRUST_set(int *t, int trust); ++int X509_add1_trust_object(X509 *x, ASN1_OBJECT *obj); ++int X509_add1_reject_object(X509 *x, ASN1_OBJECT *obj); ++void X509_trust_clear(X509 *x); ++void X509_reject_clear(X509 *x); ++ ++DECLARE_ASN1_FUNCTIONS(X509_REVOKED) ++DECLARE_ASN1_FUNCTIONS(X509_CRL_INFO) ++DECLARE_ASN1_FUNCTIONS(X509_CRL) ++ ++int X509_CRL_add0_revoked(X509_CRL *crl, X509_REVOKED *rev); ++int X509_CRL_get0_by_serial(X509_CRL *crl, ++ X509_REVOKED **ret, ASN1_INTEGER *serial); ++int X509_CRL_get0_by_cert(X509_CRL *crl, X509_REVOKED **ret, X509 *x); ++ ++X509_PKEY * X509_PKEY_new(void ); ++void X509_PKEY_free(X509_PKEY *a); ++int i2d_X509_PKEY(X509_PKEY *a,unsigned char **pp); ++X509_PKEY * d2i_X509_PKEY(X509_PKEY **a,const unsigned char **pp,long length); ++ ++DECLARE_ASN1_FUNCTIONS(NETSCAPE_SPKI) ++DECLARE_ASN1_FUNCTIONS(NETSCAPE_SPKAC) ++DECLARE_ASN1_FUNCTIONS(NETSCAPE_CERT_SEQUENCE) ++ ++#ifndef OPENSSL_NO_EVP ++X509_INFO * X509_INFO_new(void); ++void X509_INFO_free(X509_INFO *a); ++char * X509_NAME_oneline(X509_NAME *a,char *buf,int size); ++ ++int ASN1_verify(i2d_of_void *i2d, X509_ALGOR *algor1, ++ ASN1_BIT_STRING *signature,char *data,EVP_PKEY *pkey); ++ ++int ASN1_digest(i2d_of_void *i2d,const EVP_MD *type,char *data, ++ unsigned char *md,unsigned int *len); ++ ++int ASN1_sign(i2d_of_void *i2d, X509_ALGOR *algor1, ++ X509_ALGOR *algor2, ASN1_BIT_STRING *signature, ++ char *data,EVP_PKEY *pkey, const EVP_MD *type); ++ ++int ASN1_item_digest(const ASN1_ITEM *it,const EVP_MD *type,void *data, ++ unsigned char *md,unsigned int *len); ++ ++int ASN1_item_verify(const ASN1_ITEM *it, X509_ALGOR *algor1, ++ ASN1_BIT_STRING *signature,void *data,EVP_PKEY *pkey); ++ ++int ASN1_item_sign(const ASN1_ITEM *it, X509_ALGOR *algor1, X509_ALGOR *algor2, ++ ASN1_BIT_STRING *signature, ++ void *data, EVP_PKEY *pkey, const EVP_MD *type); ++#endif ++ ++int X509_set_version(X509 *x,long version); ++int X509_set_serialNumber(X509 *x, ASN1_INTEGER *serial); ++ASN1_INTEGER * X509_get_serialNumber(X509 *x); ++int X509_set_issuer_name(X509 *x, X509_NAME *name); ++X509_NAME * X509_get_issuer_name(X509 *a); ++int X509_set_subject_name(X509 *x, X509_NAME *name); ++X509_NAME * X509_get_subject_name(X509 *a); ++int X509_set_notBefore(X509 *x, const ASN1_TIME *tm); ++int X509_set_notAfter(X509 *x, const ASN1_TIME *tm); ++int X509_set_pubkey(X509 *x, EVP_PKEY *pkey); ++EVP_PKEY * X509_get_pubkey(X509 *x); ++ASN1_BIT_STRING * X509_get0_pubkey_bitstr(const X509 *x); ++int X509_certificate_type(X509 *x,EVP_PKEY *pubkey /* optional */); ++ ++int X509_REQ_set_version(X509_REQ *x,long version); ++int X509_REQ_set_subject_name(X509_REQ *req,X509_NAME *name); ++int X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey); ++EVP_PKEY * X509_REQ_get_pubkey(X509_REQ *req); ++int X509_REQ_extension_nid(int nid); ++int * X509_REQ_get_extension_nids(void); ++void X509_REQ_set_extension_nids(int *nids); ++STACK_OF(X509_EXTENSION) *X509_REQ_get_extensions(X509_REQ *req); ++int X509_REQ_add_extensions_nid(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts, ++ int nid); ++int X509_REQ_add_extensions(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts); ++int X509_REQ_get_attr_count(const X509_REQ *req); ++int X509_REQ_get_attr_by_NID(const X509_REQ *req, int nid, ++ int lastpos); ++int X509_REQ_get_attr_by_OBJ(const X509_REQ *req, ASN1_OBJECT *obj, ++ int lastpos); ++X509_ATTRIBUTE *X509_REQ_get_attr(const X509_REQ *req, int loc); ++X509_ATTRIBUTE *X509_REQ_delete_attr(X509_REQ *req, int loc); ++int X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr); ++int X509_REQ_add1_attr_by_OBJ(X509_REQ *req, ++ const ASN1_OBJECT *obj, int type, ++ const unsigned char *bytes, int len); ++int X509_REQ_add1_attr_by_NID(X509_REQ *req, ++ int nid, int type, ++ const unsigned char *bytes, int len); ++int X509_REQ_add1_attr_by_txt(X509_REQ *req, ++ const char *attrname, int type, ++ const unsigned char *bytes, int len); ++ ++int X509_CRL_set_version(X509_CRL *x, long version); ++int X509_CRL_set_issuer_name(X509_CRL *x, X509_NAME *name); ++int X509_CRL_set_lastUpdate(X509_CRL *x, const ASN1_TIME *tm); ++int X509_CRL_set_nextUpdate(X509_CRL *x, const ASN1_TIME *tm); ++int X509_CRL_sort(X509_CRL *crl); ++ ++int X509_REVOKED_set_serialNumber(X509_REVOKED *x, ASN1_INTEGER *serial); ++int X509_REVOKED_set_revocationDate(X509_REVOKED *r, ASN1_TIME *tm); ++ ++int X509_REQ_check_private_key(X509_REQ *x509,EVP_PKEY *pkey); ++ ++int X509_check_private_key(X509 *x509,EVP_PKEY *pkey); ++ ++int X509_issuer_and_serial_cmp(const X509 *a, const X509 *b); ++unsigned long X509_issuer_and_serial_hash(X509 *a); ++ ++int X509_issuer_name_cmp(const X509 *a, const X509 *b); ++unsigned long X509_issuer_name_hash(X509 *a); ++ ++int X509_subject_name_cmp(const X509 *a, const X509 *b); ++unsigned long X509_subject_name_hash(X509 *x); ++ ++#ifndef OPENSSL_NO_MD5 ++unsigned long X509_issuer_name_hash_old(X509 *a); ++unsigned long X509_subject_name_hash_old(X509 *x); ++#endif ++ ++int X509_cmp(const X509 *a, const X509 *b); ++int X509_NAME_cmp(const X509_NAME *a, const X509_NAME *b); ++unsigned long X509_NAME_hash(X509_NAME *x); ++unsigned long X509_NAME_hash_old(X509_NAME *x); ++ ++int X509_CRL_cmp(const X509_CRL *a, const X509_CRL *b); ++int X509_CRL_match(const X509_CRL *a, const X509_CRL *b); ++#ifndef OPENSSL_NO_FP_API ++int X509_print_ex_fp(FILE *bp,X509 *x, unsigned long nmflag, unsigned long cflag); ++int X509_print_fp(FILE *bp,X509 *x); ++int X509_CRL_print_fp(FILE *bp,X509_CRL *x); ++int X509_REQ_print_fp(FILE *bp,X509_REQ *req); ++int X509_NAME_print_ex_fp(FILE *fp, X509_NAME *nm, int indent, unsigned long flags); ++#endif ++ ++#ifndef OPENSSL_NO_BIO ++int X509_NAME_print(BIO *bp, X509_NAME *name, int obase); ++int X509_NAME_print_ex(BIO *out, X509_NAME *nm, int indent, unsigned long flags); ++int X509_print_ex(BIO *bp,X509 *x, unsigned long nmflag, unsigned long cflag); ++int X509_print(BIO *bp,X509 *x); ++int X509_ocspid_print(BIO *bp,X509 *x); ++int X509_CERT_AUX_print(BIO *bp,X509_CERT_AUX *x, int indent); ++int X509_CRL_print(BIO *bp,X509_CRL *x); ++int X509_REQ_print_ex(BIO *bp, X509_REQ *x, unsigned long nmflag, unsigned long cflag); ++int X509_REQ_print(BIO *bp,X509_REQ *req); ++#endif ++ ++int X509_NAME_entry_count(X509_NAME *name); ++int X509_NAME_get_text_by_NID(X509_NAME *name, int nid, ++ char *buf,int len); ++int X509_NAME_get_text_by_OBJ(X509_NAME *name, ASN1_OBJECT *obj, ++ char *buf,int len); ++ ++/* NOTE: you should be passsing -1, not 0 as lastpos. The functions that use ++ * lastpos, search after that position on. */ ++int X509_NAME_get_index_by_NID(X509_NAME *name,int nid,int lastpos); ++int X509_NAME_get_index_by_OBJ(X509_NAME *name,ASN1_OBJECT *obj, ++ int lastpos); ++X509_NAME_ENTRY *X509_NAME_get_entry(X509_NAME *name, int loc); ++X509_NAME_ENTRY *X509_NAME_delete_entry(X509_NAME *name, int loc); ++int X509_NAME_add_entry(X509_NAME *name,X509_NAME_ENTRY *ne, ++ int loc, int set); ++int X509_NAME_add_entry_by_OBJ(X509_NAME *name, ASN1_OBJECT *obj, int type, ++ unsigned char *bytes, int len, int loc, int set); ++int X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type, ++ unsigned char *bytes, int len, int loc, int set); ++X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY **ne, ++ const char *field, int type, const unsigned char *bytes, int len); ++X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid, ++ int type,unsigned char *bytes, int len); ++int X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type, ++ const unsigned char *bytes, int len, int loc, int set); ++X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY **ne, ++ ASN1_OBJECT *obj, int type,const unsigned char *bytes, ++ int len); ++int X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne, ++ ASN1_OBJECT *obj); ++int X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type, ++ const unsigned char *bytes, int len); ++ASN1_OBJECT * X509_NAME_ENTRY_get_object(X509_NAME_ENTRY *ne); ++ASN1_STRING * X509_NAME_ENTRY_get_data(X509_NAME_ENTRY *ne); ++ ++int X509v3_get_ext_count(const STACK_OF(X509_EXTENSION) *x); ++int X509v3_get_ext_by_NID(const STACK_OF(X509_EXTENSION) *x, ++ int nid, int lastpos); ++int X509v3_get_ext_by_OBJ(const STACK_OF(X509_EXTENSION) *x, ++ ASN1_OBJECT *obj,int lastpos); ++int X509v3_get_ext_by_critical(const STACK_OF(X509_EXTENSION) *x, ++ int crit, int lastpos); ++X509_EXTENSION *X509v3_get_ext(const STACK_OF(X509_EXTENSION) *x, int loc); ++X509_EXTENSION *X509v3_delete_ext(STACK_OF(X509_EXTENSION) *x, int loc); ++STACK_OF(X509_EXTENSION) *X509v3_add_ext(STACK_OF(X509_EXTENSION) **x, ++ X509_EXTENSION *ex, int loc); ++ ++int X509_get_ext_count(X509 *x); ++int X509_get_ext_by_NID(X509 *x, int nid, int lastpos); ++int X509_get_ext_by_OBJ(X509 *x,ASN1_OBJECT *obj,int lastpos); ++int X509_get_ext_by_critical(X509 *x, int crit, int lastpos); ++X509_EXTENSION *X509_get_ext(X509 *x, int loc); ++X509_EXTENSION *X509_delete_ext(X509 *x, int loc); ++int X509_add_ext(X509 *x, X509_EXTENSION *ex, int loc); ++void * X509_get_ext_d2i(X509 *x, int nid, int *crit, int *idx); ++int X509_add1_ext_i2d(X509 *x, int nid, void *value, int crit, ++ unsigned long flags); ++ ++int X509_CRL_get_ext_count(X509_CRL *x); ++int X509_CRL_get_ext_by_NID(X509_CRL *x, int nid, int lastpos); ++int X509_CRL_get_ext_by_OBJ(X509_CRL *x,ASN1_OBJECT *obj,int lastpos); ++int X509_CRL_get_ext_by_critical(X509_CRL *x, int crit, int lastpos); ++X509_EXTENSION *X509_CRL_get_ext(X509_CRL *x, int loc); ++X509_EXTENSION *X509_CRL_delete_ext(X509_CRL *x, int loc); ++int X509_CRL_add_ext(X509_CRL *x, X509_EXTENSION *ex, int loc); ++void * X509_CRL_get_ext_d2i(X509_CRL *x, int nid, int *crit, int *idx); ++int X509_CRL_add1_ext_i2d(X509_CRL *x, int nid, void *value, int crit, ++ unsigned long flags); ++ ++int X509_REVOKED_get_ext_count(X509_REVOKED *x); ++int X509_REVOKED_get_ext_by_NID(X509_REVOKED *x, int nid, int lastpos); ++int X509_REVOKED_get_ext_by_OBJ(X509_REVOKED *x,ASN1_OBJECT *obj,int lastpos); ++int X509_REVOKED_get_ext_by_critical(X509_REVOKED *x, int crit, int lastpos); ++X509_EXTENSION *X509_REVOKED_get_ext(X509_REVOKED *x, int loc); ++X509_EXTENSION *X509_REVOKED_delete_ext(X509_REVOKED *x, int loc); ++int X509_REVOKED_add_ext(X509_REVOKED *x, X509_EXTENSION *ex, int loc); ++void * X509_REVOKED_get_ext_d2i(X509_REVOKED *x, int nid, int *crit, int *idx); ++int X509_REVOKED_add1_ext_i2d(X509_REVOKED *x, int nid, void *value, int crit, ++ unsigned long flags); ++ ++X509_EXTENSION *X509_EXTENSION_create_by_NID(X509_EXTENSION **ex, ++ int nid, int crit, ASN1_OCTET_STRING *data); ++X509_EXTENSION *X509_EXTENSION_create_by_OBJ(X509_EXTENSION **ex, ++ ASN1_OBJECT *obj,int crit,ASN1_OCTET_STRING *data); ++int X509_EXTENSION_set_object(X509_EXTENSION *ex,ASN1_OBJECT *obj); ++int X509_EXTENSION_set_critical(X509_EXTENSION *ex, int crit); ++int X509_EXTENSION_set_data(X509_EXTENSION *ex, ++ ASN1_OCTET_STRING *data); ++ASN1_OBJECT * X509_EXTENSION_get_object(X509_EXTENSION *ex); ++ASN1_OCTET_STRING *X509_EXTENSION_get_data(X509_EXTENSION *ne); ++int X509_EXTENSION_get_critical(X509_EXTENSION *ex); ++ ++int X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x); ++int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid, ++ int lastpos); ++int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk, ASN1_OBJECT *obj, ++ int lastpos); ++X509_ATTRIBUTE *X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc); ++X509_ATTRIBUTE *X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc); ++STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x, ++ X509_ATTRIBUTE *attr); ++STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE) **x, ++ const ASN1_OBJECT *obj, int type, ++ const unsigned char *bytes, int len); ++STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE) **x, ++ int nid, int type, ++ const unsigned char *bytes, int len); ++STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE) **x, ++ const char *attrname, int type, ++ const unsigned char *bytes, int len); ++void *X509at_get0_data_by_OBJ(STACK_OF(X509_ATTRIBUTE) *x, ++ ASN1_OBJECT *obj, int lastpos, int type); ++X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid, ++ int atrtype, const void *data, int len); ++X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr, ++ const ASN1_OBJECT *obj, int atrtype, const void *data, int len); ++X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr, ++ const char *atrname, int type, const unsigned char *bytes, int len); ++int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj); ++int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype, const void *data, int len); ++void *X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx, ++ int atrtype, void *data); ++int X509_ATTRIBUTE_count(X509_ATTRIBUTE *attr); ++ASN1_OBJECT *X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr); ++ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx); ++ ++int EVP_PKEY_get_attr_count(const EVP_PKEY *key); ++int EVP_PKEY_get_attr_by_NID(const EVP_PKEY *key, int nid, ++ int lastpos); ++int EVP_PKEY_get_attr_by_OBJ(const EVP_PKEY *key, ASN1_OBJECT *obj, ++ int lastpos); ++X509_ATTRIBUTE *EVP_PKEY_get_attr(const EVP_PKEY *key, int loc); ++X509_ATTRIBUTE *EVP_PKEY_delete_attr(EVP_PKEY *key, int loc); ++int EVP_PKEY_add1_attr(EVP_PKEY *key, X509_ATTRIBUTE *attr); ++int EVP_PKEY_add1_attr_by_OBJ(EVP_PKEY *key, ++ const ASN1_OBJECT *obj, int type, ++ const unsigned char *bytes, int len); ++int EVP_PKEY_add1_attr_by_NID(EVP_PKEY *key, ++ int nid, int type, ++ const unsigned char *bytes, int len); ++int EVP_PKEY_add1_attr_by_txt(EVP_PKEY *key, ++ const char *attrname, int type, ++ const unsigned char *bytes, int len); ++ ++int X509_verify_cert(X509_STORE_CTX *ctx); ++ ++/* lookup a cert from a X509 STACK */ ++X509 *X509_find_by_issuer_and_serial(STACK_OF(X509) *sk,X509_NAME *name, ++ ASN1_INTEGER *serial); ++X509 *X509_find_by_subject(STACK_OF(X509) *sk,X509_NAME *name); ++ ++DECLARE_ASN1_FUNCTIONS(PBEPARAM) ++DECLARE_ASN1_FUNCTIONS(PBE2PARAM) ++DECLARE_ASN1_FUNCTIONS(PBKDF2PARAM) ++ ++int PKCS5_pbe_set0_algor(X509_ALGOR *algor, int alg, int iter, ++ const unsigned char *salt, int saltlen); ++ ++X509_ALGOR *PKCS5_pbe_set(int alg, int iter, ++ const unsigned char *salt, int saltlen); ++X509_ALGOR *PKCS5_pbe2_set(const EVP_CIPHER *cipher, int iter, ++ unsigned char *salt, int saltlen); ++X509_ALGOR *PKCS5_pbe2_set_iv(const EVP_CIPHER *cipher, int iter, ++ unsigned char *salt, int saltlen, ++ unsigned char *aiv, int prf_nid); ++ ++/* PKCS#8 utilities */ ++ ++DECLARE_ASN1_FUNCTIONS(PKCS8_PRIV_KEY_INFO) ++ ++EVP_PKEY *EVP_PKCS82PKEY(PKCS8_PRIV_KEY_INFO *p8); ++PKCS8_PRIV_KEY_INFO *EVP_PKEY2PKCS8(EVP_PKEY *pkey); ++PKCS8_PRIV_KEY_INFO *EVP_PKEY2PKCS8_broken(EVP_PKEY *pkey, int broken); ++PKCS8_PRIV_KEY_INFO *PKCS8_set_broken(PKCS8_PRIV_KEY_INFO *p8, int broken); ++ ++int PKCS8_pkey_set0(PKCS8_PRIV_KEY_INFO *priv, ASN1_OBJECT *aobj, ++ int version, int ptype, void *pval, ++ unsigned char *penc, int penclen); ++int PKCS8_pkey_get0(ASN1_OBJECT **ppkalg, ++ const unsigned char **pk, int *ppklen, ++ X509_ALGOR **pa, ++ PKCS8_PRIV_KEY_INFO *p8); ++ ++int X509_PUBKEY_set0_param(X509_PUBKEY *pub, ASN1_OBJECT *aobj, ++ int ptype, void *pval, ++ unsigned char *penc, int penclen); ++int X509_PUBKEY_get0_param(ASN1_OBJECT **ppkalg, ++ const unsigned char **pk, int *ppklen, ++ X509_ALGOR **pa, ++ X509_PUBKEY *pub); ++ ++int X509_check_trust(X509 *x, int id, int flags); ++int X509_TRUST_get_count(void); ++X509_TRUST * X509_TRUST_get0(int idx); ++int X509_TRUST_get_by_id(int id); ++int X509_TRUST_add(int id, int flags, int (*ck)(X509_TRUST *, X509 *, int), ++ char *name, int arg1, void *arg2); ++void X509_TRUST_cleanup(void); ++int X509_TRUST_get_flags(X509_TRUST *xp); ++char *X509_TRUST_get0_name(X509_TRUST *xp); ++int X509_TRUST_get_trust(X509_TRUST *xp); ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_X509_strings(void); ++ ++/* Error codes for the X509 functions. */ ++ ++/* Function codes. */ ++#define X509_F_ADD_CERT_DIR 100 ++#define X509_F_BY_FILE_CTRL 101 ++#define X509_F_CHECK_POLICY 145 ++#define X509_F_DIR_CTRL 102 ++#define X509_F_GET_CERT_BY_SUBJECT 103 ++#define X509_F_NETSCAPE_SPKI_B64_DECODE 129 ++#define X509_F_NETSCAPE_SPKI_B64_ENCODE 130 ++#define X509_F_X509AT_ADD1_ATTR 135 ++#define X509_F_X509V3_ADD_EXT 104 ++#define X509_F_X509_ATTRIBUTE_CREATE_BY_NID 136 ++#define X509_F_X509_ATTRIBUTE_CREATE_BY_OBJ 137 ++#define X509_F_X509_ATTRIBUTE_CREATE_BY_TXT 140 ++#define X509_F_X509_ATTRIBUTE_GET0_DATA 139 ++#define X509_F_X509_ATTRIBUTE_SET1_DATA 138 ++#define X509_F_X509_CHECK_PRIVATE_KEY 128 ++#define X509_F_X509_CRL_PRINT_FP 147 ++#define X509_F_X509_EXTENSION_CREATE_BY_NID 108 ++#define X509_F_X509_EXTENSION_CREATE_BY_OBJ 109 ++#define X509_F_X509_GET_PUBKEY_PARAMETERS 110 ++#define X509_F_X509_LOAD_CERT_CRL_FILE 132 ++#define X509_F_X509_LOAD_CERT_FILE 111 ++#define X509_F_X509_LOAD_CRL_FILE 112 ++#define X509_F_X509_NAME_ADD_ENTRY 113 ++#define X509_F_X509_NAME_ENTRY_CREATE_BY_NID 114 ++#define X509_F_X509_NAME_ENTRY_CREATE_BY_TXT 131 ++#define X509_F_X509_NAME_ENTRY_SET_OBJECT 115 ++#define X509_F_X509_NAME_ONELINE 116 ++#define X509_F_X509_NAME_PRINT 117 ++#define X509_F_X509_PRINT_EX_FP 118 ++#define X509_F_X509_PUBKEY_GET 119 ++#define X509_F_X509_PUBKEY_SET 120 ++#define X509_F_X509_REQ_CHECK_PRIVATE_KEY 144 ++#define X509_F_X509_REQ_PRINT_EX 121 ++#define X509_F_X509_REQ_PRINT_FP 122 ++#define X509_F_X509_REQ_TO_X509 123 ++#define X509_F_X509_STORE_ADD_CERT 124 ++#define X509_F_X509_STORE_ADD_CRL 125 ++#define X509_F_X509_STORE_CTX_GET1_ISSUER 146 ++#define X509_F_X509_STORE_CTX_INIT 143 ++#define X509_F_X509_STORE_CTX_NEW 142 ++#define X509_F_X509_STORE_CTX_PURPOSE_INHERIT 134 ++#define X509_F_X509_TO_X509_REQ 126 ++#define X509_F_X509_TRUST_ADD 133 ++#define X509_F_X509_TRUST_SET 141 ++#define X509_F_X509_VERIFY_CERT 127 ++ ++/* Reason codes. */ ++#define X509_R_BAD_X509_FILETYPE 100 ++#define X509_R_BASE64_DECODE_ERROR 118 ++#define X509_R_CANT_CHECK_DH_KEY 114 ++#define X509_R_CERT_ALREADY_IN_HASH_TABLE 101 ++#define X509_R_ERR_ASN1_LIB 102 ++#define X509_R_INVALID_DIRECTORY 113 ++#define X509_R_INVALID_FIELD_NAME 119 ++#define X509_R_INVALID_TRUST 123 ++#define X509_R_KEY_TYPE_MISMATCH 115 ++#define X509_R_KEY_VALUES_MISMATCH 116 ++#define X509_R_LOADING_CERT_DIR 103 ++#define X509_R_LOADING_DEFAULTS 104 ++#define X509_R_METHOD_NOT_SUPPORTED 124 ++#define X509_R_NO_CERT_SET_FOR_US_TO_VERIFY 105 ++#define X509_R_PUBLIC_KEY_DECODE_ERROR 125 ++#define X509_R_PUBLIC_KEY_ENCODE_ERROR 126 ++#define X509_R_SHOULD_RETRY 106 ++#define X509_R_UNABLE_TO_FIND_PARAMETERS_IN_CHAIN 107 ++#define X509_R_UNABLE_TO_GET_CERTS_PUBLIC_KEY 108 ++#define X509_R_UNKNOWN_KEY_TYPE 117 ++#define X509_R_UNKNOWN_NID 109 ++#define X509_R_UNKNOWN_PURPOSE_ID 121 ++#define X509_R_UNKNOWN_TRUST_ID 120 ++#define X509_R_UNSUPPORTED_ALGORITHM 111 ++#define X509_R_WRONG_LOOKUP_TYPE 112 ++#define X509_R_WRONG_TYPE 122 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/openssl/x509_vfy.h qt.patched/include/openssl/x509_vfy.h +--- qt.orig/include/openssl/x509_vfy.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/x509_vfy.h 2010-08-27 12:01:45.821387500 +0200 +@@ -0,0 +1,567 @@ ++/* crypto/x509/x509_vfy.h */ ++/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) ++ * All rights reserved. ++ * ++ * This package is an SSL implementation written ++ * by Eric Young (eay@cryptsoft.com). ++ * The implementation was written so as to conform with Netscapes SSL. ++ * ++ * This library is free for commercial and non-commercial use as long as ++ * the following conditions are aheared to. The following conditions ++ * apply to all code found in this distribution, be it the RC4, RSA, ++ * lhash, DES, etc., code; not just the SSL code. The SSL documentation ++ * included with this distribution is covered by the same copyright terms ++ * except that the holder is Tim Hudson (tjh@cryptsoft.com). ++ * ++ * Copyright remains Eric Young's, and as such any Copyright notices in ++ * the code are not to be removed. ++ * If this package is used in a product, Eric Young should be given attribution ++ * as the author of the parts of the library used. ++ * This can be in the form of a textual message at program startup or ++ * in documentation (online or textual) provided with the package. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 3. All advertising materials mentioning features or use of this software ++ * must display the following acknowledgement: ++ * "This product includes cryptographic software written by ++ * Eric Young (eay@cryptsoft.com)" ++ * The word 'cryptographic' can be left out if the rouines from the library ++ * being used are not cryptographic related :-). ++ * 4. If you include any Windows specific code (or a derivative thereof) from ++ * the apps directory (application code) you must include an acknowledgement: ++ * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ * ++ * The licence and distribution terms for any publically available version or ++ * derivative of this code cannot be changed. i.e. this code cannot simply be ++ * copied and put under another distribution licence ++ * [including the GNU Public Licence.] ++ */ ++ ++#ifndef HEADER_X509_H ++#include ++/* openssl/x509.h ends up #include-ing this file at about the only ++ * appropriate moment. */ ++#endif ++ ++#ifndef HEADER_X509_VFY_H ++#define HEADER_X509_VFY_H ++ ++#include ++#ifndef OPENSSL_NO_LHASH ++#include ++#endif ++#include ++#include ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#if 0 ++/* Outer object */ ++typedef struct x509_hash_dir_st ++ { ++ int num_dirs; ++ char **dirs; ++ int *dirs_type; ++ int num_dirs_alloced; ++ } X509_HASH_DIR_CTX; ++#endif ++ ++typedef struct x509_file_st ++ { ++ int num_paths; /* number of paths to files or directories */ ++ int num_alloced; ++ char **paths; /* the list of paths or directories */ ++ int *path_type; ++ } X509_CERT_FILE_CTX; ++ ++/*******************************/ ++/* ++SSL_CTX -> X509_STORE ++ -> X509_LOOKUP ++ ->X509_LOOKUP_METHOD ++ -> X509_LOOKUP ++ ->X509_LOOKUP_METHOD ++ ++SSL -> X509_STORE_CTX ++ ->X509_STORE ++ ++The X509_STORE holds the tables etc for verification stuff. ++A X509_STORE_CTX is used while validating a single certificate. ++The X509_STORE has X509_LOOKUPs for looking up certs. ++The X509_STORE then calls a function to actually verify the ++certificate chain. ++*/ ++ ++#define X509_LU_RETRY -1 ++#define X509_LU_FAIL 0 ++#define X509_LU_X509 1 ++#define X509_LU_CRL 2 ++#define X509_LU_PKEY 3 ++ ++typedef struct x509_object_st ++ { ++ /* one of the above types */ ++ int type; ++ union { ++ char *ptr; ++ X509 *x509; ++ X509_CRL *crl; ++ EVP_PKEY *pkey; ++ } data; ++ } X509_OBJECT; ++ ++typedef struct x509_lookup_st X509_LOOKUP; ++ ++DECLARE_STACK_OF(X509_LOOKUP) ++DECLARE_STACK_OF(X509_OBJECT) ++ ++/* This is a static that defines the function interface */ ++typedef struct x509_lookup_method_st ++ { ++ const char *name; ++ int (*new_item)(X509_LOOKUP *ctx); ++ void (*free)(X509_LOOKUP *ctx); ++ int (*init)(X509_LOOKUP *ctx); ++ int (*shutdown)(X509_LOOKUP *ctx); ++ int (*ctrl)(X509_LOOKUP *ctx,int cmd,const char *argc,long argl, ++ char **ret); ++ int (*get_by_subject)(X509_LOOKUP *ctx,int type,X509_NAME *name, ++ X509_OBJECT *ret); ++ int (*get_by_issuer_serial)(X509_LOOKUP *ctx,int type,X509_NAME *name, ++ ASN1_INTEGER *serial,X509_OBJECT *ret); ++ int (*get_by_fingerprint)(X509_LOOKUP *ctx,int type, ++ unsigned char *bytes,int len, ++ X509_OBJECT *ret); ++ int (*get_by_alias)(X509_LOOKUP *ctx,int type,char *str,int len, ++ X509_OBJECT *ret); ++ } X509_LOOKUP_METHOD; ++ ++/* This structure hold all parameters associated with a verify operation ++ * by including an X509_VERIFY_PARAM structure in related structures the ++ * parameters used can be customized ++ */ ++ ++typedef struct X509_VERIFY_PARAM_st ++ { ++ char *name; ++ time_t check_time; /* Time to use */ ++ unsigned long inh_flags; /* Inheritance flags */ ++ unsigned long flags; /* Various verify flags */ ++ int purpose; /* purpose to check untrusted certificates */ ++ int trust; /* trust setting to check */ ++ int depth; /* Verify depth */ ++ STACK_OF(ASN1_OBJECT) *policies; /* Permissible policies */ ++ } X509_VERIFY_PARAM; ++ ++DECLARE_STACK_OF(X509_VERIFY_PARAM) ++ ++/* This is used to hold everything. It is used for all certificate ++ * validation. Once we have a certificate chain, the 'verify' ++ * function is then called to actually check the cert chain. */ ++struct x509_store_st ++ { ++ /* The following is a cache of trusted certs */ ++ int cache; /* if true, stash any hits */ ++ STACK_OF(X509_OBJECT) *objs; /* Cache of all objects */ ++ ++ /* These are external lookup methods */ ++ STACK_OF(X509_LOOKUP) *get_cert_methods; ++ ++ X509_VERIFY_PARAM *param; ++ ++ /* Callbacks for various operations */ ++ int (*verify)(X509_STORE_CTX *ctx); /* called to verify a certificate */ ++ int (*verify_cb)(int ok,X509_STORE_CTX *ctx); /* error callback */ ++ int (*get_issuer)(X509 **issuer, X509_STORE_CTX *ctx, X509 *x); /* get issuers cert from ctx */ ++ int (*check_issued)(X509_STORE_CTX *ctx, X509 *x, X509 *issuer); /* check issued */ ++ int (*check_revocation)(X509_STORE_CTX *ctx); /* Check revocation status of chain */ ++ int (*get_crl)(X509_STORE_CTX *ctx, X509_CRL **crl, X509 *x); /* retrieve CRL */ ++ int (*check_crl)(X509_STORE_CTX *ctx, X509_CRL *crl); /* Check CRL validity */ ++ int (*cert_crl)(X509_STORE_CTX *ctx, X509_CRL *crl, X509 *x); /* Check certificate against CRL */ ++ STACK_OF(X509) * (*lookup_certs)(X509_STORE_CTX *ctx, X509_NAME *nm); ++ STACK_OF(X509_CRL) * (*lookup_crls)(X509_STORE_CTX *ctx, X509_NAME *nm); ++ int (*cleanup)(X509_STORE_CTX *ctx); ++ ++ CRYPTO_EX_DATA ex_data; ++ int references; ++ } /* X509_STORE */; ++ ++int X509_STORE_set_depth(X509_STORE *store, int depth); ++ ++#define X509_STORE_set_verify_cb_func(ctx,func) ((ctx)->verify_cb=(func)) ++#define X509_STORE_set_verify_func(ctx,func) ((ctx)->verify=(func)) ++ ++/* This is the functions plus an instance of the local variables. */ ++struct x509_lookup_st ++ { ++ int init; /* have we been started */ ++ int skip; /* don't use us. */ ++ X509_LOOKUP_METHOD *method; /* the functions */ ++ char *method_data; /* method data */ ++ ++ X509_STORE *store_ctx; /* who owns us */ ++ } /* X509_LOOKUP */; ++ ++/* This is a used when verifying cert chains. Since the ++ * gathering of the cert chain can take some time (and have to be ++ * 'retried', this needs to be kept and passed around. */ ++struct x509_store_ctx_st /* X509_STORE_CTX */ ++ { ++ X509_STORE *ctx; ++ int current_method; /* used when looking up certs */ ++ ++ /* The following are set by the caller */ ++ X509 *cert; /* The cert to check */ ++ STACK_OF(X509) *untrusted; /* chain of X509s - untrusted - passed in */ ++ STACK_OF(X509_CRL) *crls; /* set of CRLs passed in */ ++ ++ X509_VERIFY_PARAM *param; ++ void *other_ctx; /* Other info for use with get_issuer() */ ++ ++ /* Callbacks for various operations */ ++ int (*verify)(X509_STORE_CTX *ctx); /* called to verify a certificate */ ++ int (*verify_cb)(int ok,X509_STORE_CTX *ctx); /* error callback */ ++ int (*get_issuer)(X509 **issuer, X509_STORE_CTX *ctx, X509 *x); /* get issuers cert from ctx */ ++ int (*check_issued)(X509_STORE_CTX *ctx, X509 *x, X509 *issuer); /* check issued */ ++ int (*check_revocation)(X509_STORE_CTX *ctx); /* Check revocation status of chain */ ++ int (*get_crl)(X509_STORE_CTX *ctx, X509_CRL **crl, X509 *x); /* retrieve CRL */ ++ int (*check_crl)(X509_STORE_CTX *ctx, X509_CRL *crl); /* Check CRL validity */ ++ int (*cert_crl)(X509_STORE_CTX *ctx, X509_CRL *crl, X509 *x); /* Check certificate against CRL */ ++ int (*check_policy)(X509_STORE_CTX *ctx); ++ STACK_OF(X509) * (*lookup_certs)(X509_STORE_CTX *ctx, X509_NAME *nm); ++ STACK_OF(X509_CRL) * (*lookup_crls)(X509_STORE_CTX *ctx, X509_NAME *nm); ++ int (*cleanup)(X509_STORE_CTX *ctx); ++ ++ /* The following is built up */ ++ int valid; /* if 0, rebuild chain */ ++ int last_untrusted; /* index of last untrusted cert */ ++ STACK_OF(X509) *chain; /* chain of X509s - built up and trusted */ ++ X509_POLICY_TREE *tree; /* Valid policy tree */ ++ ++ int explicit_policy; /* Require explicit policy value */ ++ ++ /* When something goes wrong, this is why */ ++ int error_depth; ++ int error; ++ X509 *current_cert; ++ X509 *current_issuer; /* cert currently being tested as valid issuer */ ++ X509_CRL *current_crl; /* current CRL */ ++ ++ int current_crl_score; /* score of current CRL */ ++ unsigned int current_reasons; /* Reason mask */ ++ ++ X509_STORE_CTX *parent; /* For CRL path validation: parent context */ ++ ++ CRYPTO_EX_DATA ex_data; ++ } /* X509_STORE_CTX */; ++ ++void X509_STORE_CTX_set_depth(X509_STORE_CTX *ctx, int depth); ++ ++#define X509_STORE_CTX_set_app_data(ctx,data) \ ++ X509_STORE_CTX_set_ex_data(ctx,0,data) ++#define X509_STORE_CTX_get_app_data(ctx) \ ++ X509_STORE_CTX_get_ex_data(ctx,0) ++ ++#define X509_L_FILE_LOAD 1 ++#define X509_L_ADD_DIR 2 ++ ++#define X509_LOOKUP_load_file(x,name,type) \ ++ X509_LOOKUP_ctrl((x),X509_L_FILE_LOAD,(name),(long)(type),NULL) ++ ++#define X509_LOOKUP_add_dir(x,name,type) \ ++ X509_LOOKUP_ctrl((x),X509_L_ADD_DIR,(name),(long)(type),NULL) ++ ++#define X509_V_OK 0 ++/* illegal error (for uninitialized values, to avoid X509_V_OK): 1 */ ++ ++#define X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT 2 ++#define X509_V_ERR_UNABLE_TO_GET_CRL 3 ++#define X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE 4 ++#define X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE 5 ++#define X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY 6 ++#define X509_V_ERR_CERT_SIGNATURE_FAILURE 7 ++#define X509_V_ERR_CRL_SIGNATURE_FAILURE 8 ++#define X509_V_ERR_CERT_NOT_YET_VALID 9 ++#define X509_V_ERR_CERT_HAS_EXPIRED 10 ++#define X509_V_ERR_CRL_NOT_YET_VALID 11 ++#define X509_V_ERR_CRL_HAS_EXPIRED 12 ++#define X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD 13 ++#define X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD 14 ++#define X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD 15 ++#define X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD 16 ++#define X509_V_ERR_OUT_OF_MEM 17 ++#define X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT 18 ++#define X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN 19 ++#define X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY 20 ++#define X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE 21 ++#define X509_V_ERR_CERT_CHAIN_TOO_LONG 22 ++#define X509_V_ERR_CERT_REVOKED 23 ++#define X509_V_ERR_INVALID_CA 24 ++#define X509_V_ERR_PATH_LENGTH_EXCEEDED 25 ++#define X509_V_ERR_INVALID_PURPOSE 26 ++#define X509_V_ERR_CERT_UNTRUSTED 27 ++#define X509_V_ERR_CERT_REJECTED 28 ++/* These are 'informational' when looking for issuer cert */ ++#define X509_V_ERR_SUBJECT_ISSUER_MISMATCH 29 ++#define X509_V_ERR_AKID_SKID_MISMATCH 30 ++#define X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH 31 ++#define X509_V_ERR_KEYUSAGE_NO_CERTSIGN 32 ++ ++#define X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER 33 ++#define X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION 34 ++#define X509_V_ERR_KEYUSAGE_NO_CRL_SIGN 35 ++#define X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION 36 ++#define X509_V_ERR_INVALID_NON_CA 37 ++#define X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED 38 ++#define X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE 39 ++#define X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED 40 ++ ++#define X509_V_ERR_INVALID_EXTENSION 41 ++#define X509_V_ERR_INVALID_POLICY_EXTENSION 42 ++#define X509_V_ERR_NO_EXPLICIT_POLICY 43 ++#define X509_V_ERR_DIFFERENT_CRL_SCOPE 44 ++#define X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE 45 ++ ++#define X509_V_ERR_UNNESTED_RESOURCE 46 ++ ++#define X509_V_ERR_PERMITTED_VIOLATION 47 ++#define X509_V_ERR_EXCLUDED_VIOLATION 48 ++#define X509_V_ERR_SUBTREE_MINMAX 49 ++#define X509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPE 51 ++#define X509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX 52 ++#define X509_V_ERR_UNSUPPORTED_NAME_SYNTAX 53 ++#define X509_V_ERR_CRL_PATH_VALIDATION_ERROR 54 ++ ++/* The application is not happy */ ++#define X509_V_ERR_APPLICATION_VERIFICATION 50 ++ ++/* Certificate verify flags */ ++ ++/* Send issuer+subject checks to verify_cb */ ++#define X509_V_FLAG_CB_ISSUER_CHECK 0x1 ++/* Use check time instead of current time */ ++#define X509_V_FLAG_USE_CHECK_TIME 0x2 ++/* Lookup CRLs */ ++#define X509_V_FLAG_CRL_CHECK 0x4 ++/* Lookup CRLs for whole chain */ ++#define X509_V_FLAG_CRL_CHECK_ALL 0x8 ++/* Ignore unhandled critical extensions */ ++#define X509_V_FLAG_IGNORE_CRITICAL 0x10 ++/* Disable workarounds for broken certificates */ ++#define X509_V_FLAG_X509_STRICT 0x20 ++/* Enable proxy certificate validation */ ++#define X509_V_FLAG_ALLOW_PROXY_CERTS 0x40 ++/* Enable policy checking */ ++#define X509_V_FLAG_POLICY_CHECK 0x80 ++/* Policy variable require-explicit-policy */ ++#define X509_V_FLAG_EXPLICIT_POLICY 0x100 ++/* Policy variable inhibit-any-policy */ ++#define X509_V_FLAG_INHIBIT_ANY 0x200 ++/* Policy variable inhibit-policy-mapping */ ++#define X509_V_FLAG_INHIBIT_MAP 0x400 ++/* Notify callback that policy is OK */ ++#define X509_V_FLAG_NOTIFY_POLICY 0x800 ++/* Extended CRL features such as indirect CRLs, alternate CRL signing keys */ ++#define X509_V_FLAG_EXTENDED_CRL_SUPPORT 0x1000 ++/* Delta CRL support */ ++#define X509_V_FLAG_USE_DELTAS 0x2000 ++/* Check selfsigned CA signature */ ++#define X509_V_FLAG_CHECK_SS_SIGNATURE 0x4000 ++ ++ ++#define X509_VP_FLAG_DEFAULT 0x1 ++#define X509_VP_FLAG_OVERWRITE 0x2 ++#define X509_VP_FLAG_RESET_FLAGS 0x4 ++#define X509_VP_FLAG_LOCKED 0x8 ++#define X509_VP_FLAG_ONCE 0x10 ++ ++/* Internal use: mask of policy related options */ ++#define X509_V_FLAG_POLICY_MASK (X509_V_FLAG_POLICY_CHECK \ ++ | X509_V_FLAG_EXPLICIT_POLICY \ ++ | X509_V_FLAG_INHIBIT_ANY \ ++ | X509_V_FLAG_INHIBIT_MAP) ++ ++int X509_OBJECT_idx_by_subject(STACK_OF(X509_OBJECT) *h, int type, ++ X509_NAME *name); ++X509_OBJECT *X509_OBJECT_retrieve_by_subject(STACK_OF(X509_OBJECT) *h,int type,X509_NAME *name); ++X509_OBJECT *X509_OBJECT_retrieve_match(STACK_OF(X509_OBJECT) *h, X509_OBJECT *x); ++void X509_OBJECT_up_ref_count(X509_OBJECT *a); ++void X509_OBJECT_free_contents(X509_OBJECT *a); ++X509_STORE *X509_STORE_new(void ); ++void X509_STORE_free(X509_STORE *v); ++ ++STACK_OF(X509)* X509_STORE_get1_certs(X509_STORE_CTX *st, X509_NAME *nm); ++STACK_OF(X509_CRL)* X509_STORE_get1_crls(X509_STORE_CTX *st, X509_NAME *nm); ++int X509_STORE_set_flags(X509_STORE *ctx, unsigned long flags); ++int X509_STORE_set_purpose(X509_STORE *ctx, int purpose); ++int X509_STORE_set_trust(X509_STORE *ctx, int trust); ++int X509_STORE_set1_param(X509_STORE *ctx, X509_VERIFY_PARAM *pm); ++ ++void X509_STORE_set_verify_cb(X509_STORE *ctx, ++ int (*verify_cb)(int, X509_STORE_CTX *)); ++ ++X509_STORE_CTX *X509_STORE_CTX_new(void); ++ ++int X509_STORE_CTX_get1_issuer(X509 **issuer, X509_STORE_CTX *ctx, X509 *x); ++ ++void X509_STORE_CTX_free(X509_STORE_CTX *ctx); ++int X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, ++ X509 *x509, STACK_OF(X509) *chain); ++void X509_STORE_CTX_trusted_stack(X509_STORE_CTX *ctx, STACK_OF(X509) *sk); ++void X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx); ++ ++X509_LOOKUP *X509_STORE_add_lookup(X509_STORE *v, X509_LOOKUP_METHOD *m); ++ ++X509_LOOKUP_METHOD *X509_LOOKUP_hash_dir(void); ++X509_LOOKUP_METHOD *X509_LOOKUP_file(void); ++ ++int X509_STORE_add_cert(X509_STORE *ctx, X509 *x); ++int X509_STORE_add_crl(X509_STORE *ctx, X509_CRL *x); ++ ++int X509_STORE_get_by_subject(X509_STORE_CTX *vs,int type,X509_NAME *name, ++ X509_OBJECT *ret); ++ ++int X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc, ++ long argl, char **ret); ++ ++#ifndef OPENSSL_NO_STDIO ++int X509_load_cert_file(X509_LOOKUP *ctx, const char *file, int type); ++int X509_load_crl_file(X509_LOOKUP *ctx, const char *file, int type); ++int X509_load_cert_crl_file(X509_LOOKUP *ctx, const char *file, int type); ++#endif ++ ++ ++X509_LOOKUP *X509_LOOKUP_new(X509_LOOKUP_METHOD *method); ++void X509_LOOKUP_free(X509_LOOKUP *ctx); ++int X509_LOOKUP_init(X509_LOOKUP *ctx); ++int X509_LOOKUP_by_subject(X509_LOOKUP *ctx, int type, X509_NAME *name, ++ X509_OBJECT *ret); ++int X509_LOOKUP_by_issuer_serial(X509_LOOKUP *ctx, int type, X509_NAME *name, ++ ASN1_INTEGER *serial, X509_OBJECT *ret); ++int X509_LOOKUP_by_fingerprint(X509_LOOKUP *ctx, int type, ++ unsigned char *bytes, int len, X509_OBJECT *ret); ++int X509_LOOKUP_by_alias(X509_LOOKUP *ctx, int type, char *str, ++ int len, X509_OBJECT *ret); ++int X509_LOOKUP_shutdown(X509_LOOKUP *ctx); ++ ++#ifndef OPENSSL_NO_STDIO ++int X509_STORE_load_locations (X509_STORE *ctx, ++ const char *file, const char *dir); ++int X509_STORE_set_default_paths(X509_STORE *ctx); ++#endif ++ ++int X509_STORE_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, ++ CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func); ++int X509_STORE_CTX_set_ex_data(X509_STORE_CTX *ctx,int idx,void *data); ++void * X509_STORE_CTX_get_ex_data(X509_STORE_CTX *ctx,int idx); ++int X509_STORE_CTX_get_error(X509_STORE_CTX *ctx); ++void X509_STORE_CTX_set_error(X509_STORE_CTX *ctx,int s); ++int X509_STORE_CTX_get_error_depth(X509_STORE_CTX *ctx); ++X509 * X509_STORE_CTX_get_current_cert(X509_STORE_CTX *ctx); ++X509 *X509_STORE_CTX_get0_current_issuer(X509_STORE_CTX *ctx); ++X509_CRL *X509_STORE_CTX_get0_current_crl(X509_STORE_CTX *ctx); ++X509_STORE_CTX *X509_STORE_CTX_get0_parent_ctx(X509_STORE_CTX *ctx); ++STACK_OF(X509) *X509_STORE_CTX_get_chain(X509_STORE_CTX *ctx); ++STACK_OF(X509) *X509_STORE_CTX_get1_chain(X509_STORE_CTX *ctx); ++void X509_STORE_CTX_set_cert(X509_STORE_CTX *c,X509 *x); ++void X509_STORE_CTX_set_chain(X509_STORE_CTX *c,STACK_OF(X509) *sk); ++void X509_STORE_CTX_set0_crls(X509_STORE_CTX *c,STACK_OF(X509_CRL) *sk); ++int X509_STORE_CTX_set_purpose(X509_STORE_CTX *ctx, int purpose); ++int X509_STORE_CTX_set_trust(X509_STORE_CTX *ctx, int trust); ++int X509_STORE_CTX_purpose_inherit(X509_STORE_CTX *ctx, int def_purpose, ++ int purpose, int trust); ++void X509_STORE_CTX_set_flags(X509_STORE_CTX *ctx, unsigned long flags); ++void X509_STORE_CTX_set_time(X509_STORE_CTX *ctx, unsigned long flags, ++ time_t t); ++void X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx, ++ int (*verify_cb)(int, X509_STORE_CTX *)); ++ ++X509_POLICY_TREE *X509_STORE_CTX_get0_policy_tree(X509_STORE_CTX *ctx); ++int X509_STORE_CTX_get_explicit_policy(X509_STORE_CTX *ctx); ++ ++X509_VERIFY_PARAM *X509_STORE_CTX_get0_param(X509_STORE_CTX *ctx); ++void X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param); ++int X509_STORE_CTX_set_default(X509_STORE_CTX *ctx, const char *name); ++ ++/* X509_VERIFY_PARAM functions */ ++ ++X509_VERIFY_PARAM *X509_VERIFY_PARAM_new(void); ++void X509_VERIFY_PARAM_free(X509_VERIFY_PARAM *param); ++int X509_VERIFY_PARAM_inherit(X509_VERIFY_PARAM *to, ++ const X509_VERIFY_PARAM *from); ++int X509_VERIFY_PARAM_set1(X509_VERIFY_PARAM *to, ++ const X509_VERIFY_PARAM *from); ++int X509_VERIFY_PARAM_set1_name(X509_VERIFY_PARAM *param, const char *name); ++int X509_VERIFY_PARAM_set_flags(X509_VERIFY_PARAM *param, unsigned long flags); ++int X509_VERIFY_PARAM_clear_flags(X509_VERIFY_PARAM *param, ++ unsigned long flags); ++unsigned long X509_VERIFY_PARAM_get_flags(X509_VERIFY_PARAM *param); ++int X509_VERIFY_PARAM_set_purpose(X509_VERIFY_PARAM *param, int purpose); ++int X509_VERIFY_PARAM_set_trust(X509_VERIFY_PARAM *param, int trust); ++void X509_VERIFY_PARAM_set_depth(X509_VERIFY_PARAM *param, int depth); ++void X509_VERIFY_PARAM_set_time(X509_VERIFY_PARAM *param, time_t t); ++int X509_VERIFY_PARAM_add0_policy(X509_VERIFY_PARAM *param, ++ ASN1_OBJECT *policy); ++int X509_VERIFY_PARAM_set1_policies(X509_VERIFY_PARAM *param, ++ STACK_OF(ASN1_OBJECT) *policies); ++int X509_VERIFY_PARAM_get_depth(const X509_VERIFY_PARAM *param); ++ ++int X509_VERIFY_PARAM_add0_table(X509_VERIFY_PARAM *param); ++const X509_VERIFY_PARAM *X509_VERIFY_PARAM_lookup(const char *name); ++void X509_VERIFY_PARAM_table_cleanup(void); ++ ++int X509_policy_check(X509_POLICY_TREE **ptree, int *pexplicit_policy, ++ STACK_OF(X509) *certs, ++ STACK_OF(ASN1_OBJECT) *policy_oids, ++ unsigned int flags); ++ ++void X509_policy_tree_free(X509_POLICY_TREE *tree); ++ ++int X509_policy_tree_level_count(const X509_POLICY_TREE *tree); ++X509_POLICY_LEVEL * ++ X509_policy_tree_get0_level(const X509_POLICY_TREE *tree, int i); ++ ++STACK_OF(X509_POLICY_NODE) * ++ X509_policy_tree_get0_policies(const X509_POLICY_TREE *tree); ++ ++STACK_OF(X509_POLICY_NODE) * ++ X509_policy_tree_get0_user_policies(const X509_POLICY_TREE *tree); ++ ++int X509_policy_level_node_count(X509_POLICY_LEVEL *level); ++ ++X509_POLICY_NODE *X509_policy_level_get0_node(X509_POLICY_LEVEL *level, int i); ++ ++const ASN1_OBJECT *X509_policy_node_get0_policy(const X509_POLICY_NODE *node); ++ ++STACK_OF(POLICYQUALINFO) * ++ X509_policy_node_get0_qualifiers(const X509_POLICY_NODE *node); ++const X509_POLICY_NODE * ++ X509_policy_node_get0_parent(const X509_POLICY_NODE *node); ++ ++#ifdef __cplusplus ++} ++#endif ++#endif ++ +diff -urN qt.orig/include/openssl/x509v3.h qt.patched/include/openssl/x509v3.h +--- qt.orig/include/openssl/x509v3.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/openssl/x509v3.h 2010-08-27 12:01:45.837011900 +0200 +@@ -0,0 +1,1007 @@ ++/* x509v3.h */ ++/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL ++ * project 1999. ++ */ ++/* ==================================================================== ++ * Copyright (c) 1999-2004 The OpenSSL Project. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * 3. All advertising materials mentioning features or use of this ++ * software must display the following acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" ++ * ++ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to ++ * endorse or promote products derived from this software without ++ * prior written permission. For written permission, please contact ++ * licensing@OpenSSL.org. ++ * ++ * 5. Products derived from this software may not be called "OpenSSL" ++ * nor may "OpenSSL" appear in their names without prior written ++ * permission of the OpenSSL Project. ++ * ++ * 6. Redistributions of any form whatsoever must retain the following ++ * acknowledgment: ++ * "This product includes software developed by the OpenSSL Project ++ * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY ++ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ++ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ++ * OF THE POSSIBILITY OF SUCH DAMAGE. ++ * ==================================================================== ++ * ++ * This product includes cryptographic software written by Eric Young ++ * (eay@cryptsoft.com). This product includes software written by Tim ++ * Hudson (tjh@cryptsoft.com). ++ * ++ */ ++#ifndef HEADER_X509V3_H ++#define HEADER_X509V3_H ++ ++#include ++#include ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* Forward reference */ ++struct v3_ext_method; ++struct v3_ext_ctx; ++ ++/* Useful typedefs */ ++ ++typedef void * (*X509V3_EXT_NEW)(void); ++typedef void (*X509V3_EXT_FREE)(void *); ++typedef void * (*X509V3_EXT_D2I)(void *, const unsigned char ** , long); ++typedef int (*X509V3_EXT_I2D)(void *, unsigned char **); ++typedef STACK_OF(CONF_VALUE) * ++ (*X509V3_EXT_I2V)(const struct v3_ext_method *method, void *ext, ++ STACK_OF(CONF_VALUE) *extlist); ++typedef void * (*X509V3_EXT_V2I)(const struct v3_ext_method *method, ++ struct v3_ext_ctx *ctx, ++ STACK_OF(CONF_VALUE) *values); ++typedef char * (*X509V3_EXT_I2S)(const struct v3_ext_method *method, void *ext); ++typedef void * (*X509V3_EXT_S2I)(const struct v3_ext_method *method, ++ struct v3_ext_ctx *ctx, const char *str); ++typedef int (*X509V3_EXT_I2R)(const struct v3_ext_method *method, void *ext, ++ BIO *out, int indent); ++typedef void * (*X509V3_EXT_R2I)(const struct v3_ext_method *method, ++ struct v3_ext_ctx *ctx, const char *str); ++ ++/* V3 extension structure */ ++ ++struct v3_ext_method { ++int ext_nid; ++int ext_flags; ++/* If this is set the following four fields are ignored */ ++ASN1_ITEM_EXP *it; ++/* Old style ASN1 calls */ ++X509V3_EXT_NEW ext_new; ++X509V3_EXT_FREE ext_free; ++X509V3_EXT_D2I d2i; ++X509V3_EXT_I2D i2d; ++ ++/* The following pair is used for string extensions */ ++X509V3_EXT_I2S i2s; ++X509V3_EXT_S2I s2i; ++ ++/* The following pair is used for multi-valued extensions */ ++X509V3_EXT_I2V i2v; ++X509V3_EXT_V2I v2i; ++ ++/* The following are used for raw extensions */ ++X509V3_EXT_I2R i2r; ++X509V3_EXT_R2I r2i; ++ ++void *usr_data; /* Any extension specific data */ ++}; ++ ++typedef struct X509V3_CONF_METHOD_st { ++char * (*get_string)(void *db, char *section, char *value); ++STACK_OF(CONF_VALUE) * (*get_section)(void *db, char *section); ++void (*free_string)(void *db, char * string); ++void (*free_section)(void *db, STACK_OF(CONF_VALUE) *section); ++} X509V3_CONF_METHOD; ++ ++/* Context specific info */ ++struct v3_ext_ctx { ++#define CTX_TEST 0x1 ++int flags; ++X509 *issuer_cert; ++X509 *subject_cert; ++X509_REQ *subject_req; ++X509_CRL *crl; ++X509V3_CONF_METHOD *db_meth; ++void *db; ++/* Maybe more here */ ++}; ++ ++typedef struct v3_ext_method X509V3_EXT_METHOD; ++ ++DECLARE_STACK_OF(X509V3_EXT_METHOD) ++ ++/* ext_flags values */ ++#define X509V3_EXT_DYNAMIC 0x1 ++#define X509V3_EXT_CTX_DEP 0x2 ++#define X509V3_EXT_MULTILINE 0x4 ++ ++typedef BIT_STRING_BITNAME ENUMERATED_NAMES; ++ ++typedef struct BASIC_CONSTRAINTS_st { ++int ca; ++ASN1_INTEGER *pathlen; ++} BASIC_CONSTRAINTS; ++ ++ ++typedef struct PKEY_USAGE_PERIOD_st { ++ASN1_GENERALIZEDTIME *notBefore; ++ASN1_GENERALIZEDTIME *notAfter; ++} PKEY_USAGE_PERIOD; ++ ++typedef struct otherName_st { ++ASN1_OBJECT *type_id; ++ASN1_TYPE *value; ++} OTHERNAME; ++ ++typedef struct EDIPartyName_st { ++ ASN1_STRING *nameAssigner; ++ ASN1_STRING *partyName; ++} EDIPARTYNAME; ++ ++typedef struct GENERAL_NAME_st { ++ ++#define GEN_OTHERNAME 0 ++#define GEN_EMAIL 1 ++#define GEN_DNS 2 ++#define GEN_X400 3 ++#define GEN_DIRNAME 4 ++#define GEN_EDIPARTY 5 ++#define GEN_URI 6 ++#define GEN_IPADD 7 ++#define GEN_RID 8 ++ ++int type; ++union { ++ char *ptr; ++ OTHERNAME *otherName; /* otherName */ ++ ASN1_IA5STRING *rfc822Name; ++ ASN1_IA5STRING *dNSName; ++ ASN1_TYPE *x400Address; ++ X509_NAME *directoryName; ++ EDIPARTYNAME *ediPartyName; ++ ASN1_IA5STRING *uniformResourceIdentifier; ++ ASN1_OCTET_STRING *iPAddress; ++ ASN1_OBJECT *registeredID; ++ ++ /* Old names */ ++ ASN1_OCTET_STRING *ip; /* iPAddress */ ++ X509_NAME *dirn; /* dirn */ ++ ASN1_IA5STRING *ia5;/* rfc822Name, dNSName, uniformResourceIdentifier */ ++ ASN1_OBJECT *rid; /* registeredID */ ++ ASN1_TYPE *other; /* x400Address */ ++} d; ++} GENERAL_NAME; ++ ++typedef STACK_OF(GENERAL_NAME) GENERAL_NAMES; ++ ++typedef struct ACCESS_DESCRIPTION_st { ++ ASN1_OBJECT *method; ++ GENERAL_NAME *location; ++} ACCESS_DESCRIPTION; ++ ++typedef STACK_OF(ACCESS_DESCRIPTION) AUTHORITY_INFO_ACCESS; ++ ++typedef STACK_OF(ASN1_OBJECT) EXTENDED_KEY_USAGE; ++ ++DECLARE_STACK_OF(GENERAL_NAME) ++DECLARE_ASN1_SET_OF(GENERAL_NAME) ++ ++DECLARE_STACK_OF(ACCESS_DESCRIPTION) ++DECLARE_ASN1_SET_OF(ACCESS_DESCRIPTION) ++ ++typedef struct DIST_POINT_NAME_st { ++int type; ++union { ++ GENERAL_NAMES *fullname; ++ STACK_OF(X509_NAME_ENTRY) *relativename; ++} name; ++/* If relativename then this contains the full distribution point name */ ++X509_NAME *dpname; ++} DIST_POINT_NAME; ++/* All existing reasons */ ++#define CRLDP_ALL_REASONS 0x807f ++ ++#define CRL_REASON_NONE -1 ++#define CRL_REASON_UNSPECIFIED 0 ++#define CRL_REASON_KEY_COMPROMISE 1 ++#define CRL_REASON_CA_COMPROMISE 2 ++#define CRL_REASON_AFFILIATION_CHANGED 3 ++#define CRL_REASON_SUPERSEDED 4 ++#define CRL_REASON_CESSATION_OF_OPERATION 5 ++#define CRL_REASON_CERTIFICATE_HOLD 6 ++#define CRL_REASON_REMOVE_FROM_CRL 8 ++#define CRL_REASON_PRIVILEGE_WITHDRAWN 9 ++#define CRL_REASON_AA_COMPROMISE 10 ++ ++struct DIST_POINT_st { ++DIST_POINT_NAME *distpoint; ++ASN1_BIT_STRING *reasons; ++GENERAL_NAMES *CRLissuer; ++int dp_reasons; ++}; ++ ++typedef STACK_OF(DIST_POINT) CRL_DIST_POINTS; ++ ++DECLARE_STACK_OF(DIST_POINT) ++DECLARE_ASN1_SET_OF(DIST_POINT) ++ ++struct AUTHORITY_KEYID_st { ++ASN1_OCTET_STRING *keyid; ++GENERAL_NAMES *issuer; ++ASN1_INTEGER *serial; ++}; ++ ++/* Strong extranet structures */ ++ ++typedef struct SXNET_ID_st { ++ ASN1_INTEGER *zone; ++ ASN1_OCTET_STRING *user; ++} SXNETID; ++ ++DECLARE_STACK_OF(SXNETID) ++DECLARE_ASN1_SET_OF(SXNETID) ++ ++typedef struct SXNET_st { ++ ASN1_INTEGER *version; ++ STACK_OF(SXNETID) *ids; ++} SXNET; ++ ++typedef struct NOTICEREF_st { ++ ASN1_STRING *organization; ++ STACK_OF(ASN1_INTEGER) *noticenos; ++} NOTICEREF; ++ ++typedef struct USERNOTICE_st { ++ NOTICEREF *noticeref; ++ ASN1_STRING *exptext; ++} USERNOTICE; ++ ++typedef struct POLICYQUALINFO_st { ++ ASN1_OBJECT *pqualid; ++ union { ++ ASN1_IA5STRING *cpsuri; ++ USERNOTICE *usernotice; ++ ASN1_TYPE *other; ++ } d; ++} POLICYQUALINFO; ++ ++DECLARE_STACK_OF(POLICYQUALINFO) ++DECLARE_ASN1_SET_OF(POLICYQUALINFO) ++ ++typedef struct POLICYINFO_st { ++ ASN1_OBJECT *policyid; ++ STACK_OF(POLICYQUALINFO) *qualifiers; ++} POLICYINFO; ++ ++typedef STACK_OF(POLICYINFO) CERTIFICATEPOLICIES; ++ ++DECLARE_STACK_OF(POLICYINFO) ++DECLARE_ASN1_SET_OF(POLICYINFO) ++ ++typedef struct POLICY_MAPPING_st { ++ ASN1_OBJECT *issuerDomainPolicy; ++ ASN1_OBJECT *subjectDomainPolicy; ++} POLICY_MAPPING; ++ ++DECLARE_STACK_OF(POLICY_MAPPING) ++ ++typedef STACK_OF(POLICY_MAPPING) POLICY_MAPPINGS; ++ ++typedef struct GENERAL_SUBTREE_st { ++ GENERAL_NAME *base; ++ ASN1_INTEGER *minimum; ++ ASN1_INTEGER *maximum; ++} GENERAL_SUBTREE; ++ ++DECLARE_STACK_OF(GENERAL_SUBTREE) ++ ++struct NAME_CONSTRAINTS_st { ++ STACK_OF(GENERAL_SUBTREE) *permittedSubtrees; ++ STACK_OF(GENERAL_SUBTREE) *excludedSubtrees; ++}; ++ ++typedef struct POLICY_CONSTRAINTS_st { ++ ASN1_INTEGER *requireExplicitPolicy; ++ ASN1_INTEGER *inhibitPolicyMapping; ++} POLICY_CONSTRAINTS; ++ ++/* Proxy certificate structures, see RFC 3820 */ ++typedef struct PROXY_POLICY_st ++ { ++ ASN1_OBJECT *policyLanguage; ++ ASN1_OCTET_STRING *policy; ++ } PROXY_POLICY; ++ ++typedef struct PROXY_CERT_INFO_EXTENSION_st ++ { ++ ASN1_INTEGER *pcPathLengthConstraint; ++ PROXY_POLICY *proxyPolicy; ++ } PROXY_CERT_INFO_EXTENSION; ++ ++DECLARE_ASN1_FUNCTIONS(PROXY_POLICY) ++DECLARE_ASN1_FUNCTIONS(PROXY_CERT_INFO_EXTENSION) ++ ++struct ISSUING_DIST_POINT_st ++ { ++ DIST_POINT_NAME *distpoint; ++ int onlyuser; ++ int onlyCA; ++ ASN1_BIT_STRING *onlysomereasons; ++ int indirectCRL; ++ int onlyattr; ++ }; ++ ++/* Values in idp_flags field */ ++/* IDP present */ ++#define IDP_PRESENT 0x1 ++/* IDP values inconsistent */ ++#define IDP_INVALID 0x2 ++/* onlyuser true */ ++#define IDP_ONLYUSER 0x4 ++/* onlyCA true */ ++#define IDP_ONLYCA 0x8 ++/* onlyattr true */ ++#define IDP_ONLYATTR 0x10 ++/* indirectCRL true */ ++#define IDP_INDIRECT 0x20 ++/* onlysomereasons present */ ++#define IDP_REASONS 0x40 ++ ++#define X509V3_conf_err(val) ERR_add_error_data(6, "section:", val->section, \ ++",name:", val->name, ",value:", val->value); ++ ++#define X509V3_set_ctx_test(ctx) \ ++ X509V3_set_ctx(ctx, NULL, NULL, NULL, NULL, CTX_TEST) ++#define X509V3_set_ctx_nodb(ctx) (ctx)->db = NULL; ++ ++#define EXT_BITSTRING(nid, table) { nid, 0, ASN1_ITEM_ref(ASN1_BIT_STRING), \ ++ 0,0,0,0, \ ++ 0,0, \ ++ (X509V3_EXT_I2V)i2v_ASN1_BIT_STRING, \ ++ (X509V3_EXT_V2I)v2i_ASN1_BIT_STRING, \ ++ NULL, NULL, \ ++ table} ++ ++#define EXT_IA5STRING(nid) { nid, 0, ASN1_ITEM_ref(ASN1_IA5STRING), \ ++ 0,0,0,0, \ ++ (X509V3_EXT_I2S)i2s_ASN1_IA5STRING, \ ++ (X509V3_EXT_S2I)s2i_ASN1_IA5STRING, \ ++ 0,0,0,0, \ ++ NULL} ++ ++#define EXT_END { -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} ++ ++ ++/* X509_PURPOSE stuff */ ++ ++#define EXFLAG_BCONS 0x1 ++#define EXFLAG_KUSAGE 0x2 ++#define EXFLAG_XKUSAGE 0x4 ++#define EXFLAG_NSCERT 0x8 ++ ++#define EXFLAG_CA 0x10 ++/* Really self issued not necessarily self signed */ ++#define EXFLAG_SI 0x20 ++#define EXFLAG_SS 0x20 ++#define EXFLAG_V1 0x40 ++#define EXFLAG_INVALID 0x80 ++#define EXFLAG_SET 0x100 ++#define EXFLAG_CRITICAL 0x200 ++#define EXFLAG_PROXY 0x400 ++ ++#define EXFLAG_INVALID_POLICY 0x800 ++#define EXFLAG_FRESHEST 0x1000 ++ ++#define KU_DIGITAL_SIGNATURE 0x0080 ++#define KU_NON_REPUDIATION 0x0040 ++#define KU_KEY_ENCIPHERMENT 0x0020 ++#define KU_DATA_ENCIPHERMENT 0x0010 ++#define KU_KEY_AGREEMENT 0x0008 ++#define KU_KEY_CERT_SIGN 0x0004 ++#define KU_CRL_SIGN 0x0002 ++#define KU_ENCIPHER_ONLY 0x0001 ++#define KU_DECIPHER_ONLY 0x8000 ++ ++#define NS_SSL_CLIENT 0x80 ++#define NS_SSL_SERVER 0x40 ++#define NS_SMIME 0x20 ++#define NS_OBJSIGN 0x10 ++#define NS_SSL_CA 0x04 ++#define NS_SMIME_CA 0x02 ++#define NS_OBJSIGN_CA 0x01 ++#define NS_ANY_CA (NS_SSL_CA|NS_SMIME_CA|NS_OBJSIGN_CA) ++ ++#define XKU_SSL_SERVER 0x1 ++#define XKU_SSL_CLIENT 0x2 ++#define XKU_SMIME 0x4 ++#define XKU_CODE_SIGN 0x8 ++#define XKU_SGC 0x10 ++#define XKU_OCSP_SIGN 0x20 ++#define XKU_TIMESTAMP 0x40 ++#define XKU_DVCS 0x80 ++ ++#define X509_PURPOSE_DYNAMIC 0x1 ++#define X509_PURPOSE_DYNAMIC_NAME 0x2 ++ ++typedef struct x509_purpose_st { ++ int purpose; ++ int trust; /* Default trust ID */ ++ int flags; ++ int (*check_purpose)(const struct x509_purpose_st *, ++ const X509 *, int); ++ char *name; ++ char *sname; ++ void *usr_data; ++} X509_PURPOSE; ++ ++#define X509_PURPOSE_SSL_CLIENT 1 ++#define X509_PURPOSE_SSL_SERVER 2 ++#define X509_PURPOSE_NS_SSL_SERVER 3 ++#define X509_PURPOSE_SMIME_SIGN 4 ++#define X509_PURPOSE_SMIME_ENCRYPT 5 ++#define X509_PURPOSE_CRL_SIGN 6 ++#define X509_PURPOSE_ANY 7 ++#define X509_PURPOSE_OCSP_HELPER 8 ++#define X509_PURPOSE_TIMESTAMP_SIGN 9 ++ ++#define X509_PURPOSE_MIN 1 ++#define X509_PURPOSE_MAX 9 ++ ++/* Flags for X509V3_EXT_print() */ ++ ++#define X509V3_EXT_UNKNOWN_MASK (0xfL << 16) ++/* Return error for unknown extensions */ ++#define X509V3_EXT_DEFAULT 0 ++/* Print error for unknown extensions */ ++#define X509V3_EXT_ERROR_UNKNOWN (1L << 16) ++/* ASN1 parse unknown extensions */ ++#define X509V3_EXT_PARSE_UNKNOWN (2L << 16) ++/* BIO_dump unknown extensions */ ++#define X509V3_EXT_DUMP_UNKNOWN (3L << 16) ++ ++/* Flags for X509V3_add1_i2d */ ++ ++#define X509V3_ADD_OP_MASK 0xfL ++#define X509V3_ADD_DEFAULT 0L ++#define X509V3_ADD_APPEND 1L ++#define X509V3_ADD_REPLACE 2L ++#define X509V3_ADD_REPLACE_EXISTING 3L ++#define X509V3_ADD_KEEP_EXISTING 4L ++#define X509V3_ADD_DELETE 5L ++#define X509V3_ADD_SILENT 0x10 ++ ++DECLARE_STACK_OF(X509_PURPOSE) ++ ++DECLARE_ASN1_FUNCTIONS(BASIC_CONSTRAINTS) ++ ++DECLARE_ASN1_FUNCTIONS(SXNET) ++DECLARE_ASN1_FUNCTIONS(SXNETID) ++ ++int SXNET_add_id_asc(SXNET **psx, char *zone, char *user, int userlen); ++int SXNET_add_id_ulong(SXNET **psx, unsigned long lzone, char *user, int userlen); ++int SXNET_add_id_INTEGER(SXNET **psx, ASN1_INTEGER *izone, char *user, int userlen); ++ ++ASN1_OCTET_STRING *SXNET_get_id_asc(SXNET *sx, char *zone); ++ASN1_OCTET_STRING *SXNET_get_id_ulong(SXNET *sx, unsigned long lzone); ++ASN1_OCTET_STRING *SXNET_get_id_INTEGER(SXNET *sx, ASN1_INTEGER *zone); ++ ++DECLARE_ASN1_FUNCTIONS(AUTHORITY_KEYID) ++ ++DECLARE_ASN1_FUNCTIONS(PKEY_USAGE_PERIOD) ++ ++DECLARE_ASN1_FUNCTIONS(GENERAL_NAME) ++GENERAL_NAME *GENERAL_NAME_dup(GENERAL_NAME *a); ++int GENERAL_NAME_cmp(GENERAL_NAME *a, GENERAL_NAME *b); ++ ++ ++ ++ASN1_BIT_STRING *v2i_ASN1_BIT_STRING(X509V3_EXT_METHOD *method, ++ X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *nval); ++STACK_OF(CONF_VALUE) *i2v_ASN1_BIT_STRING(X509V3_EXT_METHOD *method, ++ ASN1_BIT_STRING *bits, ++ STACK_OF(CONF_VALUE) *extlist); ++ ++STACK_OF(CONF_VALUE) *i2v_GENERAL_NAME(X509V3_EXT_METHOD *method, GENERAL_NAME *gen, STACK_OF(CONF_VALUE) *ret); ++int GENERAL_NAME_print(BIO *out, GENERAL_NAME *gen); ++ ++DECLARE_ASN1_FUNCTIONS(GENERAL_NAMES) ++ ++STACK_OF(CONF_VALUE) *i2v_GENERAL_NAMES(X509V3_EXT_METHOD *method, ++ GENERAL_NAMES *gen, STACK_OF(CONF_VALUE) *extlist); ++GENERAL_NAMES *v2i_GENERAL_NAMES(const X509V3_EXT_METHOD *method, ++ X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *nval); ++ ++DECLARE_ASN1_FUNCTIONS(OTHERNAME) ++DECLARE_ASN1_FUNCTIONS(EDIPARTYNAME) ++int OTHERNAME_cmp(OTHERNAME *a, OTHERNAME *b); ++void GENERAL_NAME_set0_value(GENERAL_NAME *a, int type, void *value); ++void *GENERAL_NAME_get0_value(GENERAL_NAME *a, int *ptype); ++int GENERAL_NAME_set0_othername(GENERAL_NAME *gen, ++ ASN1_OBJECT *oid, ASN1_TYPE *value); ++int GENERAL_NAME_get0_otherName(GENERAL_NAME *gen, ++ ASN1_OBJECT **poid, ASN1_TYPE **pvalue); ++ ++char *i2s_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method, ASN1_OCTET_STRING *ia5); ++ASN1_OCTET_STRING *s2i_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method, X509V3_CTX *ctx, char *str); ++ ++DECLARE_ASN1_FUNCTIONS(EXTENDED_KEY_USAGE) ++int i2a_ACCESS_DESCRIPTION(BIO *bp, ACCESS_DESCRIPTION* a); ++ ++DECLARE_ASN1_FUNCTIONS(CERTIFICATEPOLICIES) ++DECLARE_ASN1_FUNCTIONS(POLICYINFO) ++DECLARE_ASN1_FUNCTIONS(POLICYQUALINFO) ++DECLARE_ASN1_FUNCTIONS(USERNOTICE) ++DECLARE_ASN1_FUNCTIONS(NOTICEREF) ++ ++DECLARE_ASN1_FUNCTIONS(CRL_DIST_POINTS) ++DECLARE_ASN1_FUNCTIONS(DIST_POINT) ++DECLARE_ASN1_FUNCTIONS(DIST_POINT_NAME) ++DECLARE_ASN1_FUNCTIONS(ISSUING_DIST_POINT) ++ ++int DIST_POINT_set_dpname(DIST_POINT_NAME *dpn, X509_NAME *iname); ++ ++int NAME_CONSTRAINTS_check(X509 *x, NAME_CONSTRAINTS *nc); ++ ++DECLARE_ASN1_FUNCTIONS(ACCESS_DESCRIPTION) ++DECLARE_ASN1_FUNCTIONS(AUTHORITY_INFO_ACCESS) ++ ++DECLARE_ASN1_ITEM(POLICY_MAPPING) ++DECLARE_ASN1_ALLOC_FUNCTIONS(POLICY_MAPPING) ++DECLARE_ASN1_ITEM(POLICY_MAPPINGS) ++ ++DECLARE_ASN1_ITEM(GENERAL_SUBTREE) ++DECLARE_ASN1_ALLOC_FUNCTIONS(GENERAL_SUBTREE) ++ ++DECLARE_ASN1_ITEM(NAME_CONSTRAINTS) ++DECLARE_ASN1_ALLOC_FUNCTIONS(NAME_CONSTRAINTS) ++ ++DECLARE_ASN1_ALLOC_FUNCTIONS(POLICY_CONSTRAINTS) ++DECLARE_ASN1_ITEM(POLICY_CONSTRAINTS) ++ ++GENERAL_NAME *a2i_GENERAL_NAME(GENERAL_NAME *out, ++ const X509V3_EXT_METHOD *method, X509V3_CTX *ctx, ++ int gen_type, char *value, int is_nc); ++ ++#ifdef HEADER_CONF_H ++GENERAL_NAME *v2i_GENERAL_NAME(const X509V3_EXT_METHOD *method, X509V3_CTX *ctx, ++ CONF_VALUE *cnf); ++GENERAL_NAME *v2i_GENERAL_NAME_ex(GENERAL_NAME *out, ++ const X509V3_EXT_METHOD *method, ++ X509V3_CTX *ctx, CONF_VALUE *cnf, int is_nc); ++void X509V3_conf_free(CONF_VALUE *val); ++ ++X509_EXTENSION *X509V3_EXT_nconf_nid(CONF *conf, X509V3_CTX *ctx, int ext_nid, char *value); ++X509_EXTENSION *X509V3_EXT_nconf(CONF *conf, X509V3_CTX *ctx, char *name, char *value); ++int X509V3_EXT_add_nconf_sk(CONF *conf, X509V3_CTX *ctx, char *section, STACK_OF(X509_EXTENSION) **sk); ++int X509V3_EXT_add_nconf(CONF *conf, X509V3_CTX *ctx, char *section, X509 *cert); ++int X509V3_EXT_REQ_add_nconf(CONF *conf, X509V3_CTX *ctx, char *section, X509_REQ *req); ++int X509V3_EXT_CRL_add_nconf(CONF *conf, X509V3_CTX *ctx, char *section, X509_CRL *crl); ++ ++X509_EXTENSION *X509V3_EXT_conf_nid(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx, ++ int ext_nid, char *value); ++X509_EXTENSION *X509V3_EXT_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx, ++ char *name, char *value); ++int X509V3_EXT_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx, ++ char *section, X509 *cert); ++int X509V3_EXT_REQ_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx, ++ char *section, X509_REQ *req); ++int X509V3_EXT_CRL_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx, ++ char *section, X509_CRL *crl); ++ ++int X509V3_add_value_bool_nf(char *name, int asn1_bool, ++ STACK_OF(CONF_VALUE) **extlist); ++int X509V3_get_value_bool(CONF_VALUE *value, int *asn1_bool); ++int X509V3_get_value_int(CONF_VALUE *value, ASN1_INTEGER **aint); ++void X509V3_set_nconf(X509V3_CTX *ctx, CONF *conf); ++void X509V3_set_conf_lhash(X509V3_CTX *ctx, LHASH_OF(CONF_VALUE) *lhash); ++#endif ++ ++char * X509V3_get_string(X509V3_CTX *ctx, char *name, char *section); ++STACK_OF(CONF_VALUE) * X509V3_get_section(X509V3_CTX *ctx, char *section); ++void X509V3_string_free(X509V3_CTX *ctx, char *str); ++void X509V3_section_free( X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *section); ++void X509V3_set_ctx(X509V3_CTX *ctx, X509 *issuer, X509 *subject, ++ X509_REQ *req, X509_CRL *crl, int flags); ++ ++int X509V3_add_value(const char *name, const char *value, ++ STACK_OF(CONF_VALUE) **extlist); ++int X509V3_add_value_uchar(const char *name, const unsigned char *value, ++ STACK_OF(CONF_VALUE) **extlist); ++int X509V3_add_value_bool(const char *name, int asn1_bool, ++ STACK_OF(CONF_VALUE) **extlist); ++int X509V3_add_value_int(const char *name, ASN1_INTEGER *aint, ++ STACK_OF(CONF_VALUE) **extlist); ++char * i2s_ASN1_INTEGER(X509V3_EXT_METHOD *meth, ASN1_INTEGER *aint); ++ASN1_INTEGER * s2i_ASN1_INTEGER(X509V3_EXT_METHOD *meth, char *value); ++char * i2s_ASN1_ENUMERATED(X509V3_EXT_METHOD *meth, ASN1_ENUMERATED *aint); ++char * i2s_ASN1_ENUMERATED_TABLE(X509V3_EXT_METHOD *meth, ASN1_ENUMERATED *aint); ++int X509V3_EXT_add(X509V3_EXT_METHOD *ext); ++int X509V3_EXT_add_list(X509V3_EXT_METHOD *extlist); ++int X509V3_EXT_add_alias(int nid_to, int nid_from); ++void X509V3_EXT_cleanup(void); ++ ++const X509V3_EXT_METHOD *X509V3_EXT_get(X509_EXTENSION *ext); ++const X509V3_EXT_METHOD *X509V3_EXT_get_nid(int nid); ++int X509V3_add_standard_extensions(void); ++STACK_OF(CONF_VALUE) *X509V3_parse_list(const char *line); ++void *X509V3_EXT_d2i(X509_EXTENSION *ext); ++void *X509V3_get_d2i(STACK_OF(X509_EXTENSION) *x, int nid, int *crit, int *idx); ++ ++ ++X509_EXTENSION *X509V3_EXT_i2d(int ext_nid, int crit, void *ext_struc); ++int X509V3_add1_i2d(STACK_OF(X509_EXTENSION) **x, int nid, void *value, int crit, unsigned long flags); ++ ++char *hex_to_string(const unsigned char *buffer, long len); ++unsigned char *string_to_hex(const char *str, long *len); ++int name_cmp(const char *name, const char *cmp); ++ ++void X509V3_EXT_val_prn(BIO *out, STACK_OF(CONF_VALUE) *val, int indent, ++ int ml); ++int X509V3_EXT_print(BIO *out, X509_EXTENSION *ext, unsigned long flag, int indent); ++int X509V3_EXT_print_fp(FILE *out, X509_EXTENSION *ext, int flag, int indent); ++ ++int X509V3_extensions_print(BIO *out, char *title, STACK_OF(X509_EXTENSION) *exts, unsigned long flag, int indent); ++ ++int X509_check_ca(X509 *x); ++int X509_check_purpose(X509 *x, int id, int ca); ++int X509_supported_extension(X509_EXTENSION *ex); ++int X509_PURPOSE_set(int *p, int purpose); ++int X509_check_issued(X509 *issuer, X509 *subject); ++int X509_check_akid(X509 *issuer, AUTHORITY_KEYID *akid); ++int X509_PURPOSE_get_count(void); ++X509_PURPOSE * X509_PURPOSE_get0(int idx); ++int X509_PURPOSE_get_by_sname(char *sname); ++int X509_PURPOSE_get_by_id(int id); ++int X509_PURPOSE_add(int id, int trust, int flags, ++ int (*ck)(const X509_PURPOSE *, const X509 *, int), ++ char *name, char *sname, void *arg); ++char *X509_PURPOSE_get0_name(X509_PURPOSE *xp); ++char *X509_PURPOSE_get0_sname(X509_PURPOSE *xp); ++int X509_PURPOSE_get_trust(X509_PURPOSE *xp); ++void X509_PURPOSE_cleanup(void); ++int X509_PURPOSE_get_id(X509_PURPOSE *); ++ ++STACK_OF(OPENSSL_STRING) *X509_get1_email(X509 *x); ++STACK_OF(OPENSSL_STRING) *X509_REQ_get1_email(X509_REQ *x); ++void X509_email_free(STACK_OF(OPENSSL_STRING) *sk); ++STACK_OF(OPENSSL_STRING) *X509_get1_ocsp(X509 *x); ++ ++ASN1_OCTET_STRING *a2i_IPADDRESS(const char *ipasc); ++ASN1_OCTET_STRING *a2i_IPADDRESS_NC(const char *ipasc); ++int a2i_ipadd(unsigned char *ipout, const char *ipasc); ++int X509V3_NAME_from_section(X509_NAME *nm, STACK_OF(CONF_VALUE)*dn_sk, ++ unsigned long chtype); ++ ++void X509_POLICY_NODE_print(BIO *out, X509_POLICY_NODE *node, int indent); ++DECLARE_STACK_OF(X509_POLICY_NODE) ++ ++#ifndef OPENSSL_NO_RFC3779 ++ ++typedef struct ASRange_st { ++ ASN1_INTEGER *min, *max; ++} ASRange; ++ ++#define ASIdOrRange_id 0 ++#define ASIdOrRange_range 1 ++ ++typedef struct ASIdOrRange_st { ++ int type; ++ union { ++ ASN1_INTEGER *id; ++ ASRange *range; ++ } u; ++} ASIdOrRange; ++ ++typedef STACK_OF(ASIdOrRange) ASIdOrRanges; ++DECLARE_STACK_OF(ASIdOrRange) ++ ++#define ASIdentifierChoice_inherit 0 ++#define ASIdentifierChoice_asIdsOrRanges 1 ++ ++typedef struct ASIdentifierChoice_st { ++ int type; ++ union { ++ ASN1_NULL *inherit; ++ ASIdOrRanges *asIdsOrRanges; ++ } u; ++} ASIdentifierChoice; ++ ++typedef struct ASIdentifiers_st { ++ ASIdentifierChoice *asnum, *rdi; ++} ASIdentifiers; ++ ++DECLARE_ASN1_FUNCTIONS(ASRange) ++DECLARE_ASN1_FUNCTIONS(ASIdOrRange) ++DECLARE_ASN1_FUNCTIONS(ASIdentifierChoice) ++DECLARE_ASN1_FUNCTIONS(ASIdentifiers) ++ ++ ++typedef struct IPAddressRange_st { ++ ASN1_BIT_STRING *min, *max; ++} IPAddressRange; ++ ++#define IPAddressOrRange_addressPrefix 0 ++#define IPAddressOrRange_addressRange 1 ++ ++typedef struct IPAddressOrRange_st { ++ int type; ++ union { ++ ASN1_BIT_STRING *addressPrefix; ++ IPAddressRange *addressRange; ++ } u; ++} IPAddressOrRange; ++ ++typedef STACK_OF(IPAddressOrRange) IPAddressOrRanges; ++DECLARE_STACK_OF(IPAddressOrRange) ++ ++#define IPAddressChoice_inherit 0 ++#define IPAddressChoice_addressesOrRanges 1 ++ ++typedef struct IPAddressChoice_st { ++ int type; ++ union { ++ ASN1_NULL *inherit; ++ IPAddressOrRanges *addressesOrRanges; ++ } u; ++} IPAddressChoice; ++ ++typedef struct IPAddressFamily_st { ++ ASN1_OCTET_STRING *addressFamily; ++ IPAddressChoice *ipAddressChoice; ++} IPAddressFamily; ++ ++typedef STACK_OF(IPAddressFamily) IPAddrBlocks; ++DECLARE_STACK_OF(IPAddressFamily) ++ ++DECLARE_ASN1_FUNCTIONS(IPAddressRange) ++DECLARE_ASN1_FUNCTIONS(IPAddressOrRange) ++DECLARE_ASN1_FUNCTIONS(IPAddressChoice) ++DECLARE_ASN1_FUNCTIONS(IPAddressFamily) ++ ++/* ++ * API tag for elements of the ASIdentifer SEQUENCE. ++ */ ++#define V3_ASID_ASNUM 0 ++#define V3_ASID_RDI 1 ++ ++/* ++ * AFI values, assigned by IANA. It'd be nice to make the AFI ++ * handling code totally generic, but there are too many little things ++ * that would need to be defined for other address families for it to ++ * be worth the trouble. ++ */ ++#define IANA_AFI_IPV4 1 ++#define IANA_AFI_IPV6 2 ++ ++/* ++ * Utilities to construct and extract values from RFC3779 extensions, ++ * since some of the encodings (particularly for IP address prefixes ++ * and ranges) are a bit tedious to work with directly. ++ */ ++int v3_asid_add_inherit(ASIdentifiers *asid, int which); ++int v3_asid_add_id_or_range(ASIdentifiers *asid, int which, ++ ASN1_INTEGER *min, ASN1_INTEGER *max); ++int v3_addr_add_inherit(IPAddrBlocks *addr, ++ const unsigned afi, const unsigned *safi); ++int v3_addr_add_prefix(IPAddrBlocks *addr, ++ const unsigned afi, const unsigned *safi, ++ unsigned char *a, const int prefixlen); ++int v3_addr_add_range(IPAddrBlocks *addr, ++ const unsigned afi, const unsigned *safi, ++ unsigned char *min, unsigned char *max); ++unsigned v3_addr_get_afi(const IPAddressFamily *f); ++int v3_addr_get_range(IPAddressOrRange *aor, const unsigned afi, ++ unsigned char *min, unsigned char *max, ++ const int length); ++ ++/* ++ * Canonical forms. ++ */ ++int v3_asid_is_canonical(ASIdentifiers *asid); ++int v3_addr_is_canonical(IPAddrBlocks *addr); ++int v3_asid_canonize(ASIdentifiers *asid); ++int v3_addr_canonize(IPAddrBlocks *addr); ++ ++/* ++ * Tests for inheritance and containment. ++ */ ++int v3_asid_inherits(ASIdentifiers *asid); ++int v3_addr_inherits(IPAddrBlocks *addr); ++int v3_asid_subset(ASIdentifiers *a, ASIdentifiers *b); ++int v3_addr_subset(IPAddrBlocks *a, IPAddrBlocks *b); ++ ++/* ++ * Check whether RFC 3779 extensions nest properly in chains. ++ */ ++int v3_asid_validate_path(X509_STORE_CTX *); ++int v3_addr_validate_path(X509_STORE_CTX *); ++int v3_asid_validate_resource_set(STACK_OF(X509) *chain, ++ ASIdentifiers *ext, ++ int allow_inheritance); ++int v3_addr_validate_resource_set(STACK_OF(X509) *chain, ++ IPAddrBlocks *ext, ++ int allow_inheritance); ++ ++#endif /* OPENSSL_NO_RFC3779 */ ++ ++/* BEGIN ERROR CODES */ ++/* The following lines are auto generated by the script mkerr.pl. Any changes ++ * made after this point may be overwritten when the script is next run. ++ */ ++void ERR_load_X509V3_strings(void); ++ ++/* Error codes for the X509V3 functions. */ ++ ++/* Function codes. */ ++#define X509V3_F_A2I_GENERAL_NAME 164 ++#define X509V3_F_ASIDENTIFIERCHOICE_CANONIZE 161 ++#define X509V3_F_ASIDENTIFIERCHOICE_IS_CANONICAL 162 ++#define X509V3_F_COPY_EMAIL 122 ++#define X509V3_F_COPY_ISSUER 123 ++#define X509V3_F_DO_DIRNAME 144 ++#define X509V3_F_DO_EXT_CONF 124 ++#define X509V3_F_DO_EXT_I2D 135 ++#define X509V3_F_DO_EXT_NCONF 151 ++#define X509V3_F_DO_I2V_NAME_CONSTRAINTS 148 ++#define X509V3_F_GNAMES_FROM_SECTNAME 156 ++#define X509V3_F_HEX_TO_STRING 111 ++#define X509V3_F_I2S_ASN1_ENUMERATED 121 ++#define X509V3_F_I2S_ASN1_IA5STRING 149 ++#define X509V3_F_I2S_ASN1_INTEGER 120 ++#define X509V3_F_I2V_AUTHORITY_INFO_ACCESS 138 ++#define X509V3_F_NOTICE_SECTION 132 ++#define X509V3_F_NREF_NOS 133 ++#define X509V3_F_POLICY_SECTION 131 ++#define X509V3_F_PROCESS_PCI_VALUE 150 ++#define X509V3_F_R2I_CERTPOL 130 ++#define X509V3_F_R2I_PCI 155 ++#define X509V3_F_S2I_ASN1_IA5STRING 100 ++#define X509V3_F_S2I_ASN1_INTEGER 108 ++#define X509V3_F_S2I_ASN1_OCTET_STRING 112 ++#define X509V3_F_S2I_ASN1_SKEY_ID 114 ++#define X509V3_F_S2I_SKEY_ID 115 ++#define X509V3_F_SET_DIST_POINT_NAME 158 ++#define X509V3_F_STRING_TO_HEX 113 ++#define X509V3_F_SXNET_ADD_ID_ASC 125 ++#define X509V3_F_SXNET_ADD_ID_INTEGER 126 ++#define X509V3_F_SXNET_ADD_ID_ULONG 127 ++#define X509V3_F_SXNET_GET_ID_ASC 128 ++#define X509V3_F_SXNET_GET_ID_ULONG 129 ++#define X509V3_F_V2I_ASIDENTIFIERS 163 ++#define X509V3_F_V2I_ASN1_BIT_STRING 101 ++#define X509V3_F_V2I_AUTHORITY_INFO_ACCESS 139 ++#define X509V3_F_V2I_AUTHORITY_KEYID 119 ++#define X509V3_F_V2I_BASIC_CONSTRAINTS 102 ++#define X509V3_F_V2I_CRLD 134 ++#define X509V3_F_V2I_EXTENDED_KEY_USAGE 103 ++#define X509V3_F_V2I_GENERAL_NAMES 118 ++#define X509V3_F_V2I_GENERAL_NAME_EX 117 ++#define X509V3_F_V2I_IDP 157 ++#define X509V3_F_V2I_IPADDRBLOCKS 159 ++#define X509V3_F_V2I_ISSUER_ALT 153 ++#define X509V3_F_V2I_NAME_CONSTRAINTS 147 ++#define X509V3_F_V2I_POLICY_CONSTRAINTS 146 ++#define X509V3_F_V2I_POLICY_MAPPINGS 145 ++#define X509V3_F_V2I_SUBJECT_ALT 154 ++#define X509V3_F_V3_ADDR_VALIDATE_PATH_INTERNAL 160 ++#define X509V3_F_V3_GENERIC_EXTENSION 116 ++#define X509V3_F_X509V3_ADD1_I2D 140 ++#define X509V3_F_X509V3_ADD_VALUE 105 ++#define X509V3_F_X509V3_EXT_ADD 104 ++#define X509V3_F_X509V3_EXT_ADD_ALIAS 106 ++#define X509V3_F_X509V3_EXT_CONF 107 ++#define X509V3_F_X509V3_EXT_I2D 136 ++#define X509V3_F_X509V3_EXT_NCONF 152 ++#define X509V3_F_X509V3_GET_SECTION 142 ++#define X509V3_F_X509V3_GET_STRING 143 ++#define X509V3_F_X509V3_GET_VALUE_BOOL 110 ++#define X509V3_F_X509V3_PARSE_LIST 109 ++#define X509V3_F_X509_PURPOSE_ADD 137 ++#define X509V3_F_X509_PURPOSE_SET 141 ++ ++/* Reason codes. */ ++#define X509V3_R_BAD_IP_ADDRESS 118 ++#define X509V3_R_BAD_OBJECT 119 ++#define X509V3_R_BN_DEC2BN_ERROR 100 ++#define X509V3_R_BN_TO_ASN1_INTEGER_ERROR 101 ++#define X509V3_R_DIRNAME_ERROR 149 ++#define X509V3_R_DISTPOINT_ALREADY_SET 160 ++#define X509V3_R_DUPLICATE_ZONE_ID 133 ++#define X509V3_R_ERROR_CONVERTING_ZONE 131 ++#define X509V3_R_ERROR_CREATING_EXTENSION 144 ++#define X509V3_R_ERROR_IN_EXTENSION 128 ++#define X509V3_R_EXPECTED_A_SECTION_NAME 137 ++#define X509V3_R_EXTENSION_EXISTS 145 ++#define X509V3_R_EXTENSION_NAME_ERROR 115 ++#define X509V3_R_EXTENSION_NOT_FOUND 102 ++#define X509V3_R_EXTENSION_SETTING_NOT_SUPPORTED 103 ++#define X509V3_R_EXTENSION_VALUE_ERROR 116 ++#define X509V3_R_ILLEGAL_EMPTY_EXTENSION 151 ++#define X509V3_R_ILLEGAL_HEX_DIGIT 113 ++#define X509V3_R_INCORRECT_POLICY_SYNTAX_TAG 152 ++#define X509V3_R_INVALID_MULTIPLE_RDNS 161 ++#define X509V3_R_INVALID_ASNUMBER 162 ++#define X509V3_R_INVALID_ASRANGE 163 ++#define X509V3_R_INVALID_BOOLEAN_STRING 104 ++#define X509V3_R_INVALID_EXTENSION_STRING 105 ++#define X509V3_R_INVALID_INHERITANCE 165 ++#define X509V3_R_INVALID_IPADDRESS 166 ++#define X509V3_R_INVALID_NAME 106 ++#define X509V3_R_INVALID_NULL_ARGUMENT 107 ++#define X509V3_R_INVALID_NULL_NAME 108 ++#define X509V3_R_INVALID_NULL_VALUE 109 ++#define X509V3_R_INVALID_NUMBER 140 ++#define X509V3_R_INVALID_NUMBERS 141 ++#define X509V3_R_INVALID_OBJECT_IDENTIFIER 110 ++#define X509V3_R_INVALID_OPTION 138 ++#define X509V3_R_INVALID_POLICY_IDENTIFIER 134 ++#define X509V3_R_INVALID_PROXY_POLICY_SETTING 153 ++#define X509V3_R_INVALID_PURPOSE 146 ++#define X509V3_R_INVALID_SAFI 164 ++#define X509V3_R_INVALID_SECTION 135 ++#define X509V3_R_INVALID_SYNTAX 143 ++#define X509V3_R_ISSUER_DECODE_ERROR 126 ++#define X509V3_R_MISSING_VALUE 124 ++#define X509V3_R_NEED_ORGANIZATION_AND_NUMBERS 142 ++#define X509V3_R_NO_CONFIG_DATABASE 136 ++#define X509V3_R_NO_ISSUER_CERTIFICATE 121 ++#define X509V3_R_NO_ISSUER_DETAILS 127 ++#define X509V3_R_NO_POLICY_IDENTIFIER 139 ++#define X509V3_R_NO_PROXY_CERT_POLICY_LANGUAGE_DEFINED 154 ++#define X509V3_R_NO_PUBLIC_KEY 114 ++#define X509V3_R_NO_SUBJECT_DETAILS 125 ++#define X509V3_R_ODD_NUMBER_OF_DIGITS 112 ++#define X509V3_R_OPERATION_NOT_DEFINED 148 ++#define X509V3_R_OTHERNAME_ERROR 147 ++#define X509V3_R_POLICY_LANGUAGE_ALREADY_DEFINED 155 ++#define X509V3_R_POLICY_PATH_LENGTH 156 ++#define X509V3_R_POLICY_PATH_LENGTH_ALREADY_DEFINED 157 ++#define X509V3_R_POLICY_SYNTAX_NOT_CURRENTLY_SUPPORTED 158 ++#define X509V3_R_POLICY_WHEN_PROXY_LANGUAGE_REQUIRES_NO_POLICY 159 ++#define X509V3_R_SECTION_NOT_FOUND 150 ++#define X509V3_R_UNABLE_TO_GET_ISSUER_DETAILS 122 ++#define X509V3_R_UNABLE_TO_GET_ISSUER_KEYID 123 ++#define X509V3_R_UNKNOWN_BIT_STRING_ARGUMENT 111 ++#define X509V3_R_UNKNOWN_EXTENSION 129 ++#define X509V3_R_UNKNOWN_EXTENSION_NAME 130 ++#define X509V3_R_UNKNOWN_OPTION 120 ++#define X509V3_R_UNSUPPORTED_OPTION 117 ++#define X509V3_R_UNSUPPORTED_TYPE 167 ++#define X509V3_R_USER_TOO_LONG 132 ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff -urN qt.orig/include/Qt/private/qopensslhook_p.h qt.patched/include/Qt/private/qopensslhook_p.h +--- qt.orig/include/Qt/private/qopensslhook_p.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/include/Qt/private/qopensslhook_p.h 2010-08-27 12:01:45.883885100 +0200 +@@ -0,0 +1 @@ ++#include "../../../src/network/ssl/qopensslhook_p.h" +diff -urN qt.orig/src/gui/kernel/qapplication.cpp qt.patched/src/gui/kernel/qapplication.cpp +--- qt.orig/src/gui/kernel/qapplication.cpp 2010-08-27 14:33:14.177544600 +0200 ++++ qt.patched/src/gui/kernel/qapplication.cpp 2010-08-27 12:01:44.618308700 +0200 +@@ -138,7 +138,7 @@ + + QT_BEGIN_NAMESPACE + +-Q_DECL_IMPORT extern void qt_call_post_routines(); ++Q_CORE_EXPORT extern void qt_call_post_routines(); + + int QApplicationPrivate::app_compile_version = 0x040000; //we don't know exactly, but it's at least 4.0.0 + +diff -urN qt.orig/src/gui/kernel/qwhatsthis.cpp qt.patched/src/gui/kernel/qwhatsthis.cpp +--- qt.orig/src/gui/kernel/qwhatsthis.cpp 2010-08-27 14:33:14.193169800 +0200 ++++ qt.patched/src/gui/kernel/qwhatsthis.cpp 2010-08-27 12:01:44.649557500 +0200 +@@ -143,7 +143,7 @@ + \sa QToolTip + */ + +-Q_DECL_IMPORT extern void qDeleteInEventHandler(QObject *o); ++Q_CORE_EXPORT extern void qDeleteInEventHandler(QObject *o); + + class QWhatsThat : public QWidget + { +diff -urN qt.orig/src/network/ssl/qopensslhook_p.h qt.patched/src/network/ssl/qopensslhook_p.h +--- qt.orig/src/network/ssl/qopensslhook_p.h 1970-01-01 01:00:00.000000000 +0100 ++++ qt.patched/src/network/ssl/qopensslhook_p.h 2010-08-27 12:01:44.665181900 +0200 +@@ -0,0 +1,16 @@ ++#ifndef QOPENSSLHOOK_P_H ++#define QOPENSSLHOOK_P_H ++#include "qsslsocket_openssl_p.h" ++ ++QT_BEGIN_NAMESPACE ++ ++class QOpenSslHook { ++public: ++ virtual ~QOpenSslHook() {} ++ ++ virtual bool hookInitSslContext(SSL_CTX* ctx)=0; ++}; ++ ++QT_END_NAMESPACE ++ ++#endif // QOPENSSLHOOK_P_H +diff -urN qt.orig/src/network/ssl/qsslconfiguration.cpp qt.patched/src/network/ssl/qsslconfiguration.cpp +--- qt.orig/src/network/ssl/qsslconfiguration.cpp 2010-08-27 14:33:14.240045400 +0200 ++++ qt.patched/src/network/ssl/qsslconfiguration.cpp 2010-08-27 12:01:44.680806300 +0200 +@@ -178,6 +178,7 @@ + d->ciphers == other.d->ciphers && + d->caCertificates == d->caCertificates && + d->protocol == other.d->protocol && ++ d->hook == d->hook && + d->peerVerifyMode == other.d->peerVerifyMode && + d->peerVerifyDepth == other.d->peerVerifyDepth; + } +@@ -542,4 +543,16 @@ + QSslConfigurationPrivate::setDefaultConfiguration(configuration); + } + ++// BEGIN: Added for SwissSurfer ++QOpenSslHook* QSslConfiguration::openSslHook() const ++{ ++ return d ? d->hook : 0; ++} ++void QSslConfiguration::setOpenSslHook(QOpenSslHook* hook) ++{ ++ d->hook=hook; ++} ++// END: Added for SwissSurfer ++ ++ + QT_END_NAMESPACE +diff -urN qt.orig/src/network/ssl/qsslconfiguration.h qt.patched/src/network/ssl/qsslconfiguration.h +--- qt.orig/src/network/ssl/qsslconfiguration.h 2010-08-27 14:33:14.255670600 +0200 ++++ qt.patched/src/network/ssl/qsslconfiguration.h 2010-08-27 12:01:44.696430700 +0200 +@@ -73,6 +73,11 @@ + class QSslCipher; + class QSslKey; + ++// BEGIN: Added for SwissSurfer ++class QOpenSslHook; ++// END: Added for SwissSurfer ++ ++ + class QSslConfigurationPrivate; + class Q_NETWORK_EXPORT QSslConfiguration + { +@@ -121,6 +126,11 @@ + static QSslConfiguration defaultConfiguration(); + static void setDefaultConfiguration(const QSslConfiguration &configuration); + ++ // BEGIN: Added for SwissSurfer ++ QOpenSslHook* openSslHook() const; ++ void setOpenSslHook(QOpenSslHook* hook); ++ // END: Added for SwissSurfer ++ + private: + friend class QSslSocket; + friend class QSslConfigurationPrivate; +diff -urN qt.orig/src/network/ssl/qsslconfiguration_p.h qt.patched/src/network/ssl/qsslconfiguration_p.h +--- qt.orig/src/network/ssl/qsslconfiguration_p.h 2010-08-27 14:33:14.271295800 +0200 ++++ qt.patched/src/network/ssl/qsslconfiguration_p.h 2010-08-27 12:01:44.712055100 +0200 +@@ -81,6 +81,9 @@ + public: + QSslConfigurationPrivate() + : protocol(QSsl::SslV3), ++ // BEGIN: Added for SwissSurfer ++ hook(0), ++ // END: Added for SwissSurfer + peerVerifyMode(QSslSocket::AutoVerifyPeer), + peerVerifyDepth(0) + { } +@@ -95,6 +98,9 @@ + QList caCertificates; + + QSsl::SslProtocol protocol; ++ // BEGIN: Added for SwissSurfer ++ QOpenSslHook* hook; ++ // END: Added for SwissSurfer + QSslSocket::PeerVerifyMode peerVerifyMode; + int peerVerifyDepth; + +diff -urN qt.orig/src/network/ssl/qsslsocket.cpp qt.patched/src/network/ssl/qsslsocket.cpp +--- qt.orig/src/network/ssl/qsslsocket.cpp 2010-08-27 14:33:14.271295800 +0200 ++++ qt.patched/src/network/ssl/qsslsocket.cpp 2010-08-27 12:01:44.727679500 +0200 +@@ -1975,6 +1975,7 @@ + ptr->ciphers = global->ciphers; + ptr->caCertificates = global->caCertificates; + ptr->protocol = global->protocol; ++ ptr->hook = global->hook; + ptr->peerVerifyMode = global->peerVerifyMode; + ptr->peerVerifyDepth = global->peerVerifyDepth; + } +diff -urN qt.orig/src/network/ssl/qsslsocket_openssl.cpp qt.patched/src/network/ssl/qsslsocket_openssl.cpp +--- qt.orig/src/network/ssl/qsslsocket_openssl.cpp 2010-08-27 14:33:14.302546200 +0200 ++++ qt.patched/src/network/ssl/qsslsocket_openssl.cpp 2010-08-27 12:01:44.743303900 +0200 +@@ -46,6 +46,9 @@ + #include "qsslsocket.h" + #include "qsslcertificate_p.h" + #include "qsslcipher_p.h" ++// BEGIN: Added for SwissSurfer ++#include "qopensslhook_p.h" ++// END: Added for SwissSurfer + + #include + #include +@@ -340,7 +343,17 @@ + // Set verification depth. + if (configuration.peerVerifyDepth != 0) + q_SSL_CTX_set_verify_depth(ctx, configuration.peerVerifyDepth); +- ++ ++ // BEGIN: Added for SwissSurfer ++ if(configuration.hook) { ++ if(!configuration.hook->hookInitSslContext(ctx)) { ++ q->setErrorString(QSslSocket::tr("Cannot set extended SSL configuration")); ++ emit q->error(QAbstractSocket::UnknownSocketError); ++ return false; ++ } ++ } ++ // END: Added for SwissSurfer ++ + // Create and initialize SSL session + if (!(ssl = q_SSL_new(ctx))) { + // ### Bad error code +diff -urN qt.orig/src/network/ssl/qsslsocket_openssl_symbols.cpp qt.patched/src/network/ssl/qsslsocket_openssl_symbols.cpp +--- qt.orig/src/network/ssl/qsslsocket_openssl_symbols.cpp 2010-08-27 14:33:14.318171400 +0200 ++++ qt.patched/src/network/ssl/qsslsocket_openssl_symbols.cpp 2010-08-27 14:46:30.368740000 +0200 +@@ -257,6 +257,30 @@ + DEFINEFUNC(void, OPENSSL_add_all_algorithms_noconf, void, DUMMYARG, return, DUMMYARG) + DEFINEFUNC(void, OPENSSL_add_all_algorithms_conf, void, DUMMYARG, return, DUMMYARG) + ++// BEGIN: Added for SwissSurfer ++#ifndef Q_OS_SYMBIAN ++DEFINEFUNC(void, ENGINE_load_dynamic, void, DUMMYARG, return, DUMMYARG) ++DEFINEFUNC(ENGINE*, ENGINE_by_id, const char *id, id, return 0, return) ++DEFINEFUNC4(int, ENGINE_ctrl_cmd_string, ENGINE *e, e, const char *cmd_name, cmd_name, ++ const char *arg, arg, int cmd_optional, cmd_optional, return 0, return) ++DEFINEFUNC6(int, ENGINE_ctrl_cmd, ENGINE *e, e, const char *cmd_name, cmd_name, ++ long i, i, void *p, p, void (*f)(void), f, int cmd_optional, cmd_optional, return 0, return); ++DEFINEFUNC(int, ENGINE_init, ENGINE *e, e, return 0, return) ++DEFINEFUNC(int, ENGINE_finish, ENGINE *e, e, return 0, return) ++DEFINEFUNC(void, ENGINE_cleanup, void, DUMMYARG, return, DUMMYARG) ++DEFINEFUNC4(EVP_PKEY*, ENGINE_load_private_key, ENGINE *e, e, const char *key_id, key_id, ++ UI_METHOD *ui_method, ui_method, void *callback_data, callback_data, return 0, return) ++DEFINEFUNC2(void, SSL_CTX_set_client_cert_cb, SSL_CTX *ctx, ctx, ++ int (*client_cert_cb)(SSL *ssl, X509 **x509, EVP_PKEY **pkey), client_cert_cb, return, DUMMYARG) ++DEFINEFUNC2(BIO*, BIO_new_file, const char *filename, filename, const char *mode, mode, return 0, return) ++DEFINEFUNC4(X509*, PEM_read_bio_X509_AUX, BIO *bp, bp, X509 **x, x, ++ pem_password_cb *cb, cb, void *u, u, return 0, return) ++DEFINEFUNC4(X509*, PEM_read_bio_X509, BIO *bp, bp, X509 **x, x, ++ pem_password_cb *cb, cb, void *u, u, return 0, return) ++ ++#endif ++// END: Added for SwissSurfer ++ + #ifdef Q_OS_SYMBIAN + #define RESOLVEFUNC(func, ordinal, lib) \ + if (!(_q_##func = _q_PTR_##func(lib->resolve(#ordinal)))) \ +@@ -731,6 +755,24 @@ + RESOLVEFUNC(OPENSSL_add_all_algorithms_noconf) + RESOLVEFUNC(OPENSSL_add_all_algorithms_conf) + #endif // Q_OS_SYMBIAN ++ ++ // BEGIN: Added for SwissSurfer ++#ifndef Q_OS_SYMBIAN ++ RESOLVEFUNC(ENGINE_load_dynamic) ++ RESOLVEFUNC(ENGINE_by_id) ++ RESOLVEFUNC(ENGINE_ctrl_cmd_string) ++ RESOLVEFUNC(ENGINE_ctrl_cmd) ++ RESOLVEFUNC(ENGINE_init) ++ RESOLVEFUNC(ENGINE_finish) ++ RESOLVEFUNC(ENGINE_cleanup) ++ RESOLVEFUNC(ENGINE_load_private_key) ++ RESOLVEFUNC(SSL_CTX_set_client_cert_cb) ++ RESOLVEFUNC(BIO_new_file) ++ RESOLVEFUNC(PEM_read_bio_X509_AUX) ++ RESOLVEFUNC(PEM_read_bio_X509) ++#endif ++ // END: Added for SwissSurfer ++ + symbolsResolved = true; + delete libs.first; + delete libs.second; +diff -urN qt.orig/src/network/ssl/qsslsocket_openssl_symbols_p.h qt.patched/src/network/ssl/qsslsocket_openssl_symbols_p.h +--- qt.orig/src/network/ssl/qsslsocket_openssl_symbols_p.h 2010-08-27 14:33:14.333796600 +0200 ++++ qt.patched/src/network/ssl/qsslsocket_openssl_symbols_p.h 2010-08-31 11:38:16.795053800 +0200 +@@ -205,7 +205,10 @@ + unsigned char * q_ASN1_STRING_data(ASN1_STRING *a); + int q_ASN1_STRING_length(ASN1_STRING *a); + long q_BIO_ctrl(BIO *a, int b, long c, void *d); +-int q_BIO_free(BIO *a); ++ ++// BEGIN: Made export for SwissSurfer ++Q_NETWORK_EXPORT int q_BIO_free(BIO *a); ++// END: Made export for SwissSurfer + BIO *q_BIO_new(BIO_METHOD *a); + BIO *q_BIO_new_mem_buf(void *a, int b); + int q_BIO_read(BIO *a, void *b, int c); +@@ -223,8 +226,10 @@ + #else + X509 *q_d2i_X509(X509 **a, unsigned char **b, long c); + #endif +-char *q_ERR_error_string(unsigned long a, char *b); +-unsigned long q_ERR_get_error(); ++// BEGIN: Made export for SwissSurfer ++Q_NETWORK_EXPORT char *q_ERR_error_string(unsigned long a, char *b); ++Q_NETWORK_EXPORT unsigned long q_ERR_get_error(); ++// END: Made export for SwissSurfer + const EVP_CIPHER *q_EVP_des_ede3_cbc(); + int q_EVP_PKEY_assign(EVP_PKEY *a, int b, char *c); + void q_EVP_PKEY_free(EVP_PKEY *a); +@@ -274,7 +279,9 @@ + #else + int q_SSL_CTX_check_private_key(SSL_CTX *a); + #endif +-long q_SSL_CTX_ctrl(SSL_CTX *a, int b, long c, void *d); ++// BEGIN: Made export for SwissSurfer ++Q_NETWORK_EXPORT long q_SSL_CTX_ctrl(SSL_CTX *a, int b, long c, void *d); ++// END: Made export for SwissSurfer + void q_SSL_CTX_free(SSL_CTX *a); + #if OPENSSL_VERSION_NUMBER >= 0x10000000L + SSL_CTX *q_SSL_CTX_new(const SSL_METHOD *a); +@@ -345,17 +352,23 @@ + #define q_X509_dup(x509) (X509 *)q_ASN1_dup((i2d_of_void *)q_i2d_X509, \ + (d2i_of_void *)q_d2i_X509,(char *)x509) + #else +-X509 *q_X509_dup(X509 *a); ++// BEGIN: Made export for SwissSurfer ++Q_NETWORK_EXPORT X509 *q_X509_dup(X509 *a); ++// END: Made export for SwissSurfer + #endif + ASN1_OBJECT *q_X509_EXTENSION_get_object(X509_EXTENSION *a); + void q_X509_free(X509 *a); + X509_EXTENSION *q_X509_get_ext(X509 *a, int b); + int q_X509_get_ext_count(X509 *a); + void *q_X509_get_ext_d2i(X509 *a, int b, int *c, int *d); +-X509_NAME *q_X509_get_issuer_name(X509 *a); +-X509_NAME *q_X509_get_subject_name(X509 *a); ++// BEGIN: Made export for SwissSurfer ++Q_NETWORK_EXPORT X509_NAME *q_X509_get_issuer_name(X509 *a); ++Q_NETWORK_EXPORT X509_NAME *q_X509_get_subject_name(X509 *a); ++// END: Made export for SwissSurfer + int q_X509_verify_cert(X509_STORE_CTX *ctx); +-char *q_X509_NAME_oneline(X509_NAME *a, char *b, int c); ++// BEGIN: Made export for SwissSurfer ++Q_NETWORK_EXPORT char *q_X509_NAME_oneline(X509_NAME *a, char *b, int c); ++// END: Made export for SwissSurfer + EVP_PKEY *q_X509_PUBKEY_get(X509_PUBKEY *a); + void q_X509_STORE_free(X509_STORE *store); + X509_STORE *q_X509_STORE_new(); +@@ -411,6 +424,29 @@ + void q_OPENSSL_add_all_algorithms_noconf(); + void q_OPENSSL_add_all_algorithms_conf(); + ++// BEGIN: Added for SwissSurfer ++#ifndef Q_OS_SYMBIAN ++ ++#include ++ ++Q_NETWORK_EXPORT void q_ENGINE_load_dynamic(void); ++Q_NETWORK_EXPORT ENGINE* q_ENGINE_by_id(const char *id); ++Q_NETWORK_EXPORT int q_ENGINE_ctrl_cmd_string(ENGINE *e, const char *cmd_name, const char *arg, int cmd_optional); ++Q_NETWORK_EXPORT int q_ENGINE_ctrl_cmd(ENGINE *e, const char *cmd_name, long i, void *p, void (*f)(void), int cmd_optional); ++Q_NETWORK_EXPORT int q_ENGINE_init(ENGINE *e); ++Q_NETWORK_EXPORT int q_ENGINE_finish(ENGINE *e); ++Q_NETWORK_EXPORT void q_ENGINE_cleanup(void); ++Q_NETWORK_EXPORT EVP_PKEY* q_ENGINE_load_private_key(ENGINE *e, const char *key_id, ++ UI_METHOD *ui_method, void *callback_data); ++ ++Q_NETWORK_EXPORT void q_SSL_CTX_set_client_cert_cb(SSL_CTX *ctx, int (*client_cert_cb)(SSL *ssl, X509 **x509, EVP_PKEY **pkey)); ++Q_NETWORK_EXPORT BIO* q_BIO_new_file(const char *filename, const char *mode); ++Q_NETWORK_EXPORT X509* q_PEM_read_bio_X509_AUX(BIO *bp, X509 **x, pem_password_cb *cb, void *u); ++Q_NETWORK_EXPORT X509* q_PEM_read_bio_X509(BIO *bp, X509 **x, pem_password_cb *cb, void *u); ++#endif ++// END: Added for SwissSurfer ++ ++ + // Helper function + class QDateTime; + QDateTime q_getTimeFromASN1(const ASN1_TIME *aTime); +diff -urN qt.orig/src/network/ssl/qsslsocket_p.h qt.patched/src/network/ssl/qsslsocket_p.h +--- qt.orig/src/network/ssl/qsslsocket_p.h 2010-08-27 14:33:14.349421800 +0200 ++++ qt.patched/src/network/ssl/qsslsocket_p.h 2010-08-27 12:01:44.805801500 +0200 +@@ -90,7 +90,7 @@ + // that was used for connecting to. + QString verificationPeerName; + +- static bool ensureInitialized(); ++ Q_NETWORK_EXPORT static bool ensureInitialized(); + static void deinitialize(); + static QList defaultCiphers(); + static QList supportedCiphers(); +diff -urN qt.orig/src/script/api/qscriptengine.cpp qt.patched/src/script/api/qscriptengine.cpp +--- qt.orig/src/script/api/qscriptengine.cpp 2010-08-27 14:33:14.365047000 +0200 ++++ qt.patched/src/script/api/qscriptengine.cpp 2010-08-27 12:01:44.821425900 +0200 +@@ -1603,7 +1603,7 @@ + + #ifndef QT_NO_REGEXP + +-Q_DECL_IMPORT extern QString qt_regexp_toCanonical(const QString &, QRegExp::PatternSyntax); ++Q_CORE_EXPORT extern QString qt_regexp_toCanonical(const QString &, QRegExp::PatternSyntax); + + /*! + Creates a QtScript object of class RegExp with the given +diff -urN qt.orig/src/script/parser/qscriptlexer.cpp qt.patched/src/script/parser/qscriptlexer.cpp +--- qt.orig/src/script/parser/qscriptlexer.cpp 2010-08-27 14:33:14.411922600 +0200 ++++ qt.patched/src/script/parser/qscriptlexer.cpp 2010-08-27 12:01:44.868299100 +0200 +@@ -31,7 +31,7 @@ + + QT_BEGIN_NAMESPACE + +-Q_DECL_IMPORT extern double qstrtod(const char *s00, char const **se, bool *ok); ++Q_CORE_EXPORT extern double qstrtod(const char *s00, char const **se, bool *ok); + + #define shiftWindowsLineBreak() \ + do { \ +diff -urN qt.orig/src/svg/qsvghandler.cpp qt.patched/src/svg/qsvghandler.cpp +--- qt.orig/src/svg/qsvghandler.cpp 2010-08-27 14:33:14.443173000 +0200 ++++ qt.patched/src/svg/qsvghandler.cpp 2010-08-27 12:01:44.899547900 +0200 +@@ -74,7 +74,7 @@ + static const char *qt_inherit_text = "inherit"; + #define QT_INHERIT QLatin1String(qt_inherit_text) + +-Q_DECL_IMPORT double qstrtod(const char *s00, char const **se, bool *ok); ++Q_CORE_EXPORT double qstrtod(const char *s00, char const **se, bool *ok); + + // ======== duplicated from qcolor_p + +diff -urN qt.orig/src/xmlpatterns/data/qdecimal_p.h qt.patched/src/xmlpatterns/data/qdecimal_p.h +--- qt.orig/src/xmlpatterns/data/qdecimal_p.h 2010-08-27 14:33:14.458798200 +0200 ++++ qt.patched/src/xmlpatterns/data/qdecimal_p.h 2010-08-27 12:01:44.915172300 +0200 +@@ -61,7 +61,7 @@ + /** + * Defined in QtCore's qlocale.cpp. + */ +-Q_DECL_IMPORT extern char *qdtoa(double d, int mode, int ndigits, int *decpt, int *sign, char **rve, char **resultp); ++Q_CORE_EXPORT extern char *qdtoa(double d, int mode, int ndigits, int *decpt, int *sign, char **rve, char **resultp); + + namespace QPatternist + {