Merge branch 'vendor/OPENSSL'
authorSascha Wildner <saw@online.de>
Thu, 19 Mar 2015 20:06:51 +0000 (21:06 +0100)
committerSascha Wildner <saw@online.de>
Thu, 19 Mar 2015 20:06:51 +0000 (21:06 +0100)
1  2 
crypto/openssl/crypto/des/des_old.h
crypto/openssl/crypto/engine/eng_all.c
crypto/openssl/crypto/engine/eng_cryptodev.c
crypto/openssl/crypto/engine/engine.h
crypto/openssl/crypto/evp/c_all.c
crypto/openssl/crypto/uid.c
crypto/openssl/ssl/srtp.h

  extern "C" {
  #endif
  
- #ifdef _
- #undef _
- #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__) && !defined(__DragonFly__)
- #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
+ 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__)
++#   if !defined(PERL5) && !defined(__FreeBSD__) && !defined(NeXT) && !defined(__OpenBSD__) && !defined(__DragonFly__)
+ #    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_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);
+                             _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);
+                             _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);
+                                       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);
+                                       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);
+ 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);
+ 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);
  
  #include "eng_int.h"
  
  void ENGINE_load_builtin_engines(void)
      {
-       /* Some ENGINEs need this */
-       OPENSSL_cpuid_setup();
+ {
+     /* Some ENGINEs need this */
+     OPENSSL_cpuid_setup();
  #if 0
-       /* There's no longer any need for an "openssl" ENGINE unless, one day,
-        * it is the *only* way for standard builtin implementations to be be
-        * accessed (ie. it would be possible to statically link binaries with
-        * *no* builtin implementations). */
-       ENGINE_load_openssl();
+     /*
+      * There's no longer any need for an "openssl" ENGINE unless, one day, it
+      * is the *only* way for standard builtin implementations to be be
+      * accessed (ie. it would be possible to statically link binaries with
+      * *no* builtin implementations).
+      */
+     ENGINE_load_openssl();
  #endif
 -#if !defined(OPENSSL_NO_HW) && (defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV))
 +#if !defined(OPENSSL_NO_HW) && (defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__) || defined(HAVE_CRYPTODEV))
-       ENGINE_load_cryptodev();
+     ENGINE_load_cryptodev();
  #endif
  #ifndef OPENSSL_NO_RSAX
-       ENGINE_load_rsax();
+     ENGINE_load_rsax();
  #endif
  #ifndef OPENSSL_NO_RDRAND
-       ENGINE_load_rdrand();
+     ENGINE_load_rdrand();
  #endif
-       ENGINE_load_dynamic();
+     ENGINE_load_dynamic();
  #ifndef OPENSSL_NO_STATIC_ENGINE
- #ifndef OPENSSL_NO_HW
- #ifndef OPENSSL_NO_HW_4758_CCA
-       ENGINE_load_4758cca();
- #endif
- #ifndef OPENSSL_NO_HW_AEP
-       ENGINE_load_aep();
- #endif
- #ifndef OPENSSL_NO_HW_ATALLA
-       ENGINE_load_atalla();
- #endif
- #ifndef OPENSSL_NO_HW_CSWIFT
-       ENGINE_load_cswift();
- #endif
- #ifndef OPENSSL_NO_HW_NCIPHER
-       ENGINE_load_chil();
- #endif
- #ifndef OPENSSL_NO_HW_NURON
-       ENGINE_load_nuron();
- #endif
- #ifndef OPENSSL_NO_HW_SUREWARE
-       ENGINE_load_sureware();
- #endif
- #ifndef OPENSSL_NO_HW_UBSEC
-       ENGINE_load_ubsec();
- #endif
- #ifndef OPENSSL_NO_HW_PADLOCK
-       ENGINE_load_padlock();
- #endif
- #endif
- #ifndef OPENSSL_NO_GOST
-       ENGINE_load_gost();
- #endif
- #ifndef OPENSSL_NO_GMP
-       ENGINE_load_gmp();
- #endif
- #if defined(OPENSSL_SYS_WIN32) && !defined(OPENSSL_NO_CAPIENG)
-       ENGINE_load_capi();
- #endif
- #endif
-       ENGINE_register_all_complete();
      }
+ # ifndef OPENSSL_NO_HW
+ #  ifndef OPENSSL_NO_HW_4758_CCA
+     ENGINE_load_4758cca();
+ #  endif
+ #  ifndef OPENSSL_NO_HW_AEP
+     ENGINE_load_aep();
+ #  endif
+ #  ifndef OPENSSL_NO_HW_ATALLA
+     ENGINE_load_atalla();
+ #  endif
+ #  ifndef OPENSSL_NO_HW_CSWIFT
+     ENGINE_load_cswift();
+ #  endif
+ #  ifndef OPENSSL_NO_HW_NCIPHER
+     ENGINE_load_chil();
+ #  endif
+ #  ifndef OPENSSL_NO_HW_NURON
+     ENGINE_load_nuron();
+ #  endif
+ #  ifndef OPENSSL_NO_HW_SUREWARE
+     ENGINE_load_sureware();
+ #  endif
+ #  ifndef OPENSSL_NO_HW_UBSEC
+     ENGINE_load_ubsec();
+ #  endif
+ #  ifndef OPENSSL_NO_HW_PADLOCK
+     ENGINE_load_padlock();
+ #  endif
+ # endif
+ # ifndef OPENSSL_NO_GOST
+     ENGINE_load_gost();
+ # endif
+ # ifndef OPENSSL_NO_GMP
+     ENGINE_load_gmp();
+ # endif
+ # if defined(OPENSSL_SYS_WIN32) && !defined(OPENSSL_NO_CAPIENG)
+     ENGINE_load_capi();
+ # endif
+ #endif
+     ENGINE_register_all_complete();
+ }
  
 -#if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV)
 +#if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__) || defined(HAVE_CRYPTODEV)
