Configure

   1 :
   2 eval 'exec perl -S $0 ${1+"$@"}'
   3     if $running_under_some_shell;
   4 ##
   5 ##  Configure -- OpenSSL source tree configuration script
   6 ##  If editing this file, run this command before committing
   7 ##      make -f Makefile.org TABLE
   8 ##
   9
  10 require 5.000;
  11 use strict;
  12 use File::Basename;
  13 use File::Spec::Functions;
  14
  15 # see INSTALL for instructions.
  16
  17 my $usage="Usage: Configure [no-<cipher> ...] [enable-<cipher> ...] [experimental-<cipher> ...] [-Dxxx] [-lxxx] [-Lxxx] [-fxxx] [-Kxxx] [no-hw-xxx|no-hw] [[no-]threads] [[no-]shared] [[no-]zlib|zlib-dynamic] [no-asm] [no-dso] [no-krb5] [sctp] [386] [--prefix=DIR] [--openssldir=OPENSSLDIR] [--with-xxx[=vvv]] [--test-sanity] [--config=FILE] os/compiler[:flags]\n";
  18
  19 # Options:
  20 #
  21 # --config      add the given configuration file, which will be read after
  22 #               any "Configurations*" files that are found in the same
  23 #               directory as this script.
  24 # --openssldir  install OpenSSL in OPENSSLDIR (Default: DIR/ssl if the
  25 #               --prefix option is given; /usr/local/ssl otherwise)
  26 # --prefix      prefix for the OpenSSL include, lib and bin directories
  27 #               (Default: the OPENSSLDIR directory)
  28 #
  29 # --install_prefix  Additional prefix for package builders (empty by
  30 #               default).  This needn't be set in advance, you can
  31 #               just as well use "make INSTALL_PREFIX=/whatever install".
  32 #
  33 # --with-krb5-dir  Declare where Kerberos 5 lives.  The libraries are expected
  34 #               to live in the subdirectory lib/ and the header files in
  35 #               include/.  A value is required.
  36 # --with-krb5-lib  Declare where the Kerberos 5 libraries live.  A value is
  37 #               required.
  38 #               (Default: KRB5_DIR/lib)
  39 # --with-krb5-include  Declare where the Kerberos 5 header files live.  A
  40 #               value is required.
  41 #               (Default: KRB5_DIR/include)
  42 # --with-krb5-flavor  Declare what flavor of Kerberos 5 is used.  Currently
  43 #               supported values are "MIT" and "Heimdal".  A value is required.
  44 #
  45 # --test-sanity Make a number of sanity checks on the data in this file.
  46 #               This is a debugging tool for OpenSSL developers.
  47 #
  48 # --cross-compile-prefix Add specified prefix to binutils components.
  49 #
  50 # no-hw-xxx     do not compile support for specific crypto hardware.
  51 #               Generic OpenSSL-style methods relating to this support
  52 #               are always compiled but return NULL if the hardware
  53 #               support isn't compiled.
  54 # no-hw         do not compile support for any crypto hardware.
  55 # [no-]threads  [don't] try to create a library that is suitable for
  56 #               multithreaded applications (default is "threads" if we
  57 #               know how to do it)
  58 # [no-]shared   [don't] try to create shared libraries when supported.
  59 # no-asm        do not use assembler
  60 # no-dso        do not compile in any native shared-library methods. This
  61 #               will ensure that all methods just return NULL.
  62 # no-krb5       do not compile in any KRB5 library or code.
  63 # [no-]zlib     [don't] compile support for zlib compression.
  64 # zlib-dynamic  Like "zlib", but the zlib library is expected to be a shared
  65 #               library and will be loaded in run-time by the OpenSSL library.
  66 # sctp          include SCTP support
  67 # 386           generate 80386 code
  68 # no-sse2       disables IA-32 SSE2 code, above option implies no-sse2
  69 # no-<cipher>   build without specified algorithm (rsa, idea, rc5, ...)
  70 # -<xxx> +<xxx> compiler options are passed through
  71 #
  72 # DEBUG_SAFESTACK use type-safe stacks to enforce type-safety on stack items
  73 #               provided to stack calls. Generates unique stack functions for
  74 #               each possible stack type.
  75 # DES_PTR       use pointer lookup vs arrays in the DES in crypto/des/des_locl.h
  76 # DES_RISC1     use different DES_ENCRYPT macro that helps reduce register
  77 #               dependancies but needs to more registers, good for RISC CPU's
  78 # DES_RISC2     A different RISC variant.
  79 # DES_UNROLL    unroll the inner DES loop, sometimes helps, somtimes hinders.
  80 # DES_INT       use 'int' instead of 'long' for DES_LONG in crypto/des/des.h
  81 #               This is used on the DEC Alpha where long is 8 bytes
  82 #               and int is 4
  83 # BN_LLONG      use the type 'long long' in crypto/bn/bn.h
  84 # MD2_CHAR      use 'char' instead of 'int' for MD2_INT in crypto/md2/md2.h
  85 # MD2_LONG      use 'long' instead of 'int' for MD2_INT in crypto/md2/md2.h
  86 # IDEA_SHORT    use 'short' instead of 'int' for IDEA_INT in crypto/idea/idea.h
  87 # IDEA_LONG     use 'long' instead of 'int' for IDEA_INT in crypto/idea/idea.h
  88 # RC2_SHORT     use 'short' instead of 'int' for RC2_INT in crypto/rc2/rc2.h
  89 # RC2_LONG      use 'long' instead of 'int' for RC2_INT in crypto/rc2/rc2.h
  90 # RC4_CHAR      use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
  91 # RC4_LONG      use 'long' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
  92 # RC4_INDEX     define RC4_INDEX in crypto/rc4/rc4_locl.h.  This turns on
  93 #               array lookups instead of pointer use.
  94 # RC4_CHUNK     enables code that handles data aligned at long (natural CPU
  95 #               word) boundary.
  96 # RC4_CHUNK_LL  enables code that handles data aligned at long long boundary
  97 #               (intended for 64-bit CPUs running 32-bit OS).
  98 # BF_PTR        use 'pointer arithmatic' for Blowfish (unsafe on Alpha).
  99 # BF_PTR2       intel specific version (generic version is more efficient).
 100 #
 101 # Following are set automatically by this script
 102 #
 103 # MD5_ASM       use some extra md5 assember,
 104 # SHA1_ASM      use some extra sha1 assember, must define L_ENDIAN for x86
 105 # RMD160_ASM    use some extra ripemd160 assember,
 106 # SHA256_ASM    sha256_block is implemented in assembler
 107 # SHA512_ASM    sha512_block is implemented in assembler
 108 # AES_ASM       ASE_[en|de]crypt is implemented in assembler
 109
 110 # Minimum warning options... any contributions to OpenSSL should at least get
 111 # past these.
 112
 113 my $gcc_devteam_warn = "-Wall -pedantic -DPEDANTIC -Wno-long-long -Wsign-compare -Wmissing-prototypes -Wshadow -Wformat -Werror -DCRYPTO_MDEBUG_ALL -DCRYPTO_MDEBUG_ABORT -DREF_CHECK";
 114
 115 my $clang_disabled_warnings = "-Wno-language-extension-token -Wno-extended-offsetof -Wno-padded -Wno-shorten-64-to-32 -Wno-format-nonliteral -Wno-missing-noreturn -Wno-unused-parameter -Wno-sign-conversion -Wno-unreachable-code -Wno-conversion -Wno-documentation -Wno-missing-variable-declarations -Wno-cast-align -Wno-incompatible-pointer-types-discards-qualifiers -Wno-missing-variable-declarations -Wno-missing-field-initializers -Wno-unused-macros -Wno-disabled-macro-expansion -Wno-conditional-uninitialized -Wno-switch-enum";
 116
 117 my $strict_warnings = 0;
 118
 119 my $x86_gcc_des="DES_PTR DES_RISC1 DES_UNROLL";
 120
 121 # MD2_CHAR slags pentium pros
 122 my $x86_gcc_opts="RC4_INDEX MD2_INT";
 123
 124 # MODIFY THESE PARAMETERS IF YOU ARE GOING TO USE THE 'util/speed.sh SCRIPT
 125 # Don't worry about these normally
 126
 127 my $tcc="cc";
 128 my $tflags="-fast -Xa";
 129 my $tbn_mul="";
 130 my $tlib="-lnsl -lsocket";
 131 #$bits1="SIXTEEN_BIT ";
 132 #$bits2="THIRTY_TWO_BIT ";
 133 my $bits1="THIRTY_TWO_BIT ";
 134 my $bits2="SIXTY_FOUR_BIT ";
 135
 136 my $x86_asm="x86cpuid.o:bn-586.o co-586.o x86-mont.o x86-gf2m.o:ecp_nistz256.o ecp_nistz256-x86.o:des-586.o crypt586.o:aes-586.o vpaes-x86.o aesni-x86.o:bf-586.o:md5-586.o:sha1-586.o sha256-586.o sha512-586.o:cast-586.o:rc4-586.o:rmd-586.o:rc5-586.o:wp_block.o wp-mmx.o:cmll-x86.o:ghash-x86.o:e_padlock-x86.o";
 137
 138 my $x86_elf_asm="$x86_asm:elf";
 139
 140 my $x86_64_asm="x86_64cpuid.o:x86_64-gcc.o x86_64-mont.o x86_64-mont5.o x86_64-gf2m.o rsaz_exp.o rsaz-x86_64.o rsaz-avx2.o:ecp_nistz256.o ecp_nistz256-x86_64.o::aes-x86_64.o vpaes-x86_64.o bsaes-x86_64.o aesni-x86_64.o aesni-sha1-x86_64.o aesni-sha256-x86_64.o aesni-mb-x86_64.o::md5-x86_64.o:sha1-x86_64.o sha256-x86_64.o sha512-x86_64.o sha1-mb-x86_64.o sha256-mb-x86_64.o::rc4-x86_64.o rc4-md5-x86_64.o:::wp-x86_64.o:cmll-x86_64.o cmll_misc.o:ghash-x86_64.o aesni-gcm-x86_64.o:e_padlock-x86_64.o";
 141 my $ia64_asm="ia64cpuid.o:bn-ia64.o ia64-mont.o:::aes_core.o aes_cbc.o aes-ia64.o::md5-ia64.o:sha1-ia64.o sha256-ia64.o sha512-ia64.o::rc4-ia64.o rc4_skey.o:::::ghash-ia64.o::void";
 142 my $sparcv9_asm="sparcv9cap.o sparccpuid.o:bn-sparcv9.o sparcv9-mont.o sparcv9a-mont.o vis3-mont.o sparct4-mont.o sparcv9-gf2m.o::des_enc-sparc.o fcrypt_b.o dest4-sparcv9.o:aes_core.o aes_cbc.o aes-sparcv9.o aest4-sparcv9.o::md5-sparcv9.o:sha1-sparcv9.o sha256-sparcv9.o sha512-sparcv9.o::::::camellia.o cmll_misc.o cmll_cbc.o cmllt4-sparcv9.o:ghash-sparcv9.o::void";
 143 my $sparcv8_asm=":sparcv8.o::des_enc-sparc.o fcrypt_b.o:::::::::::::void";
 144 my $alpha_asm="alphacpuid.o:bn_asm.o alpha-mont.o::::::sha1-alpha.o:::::::ghash-alpha.o::void";
 145 my $mips64_asm=":bn-mips.o mips-mont.o:::aes_cbc.o aes-mips.o:::sha1-mips.o sha256-mips.o sha512-mips.o::::::::";
 146 my $mips32_asm=$mips64_asm; $mips32_asm =~ s/\s*sha512\-mips\.o//;
 147 my $s390x_asm="s390xcap.o s390xcpuid.o:bn-s390x.o s390x-mont.o s390x-gf2m.o:::aes-s390x.o aes-ctr.o aes-xts.o:::sha1-s390x.o sha256-s390x.o sha512-s390x.o::rc4-s390x.o:::::ghash-s390x.o:";
 148 my $armv4_asm="armcap.o armv4cpuid.o:bn_asm.o armv4-mont.o armv4-gf2m.o:ecp_nistz256.o ecp_nistz256-armv4.o::aes_cbc.o aes-armv4.o bsaes-armv7.o aesv8-armx.o:::sha1-armv4-large.o sha256-armv4.o sha512-armv4.o:::::::ghash-armv4.o ghashv8-armx.o::void";
 149 my $aarch64_asm="armcap.o arm64cpuid.o mem_clr.o::::aes_core.o aes_cbc.o aesv8-armx.o:::sha1-armv8.o sha256-armv8.o sha512-armv8.o:::::::ghashv8-armx.o:";
 150 my $parisc11_asm="pariscid.o:bn_asm.o parisc-mont.o:::aes_core.o aes_cbc.o aes-parisc.o:::sha1-parisc.o sha256-parisc.o sha512-parisc.o::rc4-parisc.o:::::ghash-parisc.o::32";
 151 my $parisc20_asm="pariscid.o:pa-risc2W.o parisc-mont.o:::aes_core.o aes_cbc.o aes-parisc.o:::sha1-parisc.o sha256-parisc.o sha512-parisc.o::rc4-parisc.o:::::ghash-parisc.o::64";
 152 my $ppc64_asm="ppccpuid.o ppccap.o:bn-ppc.o ppc-mont.o ppc64-mont.o:::aes_core.o aes_cbc.o aes-ppc.o vpaes-ppc.o aesp8-ppc.o:::sha1-ppc.o sha256-ppc.o sha512-ppc.o sha256p8-ppc.o sha512p8-ppc.o:::::::ghashp8-ppc.o:";
 153 my $ppc32_asm=$ppc64_asm;
 154
 155 # As for $BSDthreads. Idea is to maintain "collective" set of flags,
 156 # which would cover all BSD flavors. -pthread applies to them all,
 157 # but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
 158 # -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
 159 # which has to be accompanied by explicit -D_THREAD_SAFE and
 160 # sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
 161 # seems to be sufficient?
 162 my $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
 163
 164 #config-string  $cc : $cflags : $unistd : $thread_cflag : $sys_id : $lflags : $bn_ops : $cpuid_obj : $bn_obj : $ec_obj : $des_obj : $aes_obj : $bf_obj : $md5_obj : $sha1_obj : $cast_obj : $rc4_obj : $rmd160_obj : $rc5_obj : $wp_obj : $cmll_obj : $modes_obj : $engines_obj : $dso_scheme : $shared_target : $shared_cflag : $shared_ldflag : $shared_extension : $ranlib : $arflags : $multilib
 165
 166 # table of known configurations, read in from files
 167 my %table=(
 168 );
 169
 170 # Read configuration target stanzas from a file, so that people can have
 171 # local files with their own definitions
 172 sub read_config {
 173         my $fname = shift;
 174         open(CONFFILE, "< $fname")
 175                 or die "Can't open configuration file '$fname'!\n";
 176         my $x = $/;
 177         undef $/;
 178         my $content = <CONFFILE>;
 179         $/ = $x;
 180         close(CONFFILE);
 181         my %targets = ();
 182         eval $content;
 183         %table = (%table, %targets);
 184 }
 185
 186 my ($vol, $dir, $dummy) = File::Spec->splitpath($0);
 187 my $pattern = File::Spec->catpath($vol, $dir, "Configurations*");
 188 foreach ( glob($pattern) ) {
 189     &read_config($_);
 190 }
 191
 192 my @MK1MF_Builds=qw(VC-WIN64I VC-WIN64A
 193                     debug-VC-WIN64I debug-VC-WIN64A
 194                     VC-NT VC-CE VC-WIN32 debug-VC-WIN32
 195                     BC-32
 196                     netware-clib netware-clib-bsdsock
 197                     netware-libc netware-libc-bsdsock);
 198
 199 my $idx = 0;
 200 my $idx_cc = $idx++;
 201 my $idx_cflags = $idx++;
 202 my $idx_unistd = $idx++;
 203 my $idx_thread_cflag = $idx++;
 204 my $idx_sys_id = $idx++;
 205 my $idx_lflags = $idx++;
 206 my $idx_bn_ops = $idx++;
 207 my $idx_cpuid_obj = $idx++;
 208 my $idx_bn_obj = $idx++;
 209 my $idx_ec_obj = $idx++;
 210 my $idx_des_obj = $idx++;
 211 my $idx_aes_obj = $idx++;
 212 my $idx_bf_obj = $idx++;
 213 my $idx_md5_obj = $idx++;
 214 my $idx_sha1_obj = $idx++;
 215 my $idx_cast_obj = $idx++;
 216 my $idx_rc4_obj = $idx++;
 217 my $idx_rmd160_obj = $idx++;
 218 my $idx_rc5_obj = $idx++;
 219 my $idx_wp_obj = $idx++;
 220 my $idx_cmll_obj = $idx++;
 221 my $idx_modes_obj = $idx++;
 222 my $idx_engines_obj = $idx++;
 223 my $idx_perlasm_scheme = $idx++;
 224 my $idx_dso_scheme = $idx++;
 225 my $idx_shared_target = $idx++;
 226 my $idx_shared_cflag = $idx++;
 227 my $idx_shared_ldflag = $idx++;
 228 my $idx_shared_extension = $idx++;
 229 my $idx_ranlib = $idx++;
 230 my $idx_arflags = $idx++;
 231 my $idx_multilib = $idx++;
 232
 233 my $prefix="";
 234 my $libdir="";
 235 my $openssldir="";
 236 my $exe_ext="";
 237 my $install_prefix= "$ENV{'INSTALL_PREFIX'}";
 238 my $cross_compile_prefix="";
 239 my $fipslibdir="/usr/local/ssl/fips-2.0/lib/";
 240 my $nofipscanistercheck=0;
 241 my $baseaddr="0xFB00000";
 242 my $no_threads=0;
 243 my $threads=0;
 244 my $no_shared=0; # but "no-shared" is default
 245 my $zlib=1;      # but "no-zlib" is default
 246 my $no_krb5=0;   # but "no-krb5" is implied unless "--with-krb5-..." is used
 247 my $no_rfc3779=1; # but "no-rfc3779" is default
 248 my $no_asm=0;
 249 my $no_dso=0;
 250 my $no_gmp=0;
 251 my @skip=();
 252 my $Makefile="Makefile";
 253 my $des_locl="crypto/des/des_locl.h";
 254 my $des ="crypto/des/des.h";
 255 my $bn  ="crypto/bn/bn.h";
 256 my $md2 ="crypto/md2/md2.h";
 257 my $rc4 ="crypto/rc4/rc4.h";
 258 my $rc4_locl="crypto/rc4/rc4_locl.h";
 259 my $idea        ="crypto/idea/idea.h";
 260 my $rc2 ="crypto/rc2/rc2.h";
 261 my $bf  ="crypto/bf/bf_locl.h";
 262 my $bn_asm      ="bn_asm.o";
 263 my $des_enc="des_enc.o fcrypt_b.o";
 264 my $aes_enc="aes_core.o aes_cbc.o";
 265 my $bf_enc      ="bf_enc.o";
 266 my $cast_enc="c_enc.o";
 267 my $rc4_enc="rc4_enc.o rc4_skey.o";
 268 my $rc5_enc="rc5_enc.o";
 269 my $cmll_enc="camellia.o cmll_misc.o cmll_cbc.o";
 270 my $processor="";
 271 my $default_ranlib;
 272 my $perl;
 273 my $fips=0;
 274
 275 # All of the following is disabled by default (RC5 was enabled before 0.9.8):
 276
 277 my %disabled = ( # "what"         => "comment" [or special keyword "experimental"]
 278                  "deprecated" => "default",
 279                  "ec_nistp_64_gcc_128" => "default",
 280                  "gmp"            => "default",
 281                  "jpake"          => "experimental",
 282                  "md2"            => "default",
 283                  "rc5"            => "default",
 284                  "rfc3779"        => "default",
 285                  "sctp"       => "default",
 286                  "shared"         => "default",
 287                  "ssl-trace"      => "default",
 288                  "store"          => "experimental",
 289                  "unit-test"      => "default",
 290                  "zlib"           => "default",
 291                  "zlib-dynamic"   => "default"
 292                );
 293 my @experimental = ();
 294
 295 # This is what $depflags will look like with the above defaults
 296 # (we need this to see if we should advise the user to run "make depend"):
 297 my $default_depflags = " -DOPENSSL_NO_DEPRECATED -DOPENSSL_NO_EC_NISTP_64_GCC_128 -DOPENSSL_NO_GMP -DOPENSSL_NO_JPAKE -DOPENSSL_NO_MD2 -DOPENSSL_NO_RC5 -DOPENSSL_NO_RFC3779 -DOPENSSL_NO_SCTP -DOPENSSL_NO_SSL_TRACE -DOPENSSL_NO_STORE -DOPENSSL_NO_UNIT_TEST";
 298
 299 # Explicit "no-..." options will be collected in %disabled along with the defaults.
 300 # To remove something from %disabled, use "enable-foo" (unless it's experimental).
 301 # For symmetry, "disable-foo" is a synonym for "no-foo".
 302
 303 # For features called "experimental" here, a more explicit "experimental-foo" is needed to enable.
 304 # We will collect such requests in @experimental.
 305 # To avoid accidental use of experimental features, applications will have to use -DOPENSSL_EXPERIMENTAL_FOO.
 306
 307
 308 my $no_sse2=0;
 309
 310 &usage if ($#ARGV < 0);
 311
 312 my $flags;
 313 my $depflags;
 314 my $openssl_experimental_defines;
 315 my $openssl_algorithm_defines;
 316 my $openssl_thread_defines;
 317 my $openssl_sys_defines="";
 318 my $openssl_other_defines;
 319 my $libs;
 320 my $libkrb5="";
 321 my $target;
 322 my $options;
 323 my $symlink;
 324 my $make_depend=0;
 325 my %withargs=();
 326
 327 my @argvcopy=@ARGV;
 328 my $argvstring="";
 329 my $argv_unprocessed=1;
 330
 331 while($argv_unprocessed)
 332         {
 333         $flags="";
 334         $depflags="";
 335         $openssl_experimental_defines="";
 336         $openssl_algorithm_defines="";
 337         $openssl_thread_defines="";
 338         $openssl_sys_defines="";
 339         $openssl_other_defines="";
 340         $libs="";
 341         $target="";
 342         $options="";
 343         $symlink=1;
 344
 345         $argv_unprocessed=0;
 346         $argvstring=join(' ',@argvcopy);
 347
 348 PROCESS_ARGS:
 349         foreach (@argvcopy)
 350                 {
 351                 s /^-no-/no-/; # some people just can't read the instructions
 352
 353                 # rewrite some options in "enable-..." form
 354                 s /^-?-?shared$/enable-shared/;
 355                 s /^sctp$/enable-sctp/;
 356                 s /^threads$/enable-threads/;
 357                 s /^zlib$/enable-zlib/;
 358                 s /^zlib-dynamic$/enable-zlib-dynamic/;
 359
 360                 if (/^no-(.+)$/ || /^disable-(.+)$/)
 361                         {
 362                         if (!($disabled{$1} eq "experimental"))
 363                                 {
 364                                 if ($1 eq "ssl")
 365                                         {
 366                                         $disabled{"ssl3"} = "option(ssl)";
 367                                         }
 368                                 elsif ($1 eq "tls")
 369                                         {
 370                                         $disabled{"tls1"} = "option(tls)"
 371                                         }
 372                                 elsif ($1 eq "ssl3-method")
 373                                         {
 374                                         $disabled{"ssl3-method"} = "option(ssl)";
 375                                         $disabled{"ssl3"} = "option(ssl)";
 376                                         }
 377                                 else
 378                                         {
 379                                         $disabled{$1} = "option";
 380                                         }
 381                                 }
 382                         }
 383                 elsif (/^enable-(.+)$/ || /^experimental-(.+)$/)
 384                         {
 385                         my $algo = $1;
 386                         if ($disabled{$algo} eq "experimental")
 387                                 {
 388                                 die "You are requesting an experimental feature; please say 'experimental-$algo' if you are sure\n"
 389                                         unless (/^experimental-/);
 390                                 push @experimental, $algo;
 391                                 }
 392                         delete $disabled{$algo};
 393
 394                         $threads = 1 if ($algo eq "threads");
 395                         }
 396                 elsif (/^--test-sanity$/)
 397                         {
 398                         exit(&test_sanity());
 399                         }
 400                 elsif (/^--strict-warnings/)
 401                         {
 402                         $strict_warnings = 1;
 403                         }
 404                 elsif (/^reconfigure/ || /^reconf/)
 405                         {
 406                         if (open(IN,"<$Makefile"))
 407                                 {
 408                                 while (<IN>)
 409                                         {
 410                                         chomp;
 411                                         if (/^CONFIGURE_ARGS=(.*)/)
 412                                                 {
 413                                                 $argvstring=$1;
 414                                                 @argvcopy=split(' ',$argvstring);
 415                                                 die "Incorrect data to reconfigure, please do a normal configuration\n"
 416                                                         if (grep(/^reconf/,@argvcopy));
 417                                                 print "Reconfiguring with: $argvstring\n";
 418                                                 $argv_unprocessed=1;
 419                                                 close(IN);
 420                                                 last PROCESS_ARGS;
 421                                                 }
 422                                         }
 423                                 close(IN);
 424                                 }
 425                         die "Insufficient data to reconfigure, please do a normal configuration\n";
 426                         }
 427                 elsif (/^386$/)
 428                         { $processor=386; }
 429                 elsif (/^fips$/)
 430                         {
 431                         $fips=1;
 432                         }
 433                 elsif (/^rsaref$/)
 434                         {
 435                         # No RSAref support any more since it's not needed.
 436                         # The check for the option is there so scripts aren't
 437                         # broken
 438                         }
 439                 elsif (/^nofipscanistercheck$/)
 440                         {
 441                         $fips = 1;
 442                         $nofipscanistercheck = 1;
 443                         }
 444                 elsif (/^[-+]/)
 445                         {
 446                         if (/^--prefix=(.*)$/)
 447                                 {
 448                                 $prefix=$1;
 449                                 }
 450                         elsif (/^--libdir=(.*)$/)
 451                                 {
 452                                 $libdir=$1;
 453                                 }
 454                         elsif (/^--openssldir=(.*)$/)
 455                                 {
 456                                 $openssldir=$1;
 457                                 }
 458                         elsif (/^--install.prefix=(.*)$/)
 459                                 {
 460                                 $install_prefix=$1;
 461                                 }
 462                         elsif (/^--with-krb5-(dir|lib|include|flavor)=(.*)$/)
 463                                 {
 464                                 $withargs{"krb5-".$1}=$2;
 465                                 }
 466                         elsif (/^--with-zlib-lib=(.*)$/)
 467                                 {
 468                                 $withargs{"zlib-lib"}=$1;
 469                                 }
 470                         elsif (/^--with-zlib-include=(.*)$/)
 471                                 {
 472                                 $withargs{"zlib-include"}="-I$1";
 473                                 }
 474                         elsif (/^--with-fipslibdir=(.*)$/)
 475                                 {
 476                                 $fipslibdir="$1/";
 477                                 }
 478                         elsif (/^--with-baseaddr=(.*)$/)
 479                                 {
 480                                 $baseaddr="$1";
 481                                 }
 482                         elsif (/^--cross-compile-prefix=(.*)$/)
 483                                 {
 484                                 $cross_compile_prefix=$1;
 485                                 }
 486                         elsif (/^--config=(.*)$/)
 487                                 {
 488                                 read_config $1;
 489                                 }
 490                         elsif (/^-[lL](.*)$/ or /^-Wl,/)
 491                                 {
 492                                 $libs.=$_." ";
 493                                 }
 494                         else    # common if (/^[-+]/), just pass down...
 495                                 {
 496                                 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
 497                                 $flags.=$_." ";
 498                                 }
 499                         }
 500                 elsif ($_ =~ /^([^:]+):(.+)$/)
 501                         {
 502                         eval "\$table{\$1} = \"$2\""; # allow $xxx constructs in the string
 503                         $target=$1;
 504                         }
 505                 else
 506                         {
 507                         die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
 508                         $target=$_;
 509                         }
 510
 511                 unless ($_ eq $target || /^no-/ || /^disable-/)
 512                         {
 513                         # "no-..." follows later after implied disactivations
 514                         # have been derived.  (Don't take this too seroiusly,
 515                         # we really only write OPTIONS to the Makefile out of
 516                         # nostalgia.)
 517
 518                         if ($options eq "")
 519                                 { $options = $_; }
 520                         else
 521                                 { $options .= " ".$_; }
 522                         }
 523                 }
 524         }
 525
 526
 527
 528 if ($processor eq "386")
 529         {
 530         $disabled{"sse2"} = "forced";
 531         }
 532
 533 if (!defined($withargs{"krb5-flavor"}) || $withargs{"krb5-flavor"} eq "")
 534         {
 535         $disabled{"krb5"} = "krb5-flavor not specified";
 536         }
 537
 538 if (!defined($disabled{"zlib-dynamic"}))
 539         {
 540         # "zlib-dynamic" was specifically enabled, so enable "zlib"
 541         delete $disabled{"zlib"};
 542         }
 543
 544 if (defined($disabled{"rijndael"}))
 545         {
 546         $disabled{"aes"} = "forced";
 547         }
 548 if (defined($disabled{"des"}))
 549         {
 550         $disabled{"mdc2"} = "forced";
 551         }
 552 if (defined($disabled{"ec"}))
 553         {
 554         $disabled{"ecdsa"} = "forced";
 555         $disabled{"ecdh"} = "forced";
 556         }
 557
 558 # SSL 3.0 and TLS requires MD5 and SHA and either RSA or DSA+DH
 559 if (defined($disabled{"md5"}) || defined($disabled{"sha"})
 560     || (defined($disabled{"rsa"})
 561         && (defined($disabled{"dsa"}) || defined($disabled{"dh"}))))
 562         {
 563         $disabled{"ssl3"} = "forced";
 564         $disabled{"tls1"} = "forced";
 565         }
 566
 567 if (defined($disabled{"tls1"}))
 568         {
 569         $disabled{"tlsext"} = "forced";
 570         }
 571
 572 if (defined($disabled{"ec"}) || defined($disabled{"dsa"})
 573     || defined($disabled{"dh"}))
 574         {
 575         $disabled{"gost"} = "forced";
 576         }
 577
 578 # SRP and HEARTBEATS require TLSEXT
 579 if (defined($disabled{"tlsext"}))
 580         {
 581         $disabled{"srp"} = "forced";
 582         $disabled{"heartbeats"} = "forced";
 583         }
 584
 585 if ($target eq "TABLE") {
 586         foreach $target (sort keys %table) {
 587                 print_table_entry($target);
 588         }
 589         exit 0;
 590 }
 591
 592 if ($target eq "LIST") {
 593         foreach (sort keys %table) {
 594                 print;
 595                 print "\n";
 596         }
 597         exit 0;
 598 }
 599
 600 if ($target =~ m/^CygWin32(-.*)$/) {
 601         $target = "Cygwin".$1;
 602 }
 603
 604 print "Configuring for $target\n";
 605
 606 &usage if (!defined($table{$target}));
 607
 608 if ($fips)
 609         {
 610         delete $disabled{"shared"} if ($disabled{"shared"} eq "default");
 611         }
 612
 613 foreach (sort (keys %disabled))
 614         {
 615         $options .= " no-$_";
 616
 617         printf "    no-%-12s %-10s", $_, "[$disabled{$_}]";
 618
 619         if (/^dso$/)
 620                 { $no_dso = 1; }
 621         elsif (/^threads$/)
 622                 { $no_threads = 1; }
 623         elsif (/^shared$/)
 624                 { $no_shared = 1; }
 625         elsif (/^zlib$/)
 626                 { $zlib = 0; }
 627         elsif (/^static-engine$/)
 628                 { }
 629         elsif (/^zlib-dynamic$/)
 630                 { }
 631         elsif (/^symlinks$/)
 632                 { $symlink = 0; }
 633         elsif (/^sse2$/)
 634                 { $no_sse2 = 1; }
 635         else
 636                 {
 637                 my ($ALGO, $algo);
 638                 ($ALGO = $algo = $_) =~ tr/[\-a-z]/[_A-Z]/;
 639
 640                 if (/^asm$/ || /^err$/ || /^hw$/ || /^hw-/)
 641                         {
 642                         $openssl_other_defines .= "#define OPENSSL_NO_$ALGO\n";
 643                         print " OPENSSL_NO_$ALGO";
 644
 645                         if (/^err$/)    { $flags .= "-DOPENSSL_NO_ERR "; }
 646                         elsif (/^asm$/) { $no_asm = 1; }
 647                         }
 648                 else
 649                         {
 650                         ($ALGO,$algo) = ("RMD160","rmd160") if ($algo eq "ripemd");
 651
 652                         $openssl_algorithm_defines .= "#define OPENSSL_NO_$ALGO\n";
 653                         print " OPENSSL_NO_$ALGO";
 654
 655                         if (/^krb5$/)
 656                                 { $no_krb5 = 1; }
 657                         else
 658                                 {
 659                                 push @skip, $algo;
 660                                 # fix-up crypto/directory name(s)
 661                                 $skip[$#skip]="whrlpool" if $algo eq "whirlpool";
 662                                 $skip[$#skip]="ripemd" if $algo eq "rmd160";
 663
 664                                 print " (skip dir)";
 665
 666                                 $depflags .= " -DOPENSSL_NO_$ALGO";
 667                                 }
 668                         }
 669                 }
 670
 671         print "\n";
 672         }
 673
 674 my $exp_cflags = "";
 675
 676 foreach (sort @experimental)
 677         {
 678         my $ALGO;
 679         ($ALGO = $_) =~ tr/[a-z]/[A-Z]/;
 680
 681         # opensslconf.h will set OPENSSL_NO_... unless OPENSSL_EXPERIMENTAL_... is defined
 682         $openssl_experimental_defines .= "#define OPENSSL_NO_$ALGO\n";
 683         $exp_cflags .= " -DOPENSSL_EXPERIMENTAL_$ALGO";
 684         }
 685
 686 my $IsMK1MF=scalar grep /^$target$/,@MK1MF_Builds;
 687
 688 $exe_ext=".exe" if ($target eq "Cygwin" || $target eq "DJGPP" || $target =~ /^mingw/);
 689 $exe_ext=".nlm" if ($target =~ /netware/);
 690 $exe_ext=".pm"  if ($target =~ /vos/);
 691 $openssldir="/usr/local/ssl" if ($openssldir eq "" and $prefix eq "");
 692 $prefix=$openssldir if $prefix eq "";
 693
 694 $default_ranlib= &which("ranlib") or $default_ranlib="true";
 695 $perl=$ENV{'PERL'} or $perl=&which("perl5") or $perl=&which("perl")
 696   or $perl="perl";
 697 my $make = $ENV{'MAKE'} || "make";
 698
 699 $cross_compile_prefix=$ENV{'CROSS_COMPILE'} if $cross_compile_prefix eq "";
 700
 701 chop $openssldir if $openssldir =~ /\/$/;
 702 chop $prefix if $prefix =~ /.\/$/;
 703
 704 $openssldir=$prefix . "/ssl" if $openssldir eq "";
 705 $openssldir=$prefix . "/" . $openssldir if $openssldir !~ /(^\/|^[a-zA-Z]:[\\\/])/;
 706
 707
 708 print "IsMK1MF=$IsMK1MF\n";
 709
 710 my @fields = split(/\s*:\s*/,$table{$target} . ":" x 30 , -1);
 711 my $cc = $fields[$idx_cc];
 712 # Allow environment CC to override compiler...
 713 if($ENV{CC}) {
 714     $cc = $ENV{CC};
 715 }
 716 my $cflags = $fields[$idx_cflags];
 717 my $unistd = $fields[$idx_unistd];
 718 my $thread_cflag = $fields[$idx_thread_cflag];
 719 my $sys_id = $fields[$idx_sys_id];
 720 my $lflags = $fields[$idx_lflags];
 721 my $bn_ops = $fields[$idx_bn_ops];
 722 my $cpuid_obj = $fields[$idx_cpuid_obj];
 723 my $bn_obj = $fields[$idx_bn_obj];
 724 my $ec_obj = $fields[$idx_ec_obj];
 725 my $des_obj = $fields[$idx_des_obj];
 726 my $aes_obj = $fields[$idx_aes_obj];
 727 my $bf_obj = $fields[$idx_bf_obj];
 728 my $md5_obj = $fields[$idx_md5_obj];
 729 my $sha1_obj = $fields[$idx_sha1_obj];
 730 my $cast_obj = $fields[$idx_cast_obj];
 731 my $rc4_obj = $fields[$idx_rc4_obj];
 732 my $rmd160_obj = $fields[$idx_rmd160_obj];
 733 my $rc5_obj = $fields[$idx_rc5_obj];
 734 my $wp_obj = $fields[$idx_wp_obj];
 735 my $cmll_obj = $fields[$idx_cmll_obj];
 736 my $modes_obj = $fields[$idx_modes_obj];
 737 my $engines_obj = $fields[$idx_engines_obj];
 738 my $perlasm_scheme = $fields[$idx_perlasm_scheme];
 739 my $dso_scheme = $fields[$idx_dso_scheme];
 740 my $shared_target = $fields[$idx_shared_target];
 741 my $shared_cflag = $fields[$idx_shared_cflag];
 742 my $shared_ldflag = $fields[$idx_shared_ldflag];
 743 my $shared_extension = $fields[$idx_shared_extension];
 744 my $ranlib = $ENV{'RANLIB'} || $fields[$idx_ranlib];
 745 my $ar = $ENV{'AR'} || "ar";
 746 my $arflags = $fields[$idx_arflags];
 747 my $multilib = $fields[$idx_multilib];
 748
 749 # if $prefix/lib$multilib is not an existing directory, then
 750 # assume that it's not searched by linker automatically, in
 751 # which case adding $multilib suffix causes more grief than
 752 # we're ready to tolerate, so don't...
 753 $multilib="" if !-d "$prefix/lib$multilib";
 754
 755 $libdir="lib$multilib" if $libdir eq "";
 756
 757 $cflags = "$cflags$exp_cflags";
 758
 759 # '%' in $lflags is used to split flags to "pre-" and post-flags
 760 my ($prelflags,$postlflags)=split('%',$lflags);
 761 if (defined($postlflags))       { $lflags=$postlflags;  }
 762 else                            { $lflags=$prelflags; undef $prelflags; }
 763
 764 if ($target =~ /^mingw/ && `$cc --target-help 2>&1` !~ m/\-mno\-cygwin/m)
 765         {
 766         $cflags =~ s/\-mno\-cygwin\s*//;
 767         $shared_ldflag =~ s/\-mno\-cygwin\s*//;
 768         }
 769
 770 if ($target =~ /linux.*\-mips/ && !$no_asm && $flags !~ /\-m(ips|arch=)/) {
 771         # minimally required architecture flags for assembly modules
 772         $cflags="-mips2 $cflags" if ($target =~ /mips32/);
 773         $cflags="-mips3 $cflags" if ($target =~ /mips64/);
 774 }
 775
 776 my $no_shared_warn=0;
 777 my $no_user_cflags=0;
 778
 779 if ($flags ne "")       { $cflags="$flags$cflags"; }
 780 else                    { $no_user_cflags=1;       }
 781
 782 # Kerberos settings.  The flavor must be provided from outside, either through
 783 # the script "config" or manually.
 784 if (!$no_krb5)
 785         {
 786         my ($lresolv, $lpath, $lext);
 787         if ($withargs{"krb5-flavor"} =~ /^[Hh]eimdal$/)
 788                 {
 789                 die "Sorry, Heimdal is currently not supported\n";
 790                 }
 791         ##### HACK to force use of Heimdal.
 792         ##### WARNING: Since we don't really have adequate support for Heimdal,
 793         #####          using this will break the build.  You'll have to make
 794         #####          changes to the source, and if you do, please send
 795         #####          patches to openssl-dev@openssl.org
 796         if ($withargs{"krb5-flavor"} =~ /^force-[Hh]eimdal$/)
 797                 {
 798                 warn "Heimdal isn't really supported.  Your build WILL break\n";
 799                 warn "If you fix the problems, please send a patch to openssl-dev\@openssl.org\n";
 800                 $withargs{"krb5-dir"} = "/usr/heimdal"
 801                         if $withargs{"krb5-dir"} eq "";
 802                 $withargs{"krb5-lib"} = "-L".$withargs{"krb5-dir"}.
 803                         "/lib -lgssapi -lkrb5 -lcom_err"
 804                         if $withargs{"krb5-lib"} eq "" && !$IsMK1MF;
 805                 $cflags="-DKRB5_HEIMDAL $cflags";
 806                 }
 807         if ($withargs{"krb5-flavor"} =~ /^[Mm][Ii][Tt]/)
 808                 {
 809                 $withargs{"krb5-dir"} = "/usr/kerberos"
 810                         if $withargs{"krb5-dir"} eq "";
 811                 $withargs{"krb5-lib"} = "-L".$withargs{"krb5-dir"}.
 812                         "/lib -lgssapi_krb5 -lkrb5 -lcom_err -lk5crypto"
 813                         if $withargs{"krb5-lib"} eq "" && !$IsMK1MF;
 814                 $cflags="-DKRB5_MIT $cflags";
 815                 $withargs{"krb5-flavor"} =~ s/^[Mm][Ii][Tt][._-]*//;
 816                 if ($withargs{"krb5-flavor"} =~ /^1[._-]*[01]/)
 817                         {
 818                         $cflags="-DKRB5_MIT_OLD11 $cflags";
 819                         }
 820                 }
 821         LRESOLV:
 822         foreach $lpath ("/lib", "/usr/lib")
 823                 {
 824                 foreach $lext ("a", "so")
 825                         {
 826                         $lresolv = "$lpath/libresolv.$lext";
 827                         last LRESOLV    if (-r "$lresolv");
 828                         $lresolv = "";
 829                         }
 830                 }
 831         $withargs{"krb5-lib"} .= " -lresolv"
 832                 if ("$lresolv" ne "");
 833         $withargs{"krb5-include"} = "-I".$withargs{"krb5-dir"}."/include"
 834                 if $withargs{"krb5-include"} eq "" &&
 835                    $withargs{"krb5-dir"} ne "";
 836         }
 837
 838 # The DSO code currently always implements all functions so that no
 839 # applications will have to worry about that from a compilation point
 840 # of view. However, the "method"s may return zero unless that platform
 841 # has support compiled in for them. Currently each method is enabled
 842 # by a define "DSO_<name>" ... we translate the "dso_scheme" config
 843 # string entry into using the following logic;
 844 my $dso_cflags;
 845 if (!$no_dso && $dso_scheme ne "")
 846         {
 847         $dso_scheme =~ tr/[a-z]/[A-Z]/;
 848         if ($dso_scheme eq "DLFCN")
 849                 {
 850                 $dso_cflags = "-DDSO_DLFCN -DHAVE_DLFCN_H";
 851                 }
 852         elsif ($dso_scheme eq "DLFCN_NO_H")
 853                 {
 854                 $dso_cflags = "-DDSO_DLFCN";
 855                 }
 856         else
 857                 {
 858                 $dso_cflags = "-DDSO_$dso_scheme";
 859                 }
 860         $cflags = "$dso_cflags $cflags";
 861         }
 862
 863 my $thread_cflags;
 864 my $thread_defines;
 865 if ($thread_cflag ne "(unknown)" && !$no_threads)
 866         {
 867         # If we know how to do it, support threads by default.
 868         $threads = 1;
 869         }
 870 if ($thread_cflag eq "(unknown)" && $threads)
 871         {
 872         # If the user asked for "threads", [s]he is also expected to
 873         # provide any system-dependent compiler options that are
 874         # necessary.
 875         if ($no_user_cflags)
 876                 {
 877                 print "You asked for multi-threading support, but didn't\n";
 878                 print "provide any system-specific compiler options\n";
 879                 exit(1);
 880                 }
 881         $thread_cflags="-DOPENSSL_THREADS $cflags" ;
 882         $thread_defines .= "#define OPENSSL_THREADS\n";
 883         }
 884 else
 885         {
 886         $thread_cflags="-DOPENSSL_THREADS $thread_cflag $cflags";
 887         $thread_defines .= "#define OPENSSL_THREADS\n";
 888 #       my $def;
 889 #       foreach $def (split ' ',$thread_cflag)
 890 #               {
 891 #               if ($def =~ s/^-D// && $def !~ /^_/)
 892 #                       {
 893 #                       $thread_defines .= "#define $def\n";
 894 #                       }
 895 #               }
 896         }
 897
 898 $lflags="$libs$lflags" if ($libs ne "");
 899
 900 if ($no_asm)
 901         {
 902         $cpuid_obj=$bn_obj=$ec_obj=
 903         $des_obj=$aes_obj=$bf_obj=$cast_obj=$rc4_obj=$rc5_obj=$cmll_obj=
 904         $modes_obj=$sha1_obj=$md5_obj=$rmd160_obj=$wp_obj=$engines_obj="";
 905         $cflags=~s/\-D[BL]_ENDIAN//             if ($fips);
 906         $thread_cflags=~s/\-D[BL]_ENDIAN//      if ($fips);
 907         }
 908 elsif (defined($disabled{ec2m}))
 909         {
 910         $bn_obj =~ s/\w+-gf2m.o//;
 911         }
 912
 913 if (!$no_shared)
 914         {
 915         $cast_obj="";   # CAST assembler is not PIC
 916         }
 917
 918 if ($threads)
 919         {
 920         $cflags=$thread_cflags;
 921         $openssl_thread_defines .= $thread_defines;
 922         }
 923
 924 if ($zlib)
 925         {
 926         $cflags = "-DZLIB $cflags";
 927         if (defined($disabled{"zlib-dynamic"}))
 928                 {
 929                 if (defined($withargs{"zlib-lib"}))
 930                         {
 931                         $lflags = "$lflags -L" . $withargs{"zlib-lib"} . " -lz";
 932                         }
 933                 else
 934                         {
 935                         $lflags = "$lflags -lz";
 936                         }
 937                 }
 938         else
 939                 {
 940                 $cflags = "-DZLIB_SHARED $cflags";
 941                 }
 942         }
 943
 944 #Build the library with OPENSSL_USE_DEPRECATED if deprecation is not disabled
 945 if(!defined($disabled{"deprecated"}))
 946         {
 947         $cflags = "-DOPENSSL_USE_DEPRECATED $cflags";
 948         }
 949
 950 # You will find shlib_mark1 and shlib_mark2 explained in Makefile.org
 951 my $shared_mark = "";
 952 if ($shared_target eq "")
 953         {
 954         $no_shared_warn = 1 if !$no_shared && !$fips;
 955         $no_shared = 1;
 956         }
 957 if (!$no_shared)
 958         {
 959         if ($shared_cflag ne "")
 960                 {
 961                 $cflags = "$shared_cflag -DOPENSSL_PIC $cflags";
 962                 }
 963         }
 964
 965 if (!$IsMK1MF)
 966         {
 967         # add {no-}static-engine to options to allow mkdef.pl to work without extra arguments
 968         if ($no_shared)
 969                 {
 970                 $openssl_other_defines.="#define OPENSSL_NO_DYNAMIC_ENGINE\n";
 971                 $options.=" static-engine";
 972                 }
 973         else
 974                 {
 975                 $openssl_other_defines.="#define OPENSSL_NO_STATIC_ENGINE\n";
 976                 $options.=" no-static-engine";
 977                 }
 978         }
 979
 980 $cpuid_obj.=" uplink.o uplink-x86.o" if ($cflags =~ /\-DOPENSSL_USE_APPLINK/);
 981
 982 #
 983 # Platform fix-ups
 984 #
 985 if ($target =~ /\-icc$/)        # Intel C compiler
 986         {
 987         my $iccver=0;
 988         if (open(FD,"$cc -V 2>&1 |"))
 989                 {
 990                 while(<FD>) { $iccver=$1 if (/Version ([0-9]+)\./); }
 991                 close(FD);
 992                 }
 993         if ($iccver>=8)
 994                 {
 995                 $cflags=~s/\-KPIC/-fPIC/;
 996                 # Eliminate unnecessary dependency from libirc.a. This is
 997                 # essential for shared library support, as otherwise
 998                 # apps/openssl can end up in endless loop upon startup...
 999                 $cflags.=" -Dmemcpy=__builtin_memcpy -Dmemset=__builtin_memset";
1000                 }
1001         if ($iccver>=9)
1002                 {
1003                 $lflags.=" -i-static";
1004                 $lflags=~s/\-no_cpprt/-no-cpprt/;
1005                 }
1006         if ($iccver>=10)
1007                 {
1008                 $lflags=~s/\-i\-static/-static-intel/;
1009                 }
1010         if ($iccver>=11)
1011                 {
1012                 $cflags.=" -no-intel-extensions";       # disable Cilk
1013                 $lflags=~s/\-no\-cpprt/-no-cxxlib/;
1014                 }
1015         }
1016
1017 # Unlike other OSes (like Solaris, Linux, Tru64, IRIX) BSD run-time
1018 # linkers (tested OpenBSD, NetBSD and FreeBSD) "demand" RPATH set on
1019 # .so objects. Apparently application RPATH is not global and does
1020 # not apply to .so linked with other .so. Problem manifests itself
1021 # when libssl.so fails to load libcrypto.so. One can argue that we
1022 # should engrave this into Makefile.shared rules or into BSD-* config
1023 # lines above. Meanwhile let's try to be cautious and pass -rpath to
1024 # linker only when --prefix is not /usr.
1025 if ($target =~ /^BSD\-/)
1026         {
1027         $shared_ldflag.=" -Wl,-rpath,\$(LIBRPATH)" if ($prefix !~ m|^/usr[/]*$|);
1028         }
1029
1030 if ($sys_id ne "")
1031         {
1032         #$cflags="-DOPENSSL_SYS_$sys_id $cflags";
1033         $openssl_sys_defines="#define OPENSSL_SYS_$sys_id\n";
1034         }
1035
1036 if ($ranlib eq "")
1037         {
1038         $ranlib = $default_ranlib;
1039         }
1040
1041 #my ($bn1)=split(/\s+/,$bn_obj);
1042 #$bn1 = "" unless defined $bn1;
1043 #$bn1=$bn_asm unless ($bn1 =~ /\.o$/);
1044 #$bn_obj="$bn1";
1045
1046 $cpuid_obj="" if ($processor eq "386");
1047
1048 $bn_obj = $bn_asm unless $bn_obj ne "";
1049 # bn-586 is the only one implementing bn_*_part_words
1050 $cflags.=" -DOPENSSL_BN_ASM_PART_WORDS" if ($bn_obj =~ /bn-586/);
1051 $cflags.=" -DOPENSSL_IA32_SSE2" if (!$no_sse2 && $bn_obj =~ /86/);
1052
1053 $cflags.=" -DOPENSSL_BN_ASM_MONT" if ($bn_obj =~ /-mont/);
1054 $cflags.=" -DOPENSSL_BN_ASM_MONT5" if ($bn_obj =~ /-mont5/);
1055 $cflags.=" -DOPENSSL_BN_ASM_GF2m" if ($bn_obj =~ /-gf2m/);
1056
1057 if ($fips)
1058         {
1059         $openssl_other_defines.="#define OPENSSL_FIPS\n";
1060         }
1061
1062 $cpuid_obj="mem_clr.o"  unless ($cpuid_obj =~ /\.o$/);
1063 $des_obj=$des_enc       unless ($des_obj =~ /\.o$/);
1064 $bf_obj=$bf_enc         unless ($bf_obj =~ /\.o$/);
1065 $cast_obj=$cast_enc     unless ($cast_obj =~ /\.o$/);
1066 $rc4_obj=$rc4_enc       unless ($rc4_obj =~ /\.o$/);
1067 $rc5_obj=$rc5_enc       unless ($rc5_obj =~ /\.o$/);
1068 if ($sha1_obj =~ /\.o$/)
1069         {
1070 #       $sha1_obj=$sha1_enc;
1071         $cflags.=" -DSHA1_ASM"   if ($sha1_obj =~ /sx86/ || $sha1_obj =~ /sha1/);
1072         $cflags.=" -DSHA256_ASM" if ($sha1_obj =~ /sha256/);
1073         $cflags.=" -DSHA512_ASM" if ($sha1_obj =~ /sha512/);
1074         if ($sha1_obj =~ /sse2/)
1075             {   if ($no_sse2)
1076                 {   $sha1_obj =~ s/\S*sse2\S+//;        }
1077                 elsif ($cflags !~ /OPENSSL_IA32_SSE2/)
1078                 {   $cflags.=" -DOPENSSL_IA32_SSE2";    }
1079             }
1080         }
1081 if ($md5_obj =~ /\.o$/)
1082         {
1083 #       $md5_obj=$md5_enc;
1084         $cflags.=" -DMD5_ASM";
1085         }
1086 if ($rmd160_obj =~ /\.o$/)
1087         {
1088 #       $rmd160_obj=$rmd160_enc;
1089         $cflags.=" -DRMD160_ASM";
1090         }
1091 if ($aes_obj =~ /\.o$/)
1092         {
1093         $cflags.=" -DAES_ASM" if ($aes_obj =~ m/\baes\-/);;
1094         # aes-ctr.o is not a real file, only indication that assembler
1095         # module implements AES_ctr32_encrypt...
1096         $cflags.=" -DAES_CTR_ASM" if ($aes_obj =~ s/\s*aes\-ctr\.o//);
1097         # aes-xts.o indicates presence of AES_xts_[en|de]crypt...
1098         $cflags.=" -DAES_XTS_ASM" if ($aes_obj =~ s/\s*aes\-xts\.o//);
1099         $aes_obj =~ s/\s*(vpaes|aesni)\-x86\.o//g if ($no_sse2);
1100         $cflags.=" -DVPAES_ASM" if ($aes_obj =~ m/vpaes/);
1101         $cflags.=" -DBSAES_ASM" if ($aes_obj =~ m/bsaes/);
1102         }
1103 else    {
1104         $aes_obj=$aes_enc;
1105         }
1106 $wp_obj="" if ($wp_obj =~ /mmx/ && $processor eq "386");
1107 if ($wp_obj =~ /\.o$/ && !$disabled{"whirlpool"})
1108         {
1109         $cflags.=" -DWHIRLPOOL_ASM";
1110         }
1111 else    {
1112         $wp_obj="wp_block.o";
1113         }
1114 $cmll_obj=$cmll_enc     unless ($cmll_obj =~ /.o$/);
1115 if ($modes_obj =~ /ghash\-/)
1116         {
1117         $cflags.=" -DGHASH_ASM";
1118         }
1119 if ($ec_obj =~ /ecp_nistz256/)
1120         {
1121         $cflags.=" -DECP_NISTZ256_ASM";
1122         }
1123
1124 # "Stringify" the C flags string.  This permits it to be made part of a string
1125 # and works as well on command lines.
1126 $cflags =~ s/([\\\"])/\\\1/g;
1127
1128 my $version = "unknown";
1129 my $version_num = "unknown";
1130 my $major = "unknown";
1131 my $minor = "unknown";
1132 my $shlib_version_number = "unknown";
1133 my $shlib_version_history = "unknown";
1134 my $shlib_major = "unknown";
1135 my $shlib_minor = "unknown";
1136
1137 open(IN,'<crypto/opensslv.h') || die "unable to read opensslv.h:$!\n";
1138 while (<IN>)
1139         {
1140         $version=$1 if /OPENSSL.VERSION.TEXT.*OpenSSL (\S+) /;
1141         $version_num=$1 if /OPENSSL.VERSION.NUMBER.*0x(\S+)/;
1142         $shlib_version_number=$1 if /SHLIB_VERSION_NUMBER *"([^"]+)"/;
1143         $shlib_version_history=$1 if /SHLIB_VERSION_HISTORY *"([^"]*)"/;
1144         }
1145 close(IN);
1146 if ($shlib_version_history ne "") { $shlib_version_history .= ":"; }
1147
1148 if ($version =~ /(^[0-9]*)\.([0-9\.]*)/)
1149         {
1150         $major=$1;
1151         $minor=$2;
1152         }
1153
1154 if ($shlib_version_number =~ /(^[0-9]*)\.([0-9\.]*)/)
1155         {
1156         $shlib_major=$1;
1157         $shlib_minor=$2;
1158         }
1159
1160 if ($strict_warnings)
1161         {
1162         my $wopt;
1163         die "ERROR --strict-warnings requires gcc or clang" unless ($cc =~ /gcc$/ or $cc =~ /clang$/);
1164         foreach $wopt (split /\s+/, $gcc_devteam_warn)
1165                 {
1166                 $cflags .= " $wopt" unless ($cflags =~ /$wopt/)
1167                 }
1168         }
1169
1170 open(IN,"<Makefile.org") || die "unable to read Makefile.org:$!\n";
1171 unlink("$Makefile.new") || die "unable to remove old $Makefile.new:$!\n" if -e "$Makefile.new";
1172 open(OUT,">$Makefile.new") || die "unable to create $Makefile.new:$!\n";
1173 print OUT "### Generated automatically from Makefile.org by Configure.\n\n";
1174 my $sdirs=0;
1175
1176 while (<IN>)
1177         {
1178         chomp;
1179         $sdirs = 1 if /^SDIRS=/;
1180         if ($sdirs) {
1181                 my $dir;
1182                 foreach $dir (@skip) {
1183                         s/(\s)$dir /$1/;
1184                         s/\s$dir$//;
1185                         }
1186                 }
1187         $sdirs = 0 unless /\\$/;
1188         s/fips // if (/^DIRS=/ && !$fips);
1189         s/engines // if (/^DIRS=/ && $disabled{"engine"});
1190         s/ccgost// if (/^ENGDIRS=/ && $disabled{"gost"});
1191         s/^VERSION=.*/VERSION=$version/;
1192         s/^MAJOR=.*/MAJOR=$major/;
1193         s/^MINOR=.*/MINOR=$minor/;
1194         s/^SHLIB_VERSION_NUMBER=.*/SHLIB_VERSION_NUMBER=$shlib_version_number/;
1195         s/^SHLIB_VERSION_HISTORY=.*/SHLIB_VERSION_HISTORY=$shlib_version_history/;
1196         s/^SHLIB_MAJOR=.*/SHLIB_MAJOR=$shlib_major/;
1197         s/^SHLIB_MINOR=.*/SHLIB_MINOR=$shlib_minor/;
1198         s/^SHLIB_EXT=.*/SHLIB_EXT=$shared_extension/;
1199         s/^INSTALLTOP=.*$/INSTALLTOP=$prefix/;
1200         s/^MULTILIB=.*$/MULTILIB=$multilib/;
1201         s/^OPENSSLDIR=.*$/OPENSSLDIR=$openssldir/;
1202         s/^LIBDIR=.*$/LIBDIR=$libdir/;
1203         s/^INSTALL_PREFIX=.*$/INSTALL_PREFIX=$install_prefix/;
1204         s/^PLATFORM=.*$/PLATFORM=$target/;
1205         s/^OPTIONS=.*$/OPTIONS=$options/;
1206         s/^CONFIGURE_ARGS=.*$/CONFIGURE_ARGS=$argvstring/;
1207         if ($cross_compile_prefix)
1208                 {
1209                 s/^CC=.*$/CROSS_COMPILE= $cross_compile_prefix\nCC= \$\(CROSS_COMPILE\)$cc/;
1210                 s/^AR=\s*/AR= \$\(CROSS_COMPILE\)/;
1211                 s/^NM=\s*/NM= \$\(CROSS_COMPILE\)/;
1212                 s/^RANLIB=\s*/RANLIB= \$\(CROSS_COMPILE\)/;
1213                 s/^MAKEDEPPROG=.*$/MAKEDEPPROG= \$\(CROSS_COMPILE\)$cc/ if $cc eq "gcc";
1214                 }
1215         else    {
1216                 s/^CC=.*$/CC= $cc/;
1217                 s/^AR=\s*ar/AR= $ar/;
1218                 s/^RANLIB=.*/RANLIB= $ranlib/;
1219                 s/^MAKEDEPPROG=.*$/MAKEDEPPROG= $cc/ if $cc eq "gcc" || ($cc eq 'cc' && $target =~ /darwin/);
1220                 }
1221         s/^CFLAG=.*$/CFLAG= $cflags/;
1222         s/^DEPFLAG=.*$/DEPFLAG=$depflags/;
1223         s/^PEX_LIBS=.*$/PEX_LIBS= $prelflags/;
1224         s/^EX_LIBS=.*$/EX_LIBS= $lflags/;
1225         s/^EXE_EXT=.*$/EXE_EXT= $exe_ext/;
1226         s/^CPUID_OBJ=.*$/CPUID_OBJ= $cpuid_obj/;
1227         s/^BN_ASM=.*$/BN_ASM= $bn_obj/;
1228         s/^EC_ASM=.*$/EC_ASM= $ec_obj/;
1229         s/^DES_ENC=.*$/DES_ENC= $des_obj/;
1230         s/^AES_ENC=.*$/AES_ENC= $aes_obj/;
1231         s/^BF_ENC=.*$/BF_ENC= $bf_obj/;
1232         s/^CAST_ENC=.*$/CAST_ENC= $cast_obj/;
1233         s/^RC4_ENC=.*$/RC4_ENC= $rc4_obj/;
1234         s/^RC5_ENC=.*$/RC5_ENC= $rc5_obj/;
1235         s/^MD5_ASM_OBJ=.*$/MD5_ASM_OBJ= $md5_obj/;
1236         s/^SHA1_ASM_OBJ=.*$/SHA1_ASM_OBJ= $sha1_obj/;
1237         s/^RMD160_ASM_OBJ=.*$/RMD160_ASM_OBJ= $rmd160_obj/;
1238         s/^WP_ASM_OBJ=.*$/WP_ASM_OBJ= $wp_obj/;
1239         s/^CMLL_ENC=.*$/CMLL_ENC= $cmll_obj/;
1240         s/^MODES_ASM_OBJ.=*$/MODES_ASM_OBJ= $modes_obj/;
1241         s/^ENGINES_ASM_OBJ.=*$/ENGINES_ASM_OBJ= $engines_obj/;
1242         s/^PERLASM_SCHEME=.*$/PERLASM_SCHEME= $perlasm_scheme/;
1243         s/^PROCESSOR=.*/PROCESSOR= $processor/;
1244         s/^ARFLAGS=.*/ARFLAGS= $arflags/;
1245         s/^PERL=.*/PERL= $perl/;
1246         s/^KRB5_INCLUDES=.*/KRB5_INCLUDES=$withargs{"krb5-include"}/;
1247         s/^LIBKRB5=.*/LIBKRB5=$withargs{"krb5-lib"}/;
1248         s/^LIBZLIB=.*/LIBZLIB=$withargs{"zlib-lib"}/;
1249         s/^ZLIB_INCLUDE=.*/ZLIB_INCLUDE=$withargs{"zlib-include"}/;
1250         s/^FIPSLIBDIR=.*/FIPSLIBDIR=$fipslibdir/;
1251         s/^FIPSCANLIB=.*/FIPSCANLIB=libcrypto/ if $fips;
1252         s/^SHARED_FIPS=.*/SHARED_FIPS=/;
1253         s/^SHLIBDIRS=.*/SHLIBDIRS= crypto ssl/;
1254         s/^BASEADDR=.*/BASEADDR=$baseaddr/;
1255         s/^SHLIB_TARGET=.*/SHLIB_TARGET=$shared_target/;
1256         s/^SHLIB_MARK=.*/SHLIB_MARK=$shared_mark/;
1257         s/^SHARED_LIBS=.*/SHARED_LIBS=\$(SHARED_CRYPTO) \$(SHARED_SSL)/ if (!$no_shared);
1258         if ($shared_extension ne "" && $shared_extension =~ /^\.s([ol])\.[^\.]*$/)
1259                 {
1260                 my $sotmp = $1;
1261                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.s$sotmp/;
1262                 }
1263         elsif ($shared_extension ne "" && $shared_extension =~ /^\.[^\.]*\.dylib$/)
1264                 {
1265                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.dylib/;
1266                 }
1267         elsif ($shared_extension ne "" && $shared_extension =~ /^\.s([ol])\.[^\.]*\.[^\.]*$/)
1268                 {
1269                 my $sotmp = $1;
1270                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.s$sotmp.\$(SHLIB_MAJOR) .s$sotmp/;
1271                 }
1272         elsif ($shared_extension ne "" && $shared_extension =~ /^\.[^\.]*\.[^\.]*\.dylib$/)
1273                 {
1274                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.\$(SHLIB_MAJOR).dylib .dylib/;
1275                 }
1276         s/^SHARED_LDFLAGS=.*/SHARED_LDFLAGS=$shared_ldflag/;
1277         print OUT $_."\n";
1278         }
1279 close(IN);
1280 close(OUT);
1281 rename($Makefile,"$Makefile.bak") || die "unable to rename $Makefile\n" if -e $Makefile;
1282 rename("$Makefile.new",$Makefile) || die "unable to rename $Makefile.new\n";
1283
1284 print "CC            =$cc\n";
1285 print "CFLAG         =$cflags\n";
1286 print "EX_LIBS       =$lflags\n";
1287 print "CPUID_OBJ     =$cpuid_obj\n";
1288 print "BN_ASM        =$bn_obj\n";
1289 print "EC_ASM        =$ec_obj\n";
1290 print "DES_ENC       =$des_obj\n";
1291 print "AES_ENC       =$aes_obj\n";
1292 print "BF_ENC        =$bf_obj\n";
1293 print "CAST_ENC      =$cast_obj\n";
1294 print "RC4_ENC       =$rc4_obj\n";
1295 print "RC5_ENC       =$rc5_obj\n";
1296 print "MD5_OBJ_ASM   =$md5_obj\n";
1297 print "SHA1_OBJ_ASM  =$sha1_obj\n";
1298 print "RMD160_OBJ_ASM=$rmd160_obj\n";
1299 print "CMLL_ENC      =$cmll_obj\n";
1300 print "MODES_OBJ     =$modes_obj\n";
1301 print "ENGINES_OBJ   =$engines_obj\n";
1302 print "PROCESSOR     =$processor\n";
1303 print "RANLIB        =$ranlib\n";
1304 print "ARFLAGS       =$arflags\n";
1305 print "PERL          =$perl\n";
1306 print "KRB5_INCLUDES =",$withargs{"krb5-include"},"\n"
1307         if $withargs{"krb5-include"} ne "";
1308
1309 my $des_ptr=0;
1310 my $des_risc1=0;
1311 my $des_risc2=0;
1312 my $des_unroll=0;
1313 my $bn_ll=0;
1314 my $def_int=2;
1315 my $rc4_int=$def_int;
1316 my $md2_int=$def_int;
1317 my $idea_int=$def_int;
1318 my $rc2_int=$def_int;
1319 my $rc4_idx=0;
1320 my $rc4_chunk=0;
1321 my $bf_ptr=0;
1322 my @type=("char","short","int","long");
1323 my ($b64l,$b64,$b32,$b16,$b8)=(0,0,1,0,0);
1324 my $export_var_as_fn=0;
1325
1326 my $des_int;
1327
1328 foreach (sort split(/\s+/,$bn_ops))
1329         {
1330         $des_ptr=1 if /DES_PTR/;
1331         $des_risc1=1 if /DES_RISC1/;
1332         $des_risc2=1 if /DES_RISC2/;
1333         $des_unroll=1 if /DES_UNROLL/;
1334         $des_int=1 if /DES_INT/;
1335         $bn_ll=1 if /BN_LLONG/;
1336         $rc4_int=0 if /RC4_CHAR/;
1337         $rc4_int=3 if /RC4_LONG/;
1338         $rc4_idx=1 if /RC4_INDEX/;
1339         $rc4_chunk=1 if /RC4_CHUNK/;
1340         $rc4_chunk=2 if /RC4_CHUNK_LL/;
1341         $md2_int=0 if /MD2_CHAR/;
1342         $md2_int=3 if /MD2_LONG/;
1343         $idea_int=1 if /IDEA_SHORT/;
1344         $idea_int=3 if /IDEA_LONG/;
1345         $rc2_int=1 if /RC2_SHORT/;
1346         $rc2_int=3 if /RC2_LONG/;
1347         $bf_ptr=1 if $_ eq "BF_PTR";
1348         $bf_ptr=2 if $_ eq "BF_PTR2";
1349         ($b64l,$b64,$b32,$b16,$b8)=(0,1,0,0,0) if /SIXTY_FOUR_BIT/;
1350         ($b64l,$b64,$b32,$b16,$b8)=(1,0,0,0,0) if /SIXTY_FOUR_BIT_LONG/;
1351         ($b64l,$b64,$b32,$b16,$b8)=(0,0,1,0,0) if /THIRTY_TWO_BIT/;
1352         ($b64l,$b64,$b32,$b16,$b8)=(0,0,0,1,0) if /SIXTEEN_BIT/;
1353         ($b64l,$b64,$b32,$b16,$b8)=(0,0,0,0,1) if /EIGHT_BIT/;
1354         $export_var_as_fn=1 if /EXPORT_VAR_AS_FN/;
1355         }
1356
1357 open(IN,'<crypto/opensslconf.h.in') || die "unable to read crypto/opensslconf.h.in:$!\n";
1358 unlink("crypto/opensslconf.h.new") || die "unable to remove old crypto/opensslconf.h.new:$!\n" if -e "crypto/opensslconf.h.new";
1359 open(OUT,'>crypto/opensslconf.h.new') || die "unable to create crypto/opensslconf.h.new:$!\n";
1360 print OUT "/* opensslconf.h */\n";
1361 print OUT "/* WARNING: Generated automatically from opensslconf.h.in by Configure. */\n\n";
1362
1363 print OUT "#ifdef  __cplusplus\n";
1364 print OUT "extern \"C\" {\n";
1365 print OUT "#endif\n";
1366 print OUT "/* OpenSSL was configured with the following options: */\n";
1367 my $openssl_algorithm_defines_trans = $openssl_algorithm_defines;
1368 $openssl_experimental_defines =~ s/^\s*#\s*define\s+OPENSSL_NO_(.*)/#ifndef OPENSSL_EXPERIMENTAL_$1\n# ifndef OPENSSL_NO_$1\n#  define OPENSSL_NO_$1\n# endif\n#endif/mg;
1369 $openssl_algorithm_defines_trans =~ s/^\s*#\s*define\s+OPENSSL_(.*)/# if defined(OPENSSL_$1) \&\& !defined($1)\n#  define $1\n# endif/mg;
1370 $openssl_algorithm_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1371 $openssl_algorithm_defines = "   /* no ciphers excluded */\n" if $openssl_algorithm_defines eq "";
1372 $openssl_thread_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1373 $openssl_sys_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1374 $openssl_other_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1375 print OUT $openssl_sys_defines;
1376 print OUT "#ifndef OPENSSL_DOING_MAKEDEPEND\n\n";
1377 print OUT $openssl_experimental_defines;
1378 print OUT "\n";
1379 print OUT $openssl_algorithm_defines;
1380 print OUT "\n#endif /* OPENSSL_DOING_MAKEDEPEND */\n\n";
1381 print OUT $openssl_thread_defines;
1382 print OUT $openssl_other_defines,"\n";
1383
1384 print OUT "/* The OPENSSL_NO_* macros are also defined as NO_* if the application\n";
1385 print OUT "   asks for it.  This is a transient feature that is provided for those\n";
1386 print OUT "   who haven't had the time to do the appropriate changes in their\n";
1387 print OUT "   applications.  */\n";
1388 print OUT "#ifdef OPENSSL_ALGORITHM_DEFINES\n";
1389 print OUT $openssl_algorithm_defines_trans;
1390 print OUT "#endif\n\n";
1391
1392 print OUT "#define OPENSSL_CPUID_OBJ\n\n" if ($cpuid_obj ne "mem_clr.o");
1393
1394 while (<IN>)
1395         {
1396         if      (/^#define\s+OPENSSLDIR/)
1397                 {
1398                 my $foo = $openssldir;
1399                 $foo =~ s/\\/\\\\/g;
1400                 print OUT "#define OPENSSLDIR \"$foo\"\n";
1401                 }
1402         elsif   (/^#define\s+ENGINESDIR/)
1403                 {
1404                 my $foo = "$prefix/$libdir/engines";
1405                 $foo =~ s/\\/\\\\/g;
1406                 print OUT "#define ENGINESDIR \"$foo\"\n";
1407                 }
1408         elsif   (/^#((define)|(undef))\s+OPENSSL_EXPORT_VAR_AS_FUNCTION/)
1409                 { printf OUT "#undef OPENSSL_EXPORT_VAR_AS_FUNCTION\n"
1410                         if $export_var_as_fn;
1411                   printf OUT "#%s OPENSSL_EXPORT_VAR_AS_FUNCTION\n",
1412                         ($export_var_as_fn)?"define":"undef"; }
1413         elsif   (/^#define\s+OPENSSL_UNISTD/)
1414                 {
1415                 $unistd = "<unistd.h>" if $unistd eq "";
1416                 print OUT "#define OPENSSL_UNISTD $unistd\n";
1417                 }
1418         elsif   (/^#((define)|(undef))\s+SIXTY_FOUR_BIT_LONG/)
1419                 { printf OUT "#%s SIXTY_FOUR_BIT_LONG\n",($b64l)?"define":"undef"; }
1420         elsif   (/^#((define)|(undef))\s+SIXTY_FOUR_BIT/)
1421                 { printf OUT "#%s SIXTY_FOUR_BIT\n",($b64)?"define":"undef"; }
1422         elsif   (/^#((define)|(undef))\s+THIRTY_TWO_BIT/)
1423                 { printf OUT "#%s THIRTY_TWO_BIT\n",($b32)?"define":"undef"; }
1424         elsif   (/^#((define)|(undef))\s+SIXTEEN_BIT/)
1425                 { printf OUT "#%s SIXTEEN_BIT\n",($b16)?"define":"undef"; }
1426         elsif   (/^#((define)|(undef))\s+EIGHT_BIT/)
1427                 { printf OUT "#%s EIGHT_BIT\n",($b8)?"define":"undef"; }
1428         elsif   (/^#((define)|(undef))\s+BN_LLONG\s*$/)
1429                 { printf OUT "#%s BN_LLONG\n",($bn_ll)?"define":"undef"; }
1430         elsif   (/^\#define\s+DES_LONG\s+.*/)
1431                 { printf OUT "#define DES_LONG unsigned %s\n",
1432                         ($des_int)?'int':'long'; }
1433         elsif   (/^\#(define|undef)\s+DES_PTR/)
1434                 { printf OUT "#%s DES_PTR\n",($des_ptr)?'define':'undef'; }
1435         elsif   (/^\#(define|undef)\s+DES_RISC1/)
1436                 { printf OUT "#%s DES_RISC1\n",($des_risc1)?'define':'undef'; }
1437         elsif   (/^\#(define|undef)\s+DES_RISC2/)
1438                 { printf OUT "#%s DES_RISC2\n",($des_risc2)?'define':'undef'; }
1439         elsif   (/^\#(define|undef)\s+DES_UNROLL/)
1440                 { printf OUT "#%s DES_UNROLL\n",($des_unroll)?'define':'undef'; }
1441         elsif   (/^#define\s+RC4_INT\s/)
1442                 { printf OUT "#define RC4_INT unsigned %s\n",$type[$rc4_int]; }
1443         elsif   (/^#undef\s+RC4_CHUNK/)
1444                 {
1445                 printf OUT "#undef RC4_CHUNK\n" if $rc4_chunk==0;
1446                 printf OUT "#define RC4_CHUNK unsigned long\n" if $rc4_chunk==1;
1447                 printf OUT "#define RC4_CHUNK unsigned long long\n" if $rc4_chunk==2;
1448                 }
1449         elsif   (/^#((define)|(undef))\s+RC4_INDEX/)
1450                 { printf OUT "#%s RC4_INDEX\n",($rc4_idx)?"define":"undef"; }
1451         elsif (/^#(define|undef)\s+I386_ONLY/)
1452                 { printf OUT "#%s I386_ONLY\n", ($processor eq "386")?
1453                         "define":"undef"; }
1454         elsif   (/^#define\s+MD2_INT\s/)
1455                 { printf OUT "#define MD2_INT unsigned %s\n",$type[$md2_int]; }
1456         elsif   (/^#define\s+IDEA_INT\s/)
1457                 {printf OUT "#define IDEA_INT unsigned %s\n",$type[$idea_int];}
1458         elsif   (/^#define\s+RC2_INT\s/)
1459                 {printf OUT "#define RC2_INT unsigned %s\n",$type[$rc2_int];}
1460         elsif (/^#(define|undef)\s+BF_PTR/)
1461                 {
1462                 printf OUT "#undef BF_PTR\n" if $bf_ptr == 0;
1463                 printf OUT "#define BF_PTR\n" if $bf_ptr == 1;
1464                 printf OUT "#define BF_PTR2\n" if $bf_ptr == 2;
1465                 }
1466         else
1467                 { print OUT $_; }
1468         }
1469 close(IN);
1470 print OUT "#ifdef  __cplusplus\n";
1471 print OUT "}\n";
1472 print OUT "#endif\n";
1473 close(OUT);
1474 rename("crypto/opensslconf.h","crypto/opensslconf.h.bak") || die "unable to rename crypto/opensslconf.h\n" if -e "crypto/opensslconf.h";
1475 rename("crypto/opensslconf.h.new","crypto/opensslconf.h") || die "unable to rename crypto/opensslconf.h.new\n";
1476
1477
1478 # Fix the date
1479
1480 print "SIXTY_FOUR_BIT_LONG mode\n" if $b64l;
1481 print "SIXTY_FOUR_BIT mode\n" if $b64;
1482 print "THIRTY_TWO_BIT mode\n" if $b32;
1483 print "SIXTEEN_BIT mode\n" if $b16;
1484 print "EIGHT_BIT mode\n" if $b8;
1485 print "DES_PTR used\n" if $des_ptr;
1486 print "DES_RISC1 used\n" if $des_risc1;
1487 print "DES_RISC2 used\n" if $des_risc2;
1488 print "DES_UNROLL used\n" if $des_unroll;
1489 print "DES_INT used\n" if $des_int;
1490 print "BN_LLONG mode\n" if $bn_ll;
1491 print "RC4 uses u$type[$rc4_int]\n" if $rc4_int != $def_int;
1492 print "RC4_INDEX mode\n" if $rc4_idx;
1493 print "RC4_CHUNK is undefined\n" if $rc4_chunk==0;
1494 print "RC4_CHUNK is unsigned long\n" if $rc4_chunk==1;
1495 print "RC4_CHUNK is unsigned long long\n" if $rc4_chunk==2;
1496 print "MD2 uses u$type[$md2_int]\n" if $md2_int != $def_int;
1497 print "IDEA uses u$type[$idea_int]\n" if $idea_int != $def_int;
1498 print "RC2 uses u$type[$rc2_int]\n" if $rc2_int != $def_int;
1499 print "BF_PTR used\n" if $bf_ptr == 1;
1500 print "BF_PTR2 used\n" if $bf_ptr == 2;
1501
1502 if($IsMK1MF) {
1503         open (OUT,">crypto/buildinf.h") || die "Can't open buildinf.h";
1504         printf OUT <<EOF;
1505 #ifndef MK1MF_BUILD
1506   /* auto-generated by Configure for crypto/cversion.c:
1507    * for Unix builds, crypto/Makefile.ssl generates functional definitions;
1508    * Windows builds (and other mk1mf builds) compile cversion.c with
1509    * -DMK1MF_BUILD and use definitions added to this file by util/mk1mf.pl. */
1510   #error "Windows builds (PLATFORM=$target) use mk1mf.pl-created Makefiles"
1511 #endif
1512 EOF
1513         close(OUT);
1514 } else {
1515         my $make_command = "$make PERL=\'$perl\'";
1516         my $make_targets = "";
1517         $make_targets .= " links" if $symlink;
1518         $make_targets .= " depend" if $depflags ne $default_depflags && $make_depend;
1519         $make_targets .= " gentests" if $symlink;
1520         (system $make_command.$make_targets) == 0 or die "make $make_targets failed"
1521                 if $make_targets ne "";
1522         if ( $perl =~ m@^/@) {
1523             &dofile("tools/c_rehash",$perl,'^#!/', '#!%s','^my \$dir;$', 'my $dir = "' . $openssldir . '";', '^my \$prefix;$', 'my $prefix = "' . $prefix . '";');
1524             &dofile("apps/CA.pl",$perl,'^#!/', '#!%s');
1525         } else {
1526             # No path for Perl known ...
1527             &dofile("tools/c_rehash",'/usr/local/bin/perl','^#!/', '#!%s','^my \$dir;$', 'my $dir = "' . $openssldir . '";',  '^my \$prefix;$', 'my $prefix = "' . $prefix . '";');
1528             &dofile("apps/CA.pl",'/usr/local/bin/perl','^#!/', '#!%s');
1529         }
1530         if ($depflags ne $default_depflags && !$make_depend) {
1531                 print <<EOF;
1532
1533 Since you've disabled or enabled at least one algorithm, you need to do
1534 the following before building:
1535
1536         make depend
1537 EOF
1538         }
1539 }
1540
1541 # create the ms/version32.rc file if needed
1542 if ($IsMK1MF && ($target !~ /^netware/)) {
1543         my ($v1, $v2, $v3, $v4);
1544         if ($version_num =~ /(^[0-9a-f]{1})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})/i) {
1545                 $v1=hex $1;
1546                 $v2=hex $2;
1547                 $v3=hex $3;
1548                 $v4=hex $4;
1549         }
1550         open (OUT,">ms/version32.rc") || die "Can't open ms/version32.rc";
1551         print OUT <<EOF;
1552 #include <winver.h>
1553
1554 LANGUAGE 0x09,0x01
1555
1556 1 VERSIONINFO
1557   FILEVERSION $v1,$v2,$v3,$v4
1558   PRODUCTVERSION $v1,$v2,$v3,$v4
1559   FILEFLAGSMASK 0x3fL
1560 #ifdef _DEBUG
1561   FILEFLAGS 0x01L
1562 #else
1563   FILEFLAGS 0x00L
1564 #endif
1565   FILEOS VOS__WINDOWS32
1566   FILETYPE VFT_DLL
1567   FILESUBTYPE 0x0L
1568 BEGIN
1569     BLOCK "StringFileInfo"
1570     BEGIN
1571         BLOCK "040904b0"
1572         BEGIN
1573             // Required:
1574             VALUE "CompanyName", "The OpenSSL Project, http://www.openssl.org/\\0"
1575             VALUE "FileDescription", "OpenSSL Shared Library\\0"
1576             VALUE "FileVersion", "$version\\0"
1577 #if defined(CRYPTO)
1578             VALUE "InternalName", "libeay32\\0"
1579             VALUE "OriginalFilename", "libeay32.dll\\0"
1580 #elif defined(SSL)
1581             VALUE "InternalName", "ssleay32\\0"
1582             VALUE "OriginalFilename", "ssleay32.dll\\0"
1583 #endif
1584             VALUE "ProductName", "The OpenSSL Toolkit\\0"
1585             VALUE "ProductVersion", "$version\\0"
1586             // Optional:
1587             //VALUE "Comments", "\\0"
1588             VALUE "LegalCopyright", "Copyright © 1998-2005 The OpenSSL Project. Copyright © 1995-1998 Eric A. Young, Tim J. Hudson. All rights reserved.\\0"
1589             //VALUE "LegalTrademarks", "\\0"
1590             //VALUE "PrivateBuild", "\\0"
1591             //VALUE "SpecialBuild", "\\0"
1592         END
1593     END
1594     BLOCK "VarFileInfo"
1595     BEGIN
1596         VALUE "Translation", 0x409, 0x4b0
1597     END
1598 END
1599 EOF
1600         close(OUT);
1601   }
1602
1603 print <<EOF;
1604
1605 Configured for $target.
1606 EOF
1607
1608 print <<\EOF if (!$no_threads && !$threads);
1609
1610 The library could not be configured for supporting multi-threaded
1611 applications as the compiler options required on this system are not known.
1612 See file INSTALL for details if you need multi-threading.
1613 EOF
1614
1615 print <<\EOF if ($no_shared_warn);
1616
1617 You gave the option 'shared'.  Normally, that would give you shared libraries.
1618 Unfortunately, the OpenSSL configuration doesn't include shared library support
1619 for this platform yet, so it will pretend you gave the option 'no-shared'.  If
1620 you can inform the developpers (openssl-dev\@openssl.org) how to support shared
1621 libraries on this platform, they will at least look at it and try their best
1622 (but please first make sure you have tried with a current version of OpenSSL).
1623 EOF
1624
1625 exit(0);
1626
1627 sub usage
1628         {
1629         print STDERR $usage;
1630         print STDERR "\npick os/compiler from:\n";
1631         my $j=0;
1632         my $i;
1633         my $k=0;
1634         foreach $i (sort keys %table)
1635                 {
1636                 next if $i =~ /^debug/;
1637                 $k += length($i) + 1;
1638                 if ($k > 78)
1639                         {
1640                         print STDERR "\n";
1641                         $k=length($i);
1642                         }
1643                 print STDERR $i . " ";
1644                 }
1645         foreach $i (sort keys %table)
1646                 {
1647                 next if $i !~ /^debug/;
1648                 $k += length($i) + 1;
1649                 if ($k > 78)
1650                         {
1651                         print STDERR "\n";
1652                         $k=length($i);
1653                         }
1654                 print STDERR $i . " ";
1655                 }
1656         print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
1657         exit(1);
1658         }
1659
1660 sub which
1661         {
1662         my($name)=@_;
1663         my $path;
1664         foreach $path (split /:/, $ENV{PATH})
1665                 {
1666                 if (-f "$path/$name$exe_ext" and -x _)
1667                         {
1668                         return "$path/$name$exe_ext" unless ($name eq "perl" and
1669                          system("$path/$name$exe_ext -e " . '\'exit($]<5.0);\''));
1670                         }
1671                 }
1672         }
1673
1674 sub dofile
1675         {
1676         my $f; my $p; my %m; my @a; my $k; my $ff;
1677         ($f,$p,%m)=@_;
1678
1679         open(IN,"<$f.in") || open(IN,"<$f") || die "unable to open $f:$!\n";
1680         @a=<IN>;
1681         close(IN);
1682         foreach $k (keys %m)
1683                 {
1684                 grep(/$k/ && ($_=sprintf($m{$k}."\n",$p)),@a);
1685                 }
1686         open(OUT,">$f.new") || die "unable to open $f.new:$!\n";
1687         print OUT @a;
1688         close(OUT);
1689         rename($f,"$f.bak") || die "unable to rename $f\n" if -e $f;
1690         rename("$f.new",$f) || die "unable to rename $f.new\n";
1691         }
1692
1693 sub print_table_entry
1694         {
1695         my $target = shift;
1696
1697         my ($cc, $cflags, $unistd, $thread_cflag, $sys_id, $lflags,
1698             $bn_ops, $cpuid_obj, $bn_obj, $ec_obj, $des_obj, $aes_obj, $bf_obj,
1699             $md5_obj, $sha1_obj, $cast_obj, $rc4_obj, $rmd160_obj,
1700             $rc5_obj, $wp_obj, $cmll_obj, $modes_obj, $engines_obj,
1701             $perlasm_scheme, $dso_scheme, $shared_target, $shared_cflag,
1702             $shared_ldflag, $shared_extension, $ranlib, $arflags, $multilib)=
1703         split(/\s*:\s*/,$table{$target} . ":" x 30 , -1);
1704
1705         print <<EOF
1706
1707 *** $target
1708 \$cc           = $cc
1709 \$cflags       = $cflags
1710 \$unistd       = $unistd
1711 \$thread_cflag = $thread_cflag
1712 \$sys_id       = $sys_id
1713 \$lflags       = $lflags
1714 \$bn_ops       = $bn_ops
1715 \$cpuid_obj    = $cpuid_obj
1716 \$bn_obj       = $bn_obj
1717 \$ec_obj       = $ec_obj
1718 \$des_obj      = $des_obj
1719 \$aes_obj      = $aes_obj
1720 \$bf_obj       = $bf_obj
1721 \$md5_obj      = $md5_obj
1722 \$sha1_obj     = $sha1_obj
1723 \$cast_obj     = $cast_obj
1724 \$rc4_obj      = $rc4_obj
1725 \$rmd160_obj   = $rmd160_obj
1726 \$rc5_obj      = $rc5_obj
1727 \$wp_obj       = $wp_obj
1728 \$cmll_obj     = $cmll_obj
1729 \$modes_obj    = $modes_obj
1730 \$engines_obj  = $engines_obj
1731 \$perlasm_scheme = $perlasm_scheme
1732 \$dso_scheme   = $dso_scheme
1733 \$shared_target= $shared_target
1734 \$shared_cflag = $shared_cflag
1735 \$shared_ldflag = $shared_ldflag
1736 \$shared_extension = $shared_extension
1737 \$ranlib       = $ranlib
1738 \$arflags      = $arflags
1739 \$multilib     = $multilib
1740 EOF
1741         }
1742
1743 sub test_sanity
1744         {
1745         my $errorcnt = 0;
1746
1747         print STDERR "=" x 70, "\n";
1748         print STDERR "=== SANITY TESTING!\n";
1749         print STDERR "=== No configuration will be done, all other arguments will be ignored!\n";
1750         print STDERR "=" x 70, "\n";
1751
1752         foreach $target (sort keys %table)
1753                 {
1754                 @fields = split(/\s*:\s*/,$table{$target} . ":" x 30 , -1);
1755
1756                 if ($fields[$idx_dso_scheme-1] =~ /^(beos|dl|dlfcn|win32|vms)$/)
1757                         {
1758                         $errorcnt++;
1759                         print STDERR "SANITY ERROR: '$target' has the dso_scheme [$idx_dso_scheme] values\n";
1760                         print STDERR "              in the previous field\n";
1761                         }
1762                 elsif ($fields[$idx_dso_scheme+1] =~ /^(beos|dl|dlfcn|win32|vms)$/)
1763                         {
1764                         $errorcnt++;
1765                         print STDERR "SANITY ERROR: '$target' has the dso_scheme [$idx_dso_scheme] values\n";
1766                         print STDERR "              in the following field\n";
1767                         }
1768                 elsif ($fields[$idx_dso_scheme] !~ /^(beos|dl|dlfcn|win32|vms|)$/)
1769                         {
1770                         $errorcnt++;
1771                         print STDERR "SANITY ERROR: '$target' has the dso_scheme [$idx_dso_scheme] field = ",$fields[$idx_dso_scheme],"\n";
1772                         print STDERR "              valid values are 'beos', 'dl', 'dlfcn', 'win32' and 'vms'\n";
1773                         }
1774                 }
1775         print STDERR "No sanity errors detected!\n" if $errorcnt == 0;
1776         return $errorcnt;
1777         }