- void ENGINE_setup_bsd_cryptodev(void) {
-       static int bsd_cryptodev_default_loaded = 0;
-       if (!bsd_cryptodev_default_loaded) {
-               ENGINE_load_cryptodev();
-               ENGINE_register_all_complete();
-       }
-       bsd_cryptodev_default_loaded=1;
+ void ENGINE_setup_bsd_cryptodev(void)
+ {
+     static int bsd_cryptodev_default_loaded = 0;
+     if (!bsd_cryptodev_default_loaded) {
+         ENGINE_load_cryptodev();
+         ENGINE_register_all_complete();
+     }
+     bsd_cryptodev_default_loaded = 1;
  }
  #endif
@@@ -32,9 -32,9 +32,9 @@@
  #include <openssl/bn.h>
  
  #if (defined(__unix__) || defined(unix)) && !defined(USG) && \
-       (defined(OpenBSD) || defined(__FreeBSD__) || defined(__DragonFly__))
- #include <sys/param.h>
 -        (defined(OpenBSD) || defined(__FreeBSD__))
++        (defined(OpenBSD) || defined(__FreeBSD__) || defined(__DragonFly__))
+ # include <sys/param.h>
 -# if (OpenBSD >= 200112) || ((__FreeBSD_version >= 470101 && __FreeBSD_version < 500000) || __FreeBSD_version >= 500041)
 +# if (OpenBSD >= 200112) || ((__FreeBSD_version >= 470101 && __FreeBSD_version < 500000) || __FreeBSD_version >= 500041) || (__DragonFly_version >= 200500)
  #  define HAVE_CRYPTODEV
  # endif
  # if (OpenBSD >= 200110)
@@@ -627,125 -731,140 +731,140 @@@ void ENGINE_add_conf_module(void)
  /**************************/
  
  /* 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 *);
+ # 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);
+     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;
+     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
+     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); \
-       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
+  * 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); \
+         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); \
-       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. */
+  * 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); \
+         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(__DragonFly__) || defined(HAVE_CRYPTODEV)
 -# if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV)
++# if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__) || defined(HAVE_CRYPTODEV)
  void ENGINE_setup_bsd_cryptodev(void);
- #endif
+ # endif
  
  /* BEGIN ERROR CODES */
- /* The following lines are auto generated by the script mkerr.pl. Any changes
+ /*
+  * 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);
@@@ -73,18 -73,18 +73,18 @@@ void OpenSSL_add_all_algorithms(void
  #endif
  
  void OPENSSL_add_all_algorithms_noconf(void)
      {
-       /*
-        * For the moment OPENSSL_cpuid_setup does something
-        * only on IA-32, but we reserve the option for all
-        * platforms...
-        */
-       OPENSSL_cpuid_setup();
-       OpenSSL_add_all_ciphers();
-       OpenSSL_add_all_digests();
+ {
+     /*
+      * For the moment OPENSSL_cpuid_setup does something
+      * only on IA-32, but we reserve the option for all
+      * platforms...
+      */
+     OPENSSL_cpuid_setup();
+     OpenSSL_add_all_ciphers();
+     OpenSSL_add_all_digests();
  #ifndef OPENSSL_NO_ENGINE
 -# if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV)
 +# if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__) || defined(HAVE_CRYPTODEV)
-       ENGINE_setup_bsd_cryptodev();
+     ENGINE_setup_bsd_cryptodev();
  # endif
  #endif
      }
+ }
  #include <openssl/crypto.h>
  #include <openssl/opensslconf.h>
  
 -#if defined(__OpenBSD__) || (defined(__FreeBSD__) && __FreeBSD__ > 2)
 +#if defined(__OpenBSD__) || defined(__DragonFly__) || (defined(__FreeBSD__) && __FreeBSD__ > 2)
  
- #include OPENSSL_UNISTD
+ # include OPENSSL_UNISTD
  
  int OPENSSL_issetugid(void)
      {
-       return issetugid();
      }
+ {
+     return issetugid();
+ }
  
  #elif defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_VXWORKS) || defined(OPENSSL_SYS_NETWARE)
  
Simple merge