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 my $x86_asm_nocast=$x86_asm;$x86_asm_nocast=~s/cast\-586\.o//;
 138
 139 my $x86_elf_asm="$x86_asm:elf";
 140 my $android_x86_elf_asm="$x86_asm:android";
 141
 142 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";
 143 my $win_x86_64_asm=$x86_asm;$win_x86_64_asm=~s/x86_64-gcc\.o/bn_asm.o/;
 144 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";
 145 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";
 146 my $sparcv8_asm=":sparcv8.o::des_enc-sparc.o fcrypt_b.o:::::::::::::void";
 147 my $alpha_asm="alphacpuid.o:bn_asm.o alpha-mont.o::::::sha1-alpha.o:::::::ghash-alpha.o::void";
 148 my $mips64_asm=":bn-mips.o mips-mont.o:::aes_cbc.o aes-mips.o:::sha1-mips.o sha256-mips.o sha512-mips.o::::::::";
 149 my $mips32_asm=$mips64_asm; $mips32_asm =~ s/\s*sha512\-mips\.o//;
 150 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:";
 151 my $s390x_32_asm=$s390x_asm;$s390x_32_asm=~s/bn\-s390x\.o/bn_asm.o/;
 152 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";
 153 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:";
 154 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";
 155 my $parisc20_64_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";
 156 my $parisc20_32_asm=$parisc20_64_asm;$parisc20_32_asm=~s/2W\./2\./;$parisc20_32_asm=~s/:64/:32/;
 157 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:";
 158 my $ppc32_asm=$ppc64_asm;
 159
 160 # As for $BSDthreads. Idea is to maintain "collective" set of flags,
 161 # which would cover all BSD flavors. -pthread applies to them all,
 162 # but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
 163 # -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
 164 # which has to be accompanied by explicit -D_THREAD_SAFE and
 165 # sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
 166 # seems to be sufficient?
 167 my $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
 168
 169 # table of known configurations, read in from files
 170 #
 171 # The content of each entry can take one of two forms:
 172 #
 173 # - old style config-string, colon seperated fields with exactly the
 174 #   following structure.:
 175 #
 176 #       $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 : $perlasm_scheme : $dso_scheme : $shared_target : $shared_cflag : $shared_ldflag : $shared_extension : $ranlib : $arflags : $multilib
 177 #
 178 #   We use the stringtohash function - defined below - to combine with the
 179 #   fields and form a proper hash table from the string.
 180 #
 181 # - direct transfer of old style config string to hash table, using the names
 182 #   of the fields as keys:
 183 #
 184 #       {
 185 #         cc => $cc,
 186 #         cflags => $cflags,
 187 #         unistd => $unistd,
 188 #         thread_cflag => $thread_cflag,
 189 #         sys_id => $sys_id,
 190 #         lflags => $lflags,
 191 #         bn_ops => $bn_ops,
 192 #         cpuid_obj => $cpuid_obj,
 193 #         bn_obj => $bn_obj,
 194 #         ec_obj => $ec_obj,
 195 #         des_obj => $des_obj,
 196 #         aes_obj => $aes_obj,
 197 #         bf_obj => $bf_obj,
 198 #         md5_obj => $md5_obj,
 199 #         sha1_obj => $sha1_obj,
 200 #         cast_obj => $cast_obj,
 201 #         rc4_obj => $rc4_obj,
 202 #         rmd160_obj => $rmd160_obj,
 203 #         rc5_obj => $rc5_obj,
 204 #         wp_obj => $wp_obj,
 205 #         cmll_obj => $cmll_obj,
 206 #         modes_obj => $modes_obj,
 207 #         engines_obj => $engines_obj,
 208 #         perlasm_scheme => $perlasm_scheme,
 209 #         dso_scheme => $dso_scheme,
 210 #         shared_target => $shared_target,
 211 #         shared_cflag => $shared_cflag,
 212 #         shared_ldflag => $shared_ldflag,
 213 #         shared_extension => $shared_extension,
 214 #         ranlib => $ranlib,
 215 #         arflags => $arflags,
 216 #         multilib => $multilib
 217 #       }
 218 #
 219 # - new style config hash table, which has additional attributes for debug
 220 #   and non-debug flags to be added to the common flags, for cflags and lflags:
 221 #
 222 #       {
 223 #         cc => $cc,
 224 #         cflags => $cflags,
 225 #         debug_cflags => $debug_cflags,
 226 #         release_cflags => $release_cflags,
 227 #         unistd => $unistd,
 228 #         thread_cflag => $thread_cflag,
 229 #         sys_id => $sys_id,
 230 #         lflags => $lflags,
 231 #         debug_lflags => $debug_lflags,
 232 #         release_lflags => $release_lflags,
 233 #         bn_ops => $bn_ops,
 234 #         cpuid_obj => $cpuid_obj,
 235 #         bn_obj => $bn_obj,
 236 #         ec_obj => $ec_obj,
 237 #         des_obj => $des_obj,
 238 #         aes_obj => $aes_obj,
 239 #         bf_obj => $bf_obj,
 240 #         md5_obj => $md5_obj,
 241 #         sha1_obj => $sha1_obj,
 242 #         cast_obj => $cast_obj,
 243 #         rc4_obj => $rc4_obj,
 244 #         rmd160_obj => $rmd160_obj,
 245 #         rc5_obj => $rc5_obj,
 246 #         wp_obj => $wp_obj,
 247 #         cmll_obj => $cmll_obj,
 248 #         modes_obj => $modes_obj,
 249 #         engines_obj => $engines_obj,
 250 #         dso_scheme => $dso_scheme,
 251 #         shared_target => $shared_target,
 252 #         shared_cflag => $shared_cflag,
 253 #         shared_ldflag => $shared_ldflag,
 254 #         shared_extension => $shared_extension,
 255 #         ranlib => $ranlib,
 256 #         arflags => $arflags,
 257 #         multilib => $multilib
 258 #       }
 259 #
 260 # The configuration reader will do what it can to translate everything into
 261 # new style config hash tables, including merging $target and debug-$target
 262 # if they are similar enough.
 263 #
 264 # The configuration hashes can refer to templates in two different manners:
 265 #
 266 # - as part of the hash, one can have a key called 'inherit_from' that
 267 #   indicate what other configuration hashes to inherit data from.
 268 #   These are resolved recursively.
 269 #
 270 #   Inheritance works as a set of default values that can be overriden
 271 #   by corresponding attribute values in the inheriting configuration.
 272 #
 273 #   If several configurations are given in the 'inherit_from' array, the
 274 #   values of same attribute are concatenated with space separation.
 275 #   With this, it's possible to have several smaller templates for
 276 #   different configuration aspects that can be combined into a complete
 277 #   configuration.
 278 #
 279 #   Example:
 280 #
 281 #       "foo" => {
 282 #               template => 1,
 283 #               haha => "haha",
 284 #               hoho => "ho"
 285 #       },
 286 #       "bar" => {
 287 #               template => 1,
 288 #               hoho => "ho",
 289 #               hehe => "hehe"
 290 #       },
 291 #       "laughter" => {
 292 #               inherit_from => [ "foo", "bar" ],
 293 #       }
 294 #
 295 #       The entry for "foo" will become as follows after processing:
 296 #
 297 #       "laughter" => {
 298 #               haha => "haha",
 299 #               hoho => "ho ho",
 300 #               hehe => "hehe"
 301 #       }
 302 #
 303 #   Note 1: any entry from the table can be used as a template.
 304 #   Note 2: pure templates have the attribute 'template => 1' and cannot
 305 #           be used as targets.
 306 #
 307 # - instead of a string, one can have a code block of the form
 308 #   'sub { /* your code here */ }', where the arguments are the list of
 309 #   inherited values for that key.  In fact, the concatenation of strings
 310 #   is really done by using 'sub { join(" ",@_) }' on the list of inherited
 311 #   values.
 312 #
 313 #   Example:
 314 #
 315 #       "foo" => {
 316 #               template => 1,
 317 #               haha => "ha ha",
 318 #               hoho => "ho",
 319 #               ignored => "This should not appear in the end result",
 320 #       },
 321 #       "bar" => {
 322 #               template => 1,
 323 #               haha => "ah",
 324 #               hoho => "haho",
 325 #               hehe => "hehe"
 326 #       },
 327 #       "laughter" => {
 328 #               inherit_from => [ "foo", "bar" ],
 329 #               hehe => sub { join(" ",(@_,"!!!")) },
 330 #               ignored => "",
 331 #       }
 332 #
 333 #       The entry for "foo" will become as follows after processing:
 334 #
 335 #       "laughter" => {
 336 #               haha => "ha ha ah",
 337 #               hoho => "ho haho",
 338 #               hehe => "hehe !!!",
 339 #               ignored => ""
 340 #       }
 341 #
 342
 343 my %table=(
 344
 345     # All these templates are merely a translation of the corresponding
 346     # variables further up.
 347     #
 348     # Note: as long as someone might use old style configuration strings,
 349     # or we bother supporting that, those variables need to stay
 350
 351     x86_asm => {
 352         template        => 1,
 353         cpuid_obj       => "x86cpuid.o",
 354         bn_obj          => "bn-586.o co-586.o x86-mont.o x86-gf2m.o",
 355         ec_obj          => "ecp_nistz256.o ecp_nistz256-x86.o",
 356         des_obj         => "des-586.o crypt586.o",
 357         aes_obj         => "aes-586.o vpaes-x86.o aesni-x86.o",
 358         bf_obj          => "bf-586.o",
 359         md5_obj         => "md5-586.o",
 360         sha1_obj        => "sha1-586.o sha256-586.o sha512-586.o",
 361         rc4_obj         => "rc4-586.o",
 362         rmd160_obj      => "rmd-586.o",
 363         rc5_obj         => "rc5-586.o",
 364         wp_obj          => "wp_block.o wp-mmx.o",
 365         cmll_obj        => "cmll-x86.o",
 366         modes_obj       => "ghash-x86.o",
 367         engines_obj     => "e_padlock-x86.o"
 368     },
 369     x86_elf_asm => {
 370         template        => 1,
 371         inherit_from    => [ "x86_asm" ],
 372         perlasm_scheme  => "elf"
 373     },
 374     x86_64_asm => {
 375         template        => 1,
 376         cpuid_obj       => "x86_64cpuid.o",
 377         bn_obj          => "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",
 378         ec_obj          => "ecp_nistz256.o ecp_nistz256-x86_64.o",
 379         aes_obj         => "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",
 380         md5_obj         => "md5-x86_64.o",
 381         sha1_obj        => "sha1-x86_64.o sha256-x86_64.o sha512-x86_64.o sha1-mb-x86_64.o sha256-mb-x86_64.o",
 382         rc4_obj         => "rc4-x86_64.o rc4-md5-x86_64.o",
 383         wp_obj          => "wp-x86_64.o",
 384         cmll_obj        => "cmll-x86_64.o cmll_misc.o",
 385         modes_obj       => "ghash-x86_64.o aesni-gcm-x86_64.o",
 386         engines_obj     => "e_padlock-x86_64.o"
 387     },
 388     ia64_asm => {
 389         template        => 1,
 390         cpuid_obj       => "ia64cpuid.o",
 391         bn_obj          => "bn-ia64.o ia64-mont.o",
 392         aes_obj         => "aes_core.o aes_cbc.o aes-ia64.o",
 393         md5_obj         => "md5-ia64.o",
 394         sha1_obj        => "sha1-ia64.o sha256-ia64.o sha512-ia64.o",
 395         rc4_obj         => "rc4-ia64.o rc4_skey.o",
 396         modes_obj       => "ghash-ia64.o",
 397         perlasm_scheme  => "void"
 398     },
 399     sparcv9_asm => {
 400         template        => 1,
 401         cpuid_obj       => "sparcv9cap.o sparccpuid.o",
 402         bn_obj          => "bn-sparcv9.o sparcv9-mont.o sparcv9a-mont.o vis3-mont.o sparct4-mont.o sparcv9-gf2m.o",
 403         des_obj         => "des_enc-sparc.o fcrypt_b.o dest4-sparcv9.o",
 404         aes_obj         => "aes_core.o aes_cbc.o aes-sparcv9.o aest4-sparcv9.o",
 405         md5_obj         => "md5-sparcv9.o",
 406         sha1_obj        => "sha1-sparcv9.o sha256-sparcv9.o sha512-sparcv9.o",
 407         cmll_obj        => "camellia.o cmll_misc.o cmll_cbc.o cmllt4-sparcv9.o",
 408         modes_obj       => "ghash-sparcv9.o",
 409         perlasm_scheme  => "void"
 410     },
 411     sparcv8_asm => {
 412         template        => 1,
 413         cpuid_obj       => "",
 414         bn_obj          => "sparcv8.o",
 415         des_obj         => "des_enc-sparc.o fcrypt_b.o",
 416         perlasm_scheme  => "void"
 417     },
 418     alpha_asm => {
 419         template        => 1,
 420         cpuid_obj       => "alphacpuid.o",
 421         bn_obj          => "bn_asm.o alpha-mont.o",
 422         sha1_obj        => "sha1-alpha.o",
 423         modes_obj       => "ghash-alpha.o",
 424         perlasm_scheme  => "void"
 425     },
 426     mips32_asm => {
 427         template        => 1,
 428         bn_obj          => "bn-mips.o mips-mont.o",
 429         aes_obj         => "aes_cbc.o aes-mips.o",
 430         sha1_obj        => "sha1-mips.o sha256-mips.o",
 431     },
 432     mips64_asm => {
 433         inherit_from    => [ "mips32_asm" ],
 434         template        => 1,
 435         sha1_obj        => sub { join(" ", @_, "sha512-mips.o") }
 436     },
 437     s390x_asm => {
 438         template        => 1,
 439         cpuid_obj       => "s390xcap.o s390xcpuid.o",
 440         bn_obj          => "bn-s390x.o s390x-mont.o s390x-gf2m.o",
 441         aes_obj         => "aes-s390x.o aes-ctr.o aes-xts.o",
 442         sha1_obj        => "sha1-s390x.o sha256-s390x.o sha512-s390x.o",
 443         rc4_obj         => "rc4-s390x.o",
 444         modes_obj       => "ghash-s390x.o",
 445     },
 446     armv4_asm => {
 447         template        => 1,
 448         cpuid_obj       => "armcap.o armv4cpuid.o",
 449         bn_obj          => "bn_asm.o armv4-mont.o armv4-gf2m.o",
 450         ec_obj          => "ecp_nistz256.o ecp_nistz256-armv4.o",
 451         aes_obj         => "aes_cbc.o aes-armv4.o bsaes-armv7.o aesv8-armx.o",
 452         sha1_obj        => "sha1-armv4-large.o sha256-armv4.o sha512-armv4.o",
 453         modes_obj       => "ghash-armv4.o ghashv8-armx.o",
 454         perlasm_scheme  => "void"
 455     },
 456     aarch64_asm => {
 457         template        => 1,
 458         cpuid_obj       => "armcap.o arm64cpuid.o mem_clr.o",
 459         aes_obj         => "aes_core.o aes_cbc.o aesv8-armx.o",
 460         sha1_obj        => "sha1-armv8.o sha256-armv8.o sha512-armv8.o",
 461         modes_obj       => "ghashv8-armx.o",
 462     },
 463     parisc11_asm => {
 464         template        => 1,
 465         cpuid_obj       => "pariscid.o",
 466         bn_obj          => "bn_asm.o parisc-mont.o",
 467         aes_obj         => "aes_core.o aes_cbc.o aes-parisc.o",
 468         sha1_obj        => "sha1-parisc.o sha256-parisc.o sha512-parisc.o",
 469         rc4_obj         => "rc4-parisc.o",
 470         modes_obj       => "ghash-parisc.o",
 471         perlasm_scheme  => "32"
 472     },
 473     parisc20_64_asm => {
 474         template        => 1,
 475         inherit_from    => [ "parisc11_asm" ],
 476         bn_obj          => sub { my $r=join(" ",@_); $r=~s/bn_asm/pa-risc2W/; $r; },
 477         perlasm_scheme  => "64",
 478     },
 479     ppc64_asm => {
 480         template        => 1,
 481         cpuid_obj       => "ppccpuid.o ppccap.o",
 482         bn_obj          => "bn-ppc.o ppc-mont.o ppc64-mont.o",
 483         aes_obj         => "aes_core.o aes_cbc.o aes-ppc.o vpaes-ppc.o aesp8-ppc.o",
 484         sha1_obj        => "sha1-ppc.o sha256-ppc.o sha512-ppc.o sha256p8-ppc.o sha512p8-ppc.o",
 485         modes_obj       => "ghashp8-ppc.o",
 486     },
 487     ppc32_asm => {
 488         inherit_from    => [ "ppc64_asm" ],
 489         template        => 1
 490     },
 491 );
 492
 493 {   my $no_asm_templates=0;
 494     foreach (@ARGV) { $no_asm_templates=1 if (/^\-?no\-asm$/); }
 495     sub asm { $no_asm_templates?():@_; }
 496 }
 497
 498
 499 sub stringtohash {
 500     my $in = shift @_;
 501     if (ref($in) eq "HASH") {
 502         return $in;
 503     }
 504     my @stringsequence = (
 505         "cc",
 506         "cflags",
 507         "unistd",
 508         "thread_cflag",
 509         "sys_id",
 510         "lflags",
 511         "bn_ops",
 512         "cpuid_obj",
 513         "bn_obj",
 514         "ec_obj",
 515         "des_obj",
 516         "aes_obj",
 517         "bf_obj",
 518         "md5_obj",
 519         "sha1_obj",
 520         "cast_obj",
 521         "rc4_obj",
 522         "rmd160_obj",
 523         "rc5_obj",
 524         "wp_obj",
 525         "cmll_obj",
 526         "modes_obj",
 527         "engines_obj",
 528         "perlasm_scheme",
 529         "dso_scheme",
 530         "shared_target",
 531         "shared_cflag",
 532         "shared_ldflag",
 533         "shared_extension",
 534         "ranlib",
 535         "arflags",
 536         "multilib",
 537         );
 538
 539     # return a ref to a hash, that's what the outer braces are for.
 540     return { map { shift @stringsequence => $_ } split /:/, $in };
 541 };
 542
 543 # Read configuration target stanzas from a file, so that people can have
 544 # local files with their own definitions
 545 sub read_config {
 546         my $fname = shift;
 547         open(CONFFILE, "< $fname")
 548                 or die "Can't open configuration file '$fname'!\n";
 549         my $x = $/;
 550         undef $/;
 551         my $content = <CONFFILE>;
 552         $/ = $x;
 553         close(CONFFILE);
 554         my %targets = ();
 555         eval $content;
 556
 557         # Make sure we have debug- targets first
 558         my @keys =
 559             sort {
 560                 my $a_nd = $a =~ m/^debug-/ ? $' :$a;
 561                 my $b_nd = $b =~ m/^debug-/ ? $' :$b;
 562                 my $res = 0;
 563
 564                 if (($a_nd == $a) == ($b_nd == $b)) {
 565                     # they are both debug- or not, compare them as they are
 566                     $res = $a cmp $b;
 567                 } elsif ($a_nd != $a) {
 568                     # $a is debug-, make it lesser
 569                     $res = -1;
 570                 } else {
 571                     # $b is debug-, make $a greater
 572                     $res = 1;
 573                 }
 574                 $res;
 575             } keys %targets;
 576
 577         foreach (@keys) {
 578             if (ref($targets{$_}) ne "HASH") {
 579                 # Value is assumed to be a string.  Split it up to
 580                 # become a hash table of parameters.  Also, try to
 581                 # merge debug- variants with the non-debug target.
 582
 583                 # Start with converting the value from a string to a
 584                 # standardised hash of fields.  Using $tohash is safe,
 585                 # if the input is already a hash ref, it's just returned
 586                 # back.
 587                 $targets{$_} = stringtohash($targets{$_});
 588
 589                 # If the current target is a debug target, there might
 590                 # be a corresponding non-debug target that we can merge
 591                 # with.  If it isn't a debug- target, we've already done
 592                 # as much merging as we can and do not need to bother
 593                 # with that any more.
 594                 if ($_ =~ m/^debug-/) {
 595                     my $debugkey = $_;
 596                     my $nondebugkey = $';
 597                     my $debug = $targets{$debugkey};
 598                     my $nondebug;
 599
 600                     if ($targets{$nondebugkey}) {
 601                         $nondebug = stringtohash($targets{$nondebugkey});
 602                     }
 603
 604                     if ($nondebug) {
 605                         # There's both a debug and non-debug variant of
 606                         # this target, so we should try to merge them
 607                         # together.
 608
 609                         # First, check that the non-debug variant isn't
 610                         # already built up with all it should have.
 611                         if ($nondebug->{debug_cflags}
 612                             || $nondebug->{release_cflags}
 613                             || $nondebug->{debug_lflags}
 614                             || $nondebug->{release_lflags}) {
 615                             warn "there's a debug target $debugkey to be merged with a target $nondebugkey, but the latter seems to already have both nodebug and debug information.  This requires human intervention.  Skipping $debugkey...";
 616                             next;
 617                         }
 618
 619                         # Now, check similarity.
 620                         # For keys they have in common, support that
 621                         # cflags and lflags can differ, otherwise they
 622                         # must have exactly the same values for them
 623                         # to be merged into one.
 624                         my $similarenough = 1;
 625                         for (keys %{$debug}) {
 626                             if ($nondebug->{$_} ne $debug->{$_}
 627                                 && $_ !~ m/^[cl]flags$/) {
 628                                 $similarenough = 0;
 629                                 last;
 630                             }
 631                         }
 632
 633                         if ($similarenough) {
 634                             # Here's where the magic happens, split the
 635                             # options in the debug and non-debug variants
 636                             # cflags and ldflags into three strings each,
 637                             # one with common flags, one with extra debug
 638                             # flags and one with extra non-debug flags.
 639
 640                             # The result ends up in %h_nondebug, which
 641                             # becomes the merged variant when we're done.
 642                             # for each of cflags and lflags, they are
 643                             # replaced with cflags, debug_cflags,
 644                             # release_cflags and similar for lflags.
 645                             #
 646                             # The purpose is that 'cflags' should be
 647                             # used together with 'debug_cflags' or
 648                             # 'release_cflags' depending on what the
 649                             # user asks for.
 650                             foreach (("cflags", "lflags")) {
 651                                 my @list_d = split /\s+/, $debug->{$_};
 652                                 my @list_nd = split /\s+/, $nondebug->{$_};
 653                                 my %presence = (); # bitmap
 654                                                    # 1: present in @list_d
 655                                                    # 2: present in @list_nd
 656                                                    # 3: present in both
 657                                 map { $presence{$_} += 1; } @list_d;
 658                                 map { $presence{$_} += 2; } @list_nd;
 659
 660                                 delete $nondebug->{$_};
 661                                 # Note: we build from the original lists to
 662                                 # preserve order, it might be important
 663                                 $nondebug->{"debug-".$_} =
 664                                     join(" ",
 665                                          grep { $presence{$_} == 1 } @list_d);
 666                                 $nondebug->{"nodebug-".$_} =
 667                                     join(" ",
 668                                          grep { $presence{$_} == 2 } @list_nd);
 669                                 $nondebug->{$_} =
 670                                     join(" ",
 671                                          grep { $presence{$_} == 3 } @list_d);
 672                             }
 673
 674                             $targets{$nondebugkey} = $nondebug;
 675                             delete $targets{$debugkey};
 676                         }
 677                     }
 678                 }
 679             }
 680         }
 681
 682         %table = (%table, %targets);
 683
 684         # Local function to resolve inheritance
 685         my $resolve_inheritance;
 686         $resolve_inheritance =
 687             sub {
 688                 my $target = shift;
 689                 my @breadcrumbs = @_;
 690
 691                 if (grep { $_ eq $target } @breadcrumbs) {
 692                     die "inherit_from loop!  target backtrace:\n  "
 693                         ,$target,"\n  ",join("\n  ", @breadcrumbs),"\n";
 694                 }
 695
 696                 # Recurse through all inheritances.  They will be resolved on
 697                 # the fly, so when this operation is done, they will all just
 698                 # be a bunch of attributes with string values.
 699                 # What we get here, though, are keys with references to lists
 700                 # of the combined values of them all.  We will deal with lists
 701                 # after this stage is done.
 702                 my %combined_inheritance = ();
 703                 if ($table{$target}->{inherit_from}) {
 704                     foreach (@{$table{$target}->{inherit_from}}) {
 705                         my %inherited_config =
 706                             $resolve_inheritance->($_, $target, @breadcrumbs);
 707
 708                         # 'template' is a marker that's considered private to
 709                         # the config that had it.
 710                         delete $inherited_config{template};
 711
 712                         map {
 713                             if (!$combined_inheritance{$_}) {
 714                                 $combined_inheritance{$_} = [];
 715                             }
 716                             push @{$combined_inheritance{$_}}, $inherited_config{$_};
 717                         } keys %inherited_config;
 718                     }
 719                 }
 720
 721                 # We won't need inherit_from in this target any more, since
 722                 # we've resolved all the inheritances that lead to this
 723                 delete $table{$target}->{inherit_from};
 724
 725                 # Now is the time to deal with those lists.  Here's the place
 726                 # to decide what shall be done with those lists, all based on
 727                 # the values of the target we're currently dealing with.
 728                 # - If a value is a coderef, it will be executed with the list
 729                 #   of inherited values as arguments.
 730                 # - If the corresponding key doesn't have a value at all or is
 731                 #   the emoty string, the inherited value list will be run
 732                 #   through the default combiner (below), and the result
 733                 #   becomes this target's value.
 734                 # - Otherwise, this target's value is assumed to be a string
 735                 #   that will simply override the inherited list of values.
 736                 my $default_combiner = sub { join(' ',@_) };
 737
 738                 my %all_keys =
 739                     map { $_ => 1 } (keys %combined_inheritance,
 740                                      keys %{$table{$target}});
 741                 foreach (sort keys %all_keys) {
 742
 743                     # Current target doesn't have a value for the current key?
 744                     # Assign it the default combiner, the rest of this loop
 745                     # body will handle it just like any other coderef.
 746                     if (!exists $table{$target}->{$_}) {
 747                         $table{$target}->{$_} = $default_combiner;
 748                     }
 749
 750                     my $valuetype = ref($table{$target}->{$_});
 751                     if ($valuetype eq "CODE") {
 752                         # CODE reference, execute it with the inherited values
 753                         # as arguments.
 754                         $table{$target}->{$_} =
 755                             $table{$target}->{$_}->(@{$combined_inheritance{$_}});
 756                     } elsif ($valuetype eq "") {
 757                         # Scalar, just leave it as is.
 758                     } else {
 759                         # Some other type of reference that we don't handle.
 760                         # Better to abort at this point.
 761                         die "cannot handle reference type $valuetype,"
 762                             ," found in target $target -> $_\n";
 763                     }
 764                 }
 765
 766                 # Finally done, return the result.
 767                 %{$table{$target}};
 768         };
 769
 770         # Go through all new targets and resolve inheritance and template
 771         # references.
 772         foreach (keys %targets) {
 773             # We're ignoring the returned values here, they are only valuable
 774             # to the inner recursion of this function.
 775             $resolve_inheritance->($_);
 776         }
 777 }
 778
 779 my ($vol, $dir, $dummy) = File::Spec->splitpath($0);
 780 my $pattern = File::Spec->catpath($vol, $dir, "Configurations/*.conf");
 781 foreach (sort glob($pattern) ) {
 782     &read_config($_);
 783 }
 784
 785 my @MK1MF_Builds=qw(VC-WIN64I VC-WIN64A
 786                     debug-VC-WIN64I debug-VC-WIN64A
 787                     VC-NT VC-CE VC-WIN32 debug-VC-WIN32
 788                     BC-32
 789                     netware-clib netware-clib-bsdsock
 790                     netware-libc netware-libc-bsdsock);
 791
 792 my $prefix="";
 793 my $libdir="";
 794 my $openssldir="";
 795 my $exe_ext="";
 796 my $install_prefix= "$ENV{'INSTALL_PREFIX'}";
 797 my $cross_compile_prefix="";
 798 my $fipslibdir="/usr/local/ssl/fips-2.0/lib/";
 799 my $nofipscanistercheck=0;
 800 my $baseaddr="0xFB00000";
 801 my $no_threads=0;
 802 my $threads=0;
 803 my $no_shared=0; # but "no-shared" is default
 804 my $zlib=1;      # but "no-zlib" is default
 805 my $no_krb5=0;   # but "no-krb5" is implied unless "--with-krb5-..." is used
 806 my $no_rfc3779=1; # but "no-rfc3779" is default
 807 my $no_asm=0;
 808 my $no_dso=0;
 809 my $no_gmp=0;
 810 my @skip=();
 811 my $Makefile="Makefile";
 812 my $des_locl="crypto/des/des_locl.h";
 813 my $des ="crypto/des/des.h";
 814 my $bn  ="crypto/bn/bn.h";
 815 my $md2 ="crypto/md2/md2.h";
 816 my $rc4 ="crypto/rc4/rc4.h";
 817 my $rc4_locl="crypto/rc4/rc4_locl.h";
 818 my $idea        ="crypto/idea/idea.h";
 819 my $rc2 ="crypto/rc2/rc2.h";
 820 my $bf  ="crypto/bf/bf_locl.h";
 821 my $bn_asm      ="bn_asm.o";
 822 my $des_enc="des_enc.o fcrypt_b.o";
 823 my $aes_enc="aes_core.o aes_cbc.o";
 824 my $bf_enc      ="bf_enc.o";
 825 my $cast_enc="c_enc.o";
 826 my $rc4_enc="rc4_enc.o rc4_skey.o";
 827 my $rc5_enc="rc5_enc.o";
 828 my $cmll_enc="camellia.o cmll_misc.o cmll_cbc.o";
 829 my $processor="";
 830 my $default_ranlib;
 831 my $perl;
 832 my $fips=0;
 833
 834 # All of the following is disabled by default (RC5 was enabled before 0.9.8):
 835
 836 my %disabled = ( # "what"         => "comment" [or special keyword "experimental"]
 837                  "deprecated" => "default",
 838                  "ec_nistp_64_gcc_128" => "default",
 839                  "gmp"            => "default",
 840                  "jpake"          => "experimental",
 841                  "md2"            => "default",
 842                  "rc5"            => "default",
 843                  "rfc3779"        => "default",
 844                  "sctp"       => "default",
 845                  "shared"         => "default",
 846                  "ssl-trace"      => "default",
 847                  "store"          => "experimental",
 848                  "unit-test"      => "default",
 849                  "zlib"           => "default",
 850                  "zlib-dynamic"   => "default"
 851                );
 852 my @experimental = ();
 853
 854 # This is what $depflags will look like with the above defaults
 855 # (we need this to see if we should advise the user to run "make depend"):
 856 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";
 857
 858 # Explicit "no-..." options will be collected in %disabled along with the defaults.
 859 # To remove something from %disabled, use "enable-foo" (unless it's experimental).
 860 # For symmetry, "disable-foo" is a synonym for "no-foo".
 861
 862 # For features called "experimental" here, a more explicit "experimental-foo" is needed to enable.
 863 # We will collect such requests in @experimental.
 864 # To avoid accidental use of experimental features, applications will have to use -DOPENSSL_EXPERIMENTAL_FOO.
 865
 866
 867 my $no_sse2=0;
 868
 869 &usage if ($#ARGV < 0);
 870
 871 my $flags;
 872 my $depflags;
 873 my $openssl_experimental_defines;
 874 my $openssl_algorithm_defines;
 875 my $openssl_thread_defines;
 876 my $openssl_sys_defines="";
 877 my $openssl_other_defines;
 878 my $libs;
 879 my $libkrb5="";
 880 my $target;
 881 my $options;
 882 my $symlink;
 883 my $make_depend=0;
 884 my %withargs=();
 885 my $build_prefix = "release_";
 886
 887 my @argvcopy=@ARGV;
 888 my $argvstring="";
 889 my $argv_unprocessed=1;
 890
 891 while($argv_unprocessed)
 892         {
 893         $flags="";
 894         $depflags="";
 895         $openssl_experimental_defines="";
 896         $openssl_algorithm_defines="";
 897         $openssl_thread_defines="";
 898         $openssl_sys_defines="";
 899         $openssl_other_defines="";
 900         $libs="";
 901         $target="";
 902         $options="";
 903         $symlink=1;
 904
 905         $argv_unprocessed=0;
 906         $argvstring=join(' ',@argvcopy);
 907
 908 PROCESS_ARGS:
 909         foreach (@argvcopy)
 910                 {
 911                 s /^-no-/no-/; # some people just can't read the instructions
 912
 913                 # rewrite some options in "enable-..." form
 914                 s /^-?-?shared$/enable-shared/;
 915                 s /^sctp$/enable-sctp/;
 916                 s /^threads$/enable-threads/;
 917                 s /^zlib$/enable-zlib/;
 918                 s /^zlib-dynamic$/enable-zlib-dynamic/;
 919
 920                 if (/^no-(.+)$/ || /^disable-(.+)$/)
 921                         {
 922                         if (!($disabled{$1} eq "experimental"))
 923                                 {
 924                                 if ($1 eq "ssl")
 925                                         {
 926                                         $disabled{"ssl3"} = "option(ssl)";
 927                                         }
 928                                 elsif ($1 eq "tls")
 929                                         {
 930                                         $disabled{"tls1"} = "option(tls)"
 931                                         }
 932                                 elsif ($1 eq "ssl3-method")
 933                                         {
 934                                         $disabled{"ssl3-method"} = "option(ssl)";
 935                                         $disabled{"ssl3"} = "option(ssl)";
 936                                         }
 937                                 else
 938                                         {
 939                                         $disabled{$1} = "option";
 940                                         }
 941                                 }
 942                         }
 943                 elsif (/^enable-(.+)$/ || /^experimental-(.+)$/)
 944                         {
 945                         my $algo = $1;
 946                         if ($disabled{$algo} eq "experimental")
 947                                 {
 948                                 die "You are requesting an experimental feature; please say 'experimental-$algo' if you are sure\n"
 949                                         unless (/^experimental-/);
 950                                 push @experimental, $algo;
 951                                 }
 952                         delete $disabled{$algo};
 953
 954                         $threads = 1 if ($algo eq "threads");
 955                         }
 956                 elsif (/^--test-sanity$/)
 957                         {
 958                         exit(&test_sanity());
 959                         }
 960                 elsif (/^--strict-warnings$/)
 961                         {
 962                         $strict_warnings = 1;
 963                         }
 964                 elsif (/^--debug$/)
 965                         {
 966                         $build_prefix = "debug_";
 967                         }
 968                 elsif (/^--release$/)
 969                         {
 970                         $build_prefix = "release_";
 971                         }
 972                 elsif (/^reconfigure/ || /^reconf/)
 973                         {
 974                         if (open(IN,"<$Makefile"))
 975                                 {
 976                                 while (<IN>)
 977                                         {
 978                                         chomp;
 979                                         if (/^CONFIGURE_ARGS=(.*)/)
 980                                                 {
 981                                                 $argvstring=$1;
 982                                                 @argvcopy=split(' ',$argvstring);
 983                                                 die "Incorrect data to reconfigure, please do a normal configuration\n"
 984                                                         if (grep(/^reconf/,@argvcopy));
 985                                                 print "Reconfiguring with: $argvstring\n";
 986                                                 $argv_unprocessed=1;
 987                                                 close(IN);
 988                                                 last PROCESS_ARGS;
 989                                                 }
 990                                         }
 991                                 close(IN);
 992                                 }
 993                         die "Insufficient data to reconfigure, please do a normal configuration\n";
 994                         }
 995                 elsif (/^386$/)
 996                         { $processor=386; }
 997                 elsif (/^fips$/)
 998                         {
 999                         $fips=1;
1000                         }
1001                 elsif (/^rsaref$/)
1002                         {
1003                         # No RSAref support any more since it's not needed.
1004                         # The check for the option is there so scripts aren't
1005                         # broken
1006                         }
1007                 elsif (/^nofipscanistercheck$/)
1008                         {
1009                         $fips = 1;
1010                         $nofipscanistercheck = 1;
1011                         }
1012                 elsif (/^[-+]/)
1013                         {
1014                         if (/^--prefix=(.*)$/)
1015                                 {
1016                                 $prefix=$1;
1017                                 }
1018                         elsif (/^--libdir=(.*)$/)
1019                                 {
1020                                 $libdir=$1;
1021                                 }
1022                         elsif (/^--openssldir=(.*)$/)
1023                                 {
1024                                 $openssldir=$1;
1025                                 }
1026                         elsif (/^--install.prefix=(.*)$/)
1027                                 {
1028                                 $install_prefix=$1;
1029                                 }
1030                         elsif (/^--with-krb5-(dir|lib|include|flavor)=(.*)$/)
1031                                 {
1032                                 $withargs{"krb5-".$1}=$2;
1033                                 }
1034                         elsif (/^--with-zlib-lib=(.*)$/)
1035                                 {
1036                                 $withargs{"zlib-lib"}=$1;
1037                                 }
1038                         elsif (/^--with-zlib-include=(.*)$/)
1039                                 {
1040                                 $withargs{"zlib-include"}="-I$1";
1041                                 }
1042                         elsif (/^--with-fipslibdir=(.*)$/)
1043                                 {
1044                                 $fipslibdir="$1/";
1045                                 }
1046                         elsif (/^--with-baseaddr=(.*)$/)
1047                                 {
1048                                 $baseaddr="$1";
1049                                 }
1050                         elsif (/^--cross-compile-prefix=(.*)$/)
1051                                 {
1052                                 $cross_compile_prefix=$1;
1053                                 }
1054                         elsif (/^--config=(.*)$/)
1055                                 {
1056                                 read_config $1;
1057                                 }
1058                         elsif (/^-[lL](.*)$/ or /^-Wl,/)
1059                                 {
1060                                 $libs.=$_." ";
1061                                 }
1062                         else    # common if (/^[-+]/), just pass down...
1063                                 {
1064                                 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
1065                                 $flags.=$_." ";
1066                                 }
1067                         }
1068                 elsif ($_ =~ /^([^:]+):(.+)$/)
1069                         {
1070                         eval "\$table{\$1} = \"$2\""; # allow $xxx constructs in the string
1071                         $target=$1;
1072                         }
1073                 else
1074                         {
1075                         die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
1076                         $target=$_;
1077                         }
1078
1079                 unless ($_ eq $target || /^no-/ || /^disable-/)
1080                         {
1081                         # "no-..." follows later after implied disactivations
1082                         # have been derived.  (Don't take this too seroiusly,
1083                         # we really only write OPTIONS to the Makefile out of
1084                         # nostalgia.)
1085
1086                         if ($options eq "")
1087                                 { $options = $_; }
1088                         else
1089                                 { $options .= " ".$_; }
1090                         }
1091                 }
1092         }
1093
1094
1095
1096 if ($processor eq "386")
1097         {
1098         $disabled{"sse2"} = "forced";
1099         }
1100
1101 if (!defined($withargs{"krb5-flavor"}) || $withargs{"krb5-flavor"} eq "")
1102         {
1103         $disabled{"krb5"} = "krb5-flavor not specified";
1104         }
1105
1106 if (!defined($disabled{"zlib-dynamic"}))
1107         {
1108         # "zlib-dynamic" was specifically enabled, so enable "zlib"
1109         delete $disabled{"zlib"};
1110         }
1111
1112 if (defined($disabled{"rijndael"}))
1113         {
1114         $disabled{"aes"} = "forced";
1115         }
1116 if (defined($disabled{"des"}))
1117         {
1118         $disabled{"mdc2"} = "forced";
1119         }
1120 if (defined($disabled{"ec"}))
1121         {
1122         $disabled{"ecdsa"} = "forced";
1123         $disabled{"ecdh"} = "forced";
1124         }
1125
1126 # SSL 3.0 and TLS requires MD5 and SHA and either RSA or DSA+DH
1127 if (defined($disabled{"md5"}) || defined($disabled{"sha"})
1128     || (defined($disabled{"rsa"})
1129         && (defined($disabled{"dsa"}) || defined($disabled{"dh"}))))
1130         {
1131         $disabled{"ssl3"} = "forced";
1132         $disabled{"tls1"} = "forced";
1133         }
1134
1135 if (defined($disabled{"tls1"}))
1136         {
1137         $disabled{"tlsext"} = "forced";
1138         }
1139
1140 if (defined($disabled{"ec"}) || defined($disabled{"dsa"})
1141     || defined($disabled{"dh"}))
1142         {
1143         $disabled{"gost"} = "forced";
1144         }
1145
1146 # SRP and HEARTBEATS require TLSEXT
1147 if (defined($disabled{"tlsext"}))
1148         {
1149         $disabled{"srp"} = "forced";
1150         $disabled{"heartbeats"} = "forced";
1151         }
1152
1153 if ($target eq "TABLE") {
1154         foreach $target (sort keys %table) {
1155                 print_table_entry($target, "TABLE");
1156         }
1157         exit 0;
1158 }
1159
1160 if ($target eq "LIST") {
1161         foreach (sort keys %table) {
1162                 print;
1163                 print "\n";
1164         }
1165         exit 0;
1166 }
1167
1168 if ($target eq "HASH") {
1169         print "%table = (\n";
1170         foreach (sort keys %table) {
1171                 print_table_entry($_, "HASH");
1172         }
1173         exit 0;
1174 }
1175
1176 if ($target =~ m/^CygWin32(-.*)$/) {
1177         $target = "Cygwin".$1;
1178 }
1179
1180 print "Configuring for $target\n";
1181
1182 # Support for legacy targets having a name starting with 'debug-'
1183 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
1184 if ($d) {
1185     $build_prefix = "debug_";
1186
1187     # If we do not find debug-foo in the table, the target is set to foo,
1188     # but only if the foo target has a noon-empty debug_cflags or debug_lflags
1189     # attribute.
1190     if (!$table{$target} && ($table{$t}->{debug_cflags}
1191                              || $table{$t}->{debug_lflags})) {
1192         $target = $t;
1193     }
1194 }
1195
1196 &usage if (!defined($table{$target})
1197            || $table{$target}->{template}
1198            || ($build_prefix eq "debug_"
1199                && !($table{$target}->{debug_cflags}
1200                     || $table{$target}->{debug_lflags})));
1201
1202 if ($fips)
1203         {
1204         delete $disabled{"shared"} if ($disabled{"shared"} eq "default");
1205         }
1206
1207 foreach (sort (keys %disabled))
1208         {
1209         $options .= " no-$_";
1210
1211         printf "    no-%-12s %-10s", $_, "[$disabled{$_}]";
1212
1213         if (/^dso$/)
1214                 { $no_dso = 1; }
1215         elsif (/^threads$/)
1216                 { $no_threads = 1; }
1217         elsif (/^shared$/)
1218                 { $no_shared = 1; }
1219         elsif (/^zlib$/)
1220                 { $zlib = 0; }
1221         elsif (/^static-engine$/)
1222                 { }
1223         elsif (/^zlib-dynamic$/)
1224                 { }
1225         elsif (/^symlinks$/)
1226                 { $symlink = 0; }
1227         elsif (/^sse2$/)
1228                 { $no_sse2 = 1; }
1229         else
1230                 {
1231                 my ($ALGO, $algo);
1232                 ($ALGO = $algo = $_) =~ tr/[\-a-z]/[_A-Z]/;
1233
1234                 if (/^asm$/ || /^err$/ || /^hw$/ || /^hw-/)
1235                         {
1236                         $openssl_other_defines .= "#define OPENSSL_NO_$ALGO\n";
1237                         print " OPENSSL_NO_$ALGO";
1238
1239                         if (/^err$/)    { $flags .= "-DOPENSSL_NO_ERR "; }
1240                         elsif (/^asm$/) { $no_asm = 1; }
1241                         }
1242                 else
1243                         {
1244                         ($ALGO,$algo) = ("RMD160","rmd160") if ($algo eq "ripemd");
1245
1246                         $openssl_algorithm_defines .= "#define OPENSSL_NO_$ALGO\n";
1247                         print " OPENSSL_NO_$ALGO";
1248
1249                         if (/^krb5$/)
1250                                 { $no_krb5 = 1; }
1251                         else
1252                                 {
1253                                 push @skip, $algo;
1254                                 # fix-up crypto/directory name(s)
1255                                 $skip[$#skip]="whrlpool" if $algo eq "whirlpool";
1256                                 $skip[$#skip]="ripemd" if $algo eq "rmd160";
1257
1258                                 print " (skip dir)";
1259
1260                                 $depflags .= " -DOPENSSL_NO_$ALGO";
1261                                 }
1262                         }
1263                 }
1264
1265         print "\n";
1266         }
1267
1268 my $exp_cflags = "";
1269
1270 foreach (sort @experimental)
1271         {
1272         my $ALGO;
1273         ($ALGO = $_) =~ tr/[a-z]/[A-Z]/;
1274
1275         # opensslconf.h will set OPENSSL_NO_... unless OPENSSL_EXPERIMENTAL_... is defined
1276         $openssl_experimental_defines .= "#define OPENSSL_NO_$ALGO\n";
1277         $exp_cflags .= " -DOPENSSL_EXPERIMENTAL_$ALGO";
1278         }
1279
1280 my $IsMK1MF=scalar grep /^$target$/,@MK1MF_Builds;
1281
1282 $exe_ext=".exe" if ($target eq "Cygwin" || $target eq "DJGPP" || $target =~ /^mingw/);
1283 $exe_ext=".nlm" if ($target =~ /netware/);
1284 $exe_ext=".pm"  if ($target =~ /vos/);
1285 $openssldir="/usr/local/ssl" if ($openssldir eq "" and $prefix eq "");
1286 $prefix=$openssldir if $prefix eq "";
1287
1288 $default_ranlib= &which("ranlib") or $default_ranlib="true";
1289 $perl=$ENV{'PERL'} or $perl=&which("perl5") or $perl=&which("perl")
1290   or $perl="perl";
1291 my $make = $ENV{'MAKE'} || "make";
1292
1293 $cross_compile_prefix=$ENV{'CROSS_COMPILE'} if $cross_compile_prefix eq "";
1294
1295 chop $openssldir if $openssldir =~ /\/$/;
1296 chop $prefix if $prefix =~ /.\/$/;
1297
1298 $openssldir=$prefix . "/ssl" if $openssldir eq "";
1299 $openssldir=$prefix . "/" . $openssldir if $openssldir !~ /(^\/|^[a-zA-Z]:[\\\/])/;
1300
1301
1302 print "IsMK1MF=$IsMK1MF\n";
1303
1304 # Allow environment CC to override compiler...
1305 my $cc = $ENV{CC} || $table{$t}->{cc};
1306
1307 # For cflags and lflags, add the debug_ or release_ attributes
1308 # Do it in such a way that no spurious space is appended (hence the grep).
1309 my $cflags = join(" ",
1310                   grep { $_ } ($table{$t}->{cflags},
1311                                $table{$t}->{$build_prefix."cflags"}));
1312 my $lflags = join(" ",
1313                   grep { $_ } ($table{$t}->{lflags},
1314                                $table{$t}->{$build_prefix."lflags"}));
1315
1316 my $unistd = $table{$t}->{unistd};
1317 my $thread_cflag = $table{$t}->{thread_cflag};
1318 my $sys_id = $table{$t}->{sys_id};
1319 my $bn_ops = $table{$t}->{bn_ops};
1320 my $cpuid_obj = $table{$t}->{cpuid_obj};
1321 my $bn_obj = $table{$t}->{bn_obj};
1322 my $ec_obj = $table{$t}->{ec_obj};
1323 my $des_obj = $table{$t}->{des_obj};
1324 my $aes_obj = $table{$t}->{aes_obj};
1325 my $bf_obj = $table{$t}->{bf_obj};
1326 my $md5_obj = $table{$t}->{md5_obj};
1327 my $sha1_obj = $table{$t}->{sha1_obj};
1328 my $cast_obj = $table{$t}->{cast_obj};
1329 my $rc4_obj = $table{$t}->{rc4_obj};
1330 my $rmd160_obj = $table{$t}->{rmd160_obj};
1331 my $rc5_obj = $table{$t}->{rc5_obj};
1332 my $wp_obj = $table{$t}->{wp_obj};
1333 my $cmll_obj = $table{$t}->{cmll_obj};
1334 my $modes_obj = $table{$t}->{modes_obj};
1335 my $engines_obj = $table{$t}->{engines_obj};
1336 my $perlasm_scheme = $table{$t}->{perlasm_scheme};
1337 my $dso_scheme = $table{$t}->{dso_scheme};
1338 my $shared_target = $table{$t}->{shared_target};
1339 my $shared_cflag = $table{$t}->{shared_cflag};
1340 my $shared_ldflag = $table{$t}->{shared_ldflag};
1341 my $shared_extension = $table{$t}->{shared_extension};
1342 my $ranlib = $ENV{'RANLIB'} || $table{$t}->{ranlib};
1343 my $ar = $ENV{'AR'} || "ar";
1344 my $arflags = $table{$t}->{arflags};
1345 my $multilib = $table{$t}->{multilib};
1346
1347 # if $prefix/lib$multilib is not an existing directory, then
1348 # assume that it's not searched by linker automatically, in
1349 # which case adding $multilib suffix causes more grief than
1350 # we're ready to tolerate, so don't...
1351 $multilib="" if !-d "$prefix/lib$multilib";
1352
1353 $libdir="lib$multilib" if $libdir eq "";
1354
1355 $cflags = "$cflags$exp_cflags";
1356
1357 # '%' in $lflags is used to split flags to "pre-" and post-flags
1358 my ($prelflags,$postlflags)=split('%',$lflags);
1359 if (defined($postlflags))       { $lflags=$postlflags;  }
1360 else                            { $lflags=$prelflags; undef $prelflags; }
1361
1362 if ($target =~ /^mingw/ && `$cc --target-help 2>&1` !~ m/\-mno\-cygwin/m)
1363         {
1364         $cflags =~ s/\-mno\-cygwin\s*//;
1365         $shared_ldflag =~ s/\-mno\-cygwin\s*//;
1366         }
1367
1368 if ($target =~ /linux.*\-mips/ && !$no_asm && $flags !~ /\-m(ips|arch=)/) {
1369         # minimally required architecture flags for assembly modules
1370         $cflags="-mips2 $cflags" if ($target =~ /mips32/);
1371         $cflags="-mips3 $cflags" if ($target =~ /mips64/);
1372 }
1373
1374 my $no_shared_warn=0;
1375 my $no_user_cflags=0;
1376
1377 if ($flags ne "")       { $cflags="$flags$cflags"; }
1378 else                    { $no_user_cflags=1;       }
1379
1380 # Kerberos settings.  The flavor must be provided from outside, either through
1381 # the script "config" or manually.
1382 if (!$no_krb5)
1383         {
1384         my ($lresolv, $lpath, $lext);
1385         if ($withargs{"krb5-flavor"} =~ /^[Hh]eimdal$/)
1386                 {
1387                 die "Sorry, Heimdal is currently not supported\n";
1388                 }
1389         ##### HACK to force use of Heimdal.
1390         ##### WARNING: Since we don't really have adequate support for Heimdal,
1391         #####          using this will break the build.  You'll have to make
1392         #####          changes to the source, and if you do, please send
1393         #####          patches to openssl-dev@openssl.org
1394         if ($withargs{"krb5-flavor"} =~ /^force-[Hh]eimdal$/)
1395                 {
1396                 warn "Heimdal isn't really supported.  Your build WILL break\n";
1397                 warn "If you fix the problems, please send a patch to openssl-dev\@openssl.org\n";
1398                 $withargs{"krb5-dir"} = "/usr/heimdal"
1399                         if $withargs{"krb5-dir"} eq "";
1400                 $withargs{"krb5-lib"} = "-L".$withargs{"krb5-dir"}.
1401                         "/lib -lgssapi -lkrb5 -lcom_err"
1402                         if $withargs{"krb5-lib"} eq "" && !$IsMK1MF;
1403                 $cflags="-DKRB5_HEIMDAL $cflags";
1404                 }
1405         if ($withargs{"krb5-flavor"} =~ /^[Mm][Ii][Tt]/)
1406                 {
1407                 $withargs{"krb5-dir"} = "/usr/kerberos"
1408                         if $withargs{"krb5-dir"} eq "";
1409                 $withargs{"krb5-lib"} = "-L".$withargs{"krb5-dir"}.
1410                         "/lib -lgssapi_krb5 -lkrb5 -lcom_err -lk5crypto"
1411                         if $withargs{"krb5-lib"} eq "" && !$IsMK1MF;
1412                 $cflags="-DKRB5_MIT $cflags";
1413                 $withargs{"krb5-flavor"} =~ s/^[Mm][Ii][Tt][._-]*//;
1414                 if ($withargs{"krb5-flavor"} =~ /^1[._-]*[01]/)
1415                         {
1416                         $cflags="-DKRB5_MIT_OLD11 $cflags";
1417                         }
1418                 }
1419         LRESOLV:
1420         foreach $lpath ("/lib", "/usr/lib")
1421                 {
1422                 foreach $lext ("a", "so")
1423                         {
1424                         $lresolv = "$lpath/libresolv.$lext";
1425                         last LRESOLV    if (-r "$lresolv");
1426                         $lresolv = "";
1427                         }
1428                 }
1429         $withargs{"krb5-lib"} .= " -lresolv"
1430                 if ("$lresolv" ne "");
1431         $withargs{"krb5-include"} = "-I".$withargs{"krb5-dir"}."/include"
1432                 if $withargs{"krb5-include"} eq "" &&
1433                    $withargs{"krb5-dir"} ne "";
1434         }
1435
1436 # The DSO code currently always implements all functions so that no
1437 # applications will have to worry about that from a compilation point
1438 # of view. However, the "method"s may return zero unless that platform
1439 # has support compiled in for them. Currently each method is enabled
1440 # by a define "DSO_<name>" ... we translate the "dso_scheme" config
1441 # string entry into using the following logic;
1442 my $dso_cflags;
1443 if (!$no_dso && $dso_scheme ne "")
1444         {
1445         $dso_scheme =~ tr/[a-z]/[A-Z]/;
1446         if ($dso_scheme eq "DLFCN")
1447                 {
1448                 $dso_cflags = "-DDSO_DLFCN -DHAVE_DLFCN_H";
1449                 }
1450         elsif ($dso_scheme eq "DLFCN_NO_H")
1451                 {
1452                 $dso_cflags = "-DDSO_DLFCN";
1453                 }
1454         else
1455                 {
1456                 $dso_cflags = "-DDSO_$dso_scheme";
1457                 }
1458         $cflags = "$dso_cflags $cflags";
1459         }
1460
1461 my $thread_cflags;
1462 my $thread_defines;
1463 if ($thread_cflag ne "(unknown)" && !$no_threads)
1464         {
1465         # If we know how to do it, support threads by default.
1466         $threads = 1;
1467         }
1468 if ($thread_cflag eq "(unknown)" && $threads)
1469         {
1470         # If the user asked for "threads", [s]he is also expected to
1471         # provide any system-dependent compiler options that are
1472         # necessary.
1473         if ($no_user_cflags)
1474                 {
1475                 print "You asked for multi-threading support, but didn't\n";
1476                 print "provide any system-specific compiler options\n";
1477                 exit(1);
1478                 }
1479         $thread_cflags="-DOPENSSL_THREADS $cflags" ;
1480         $thread_defines .= "#define OPENSSL_THREADS\n";
1481         }
1482 else
1483         {
1484         $thread_cflags="-DOPENSSL_THREADS $thread_cflag $cflags";
1485         $thread_defines .= "#define OPENSSL_THREADS\n";
1486 #       my $def;
1487 #       foreach $def (split ' ',$thread_cflag)
1488 #               {
1489 #               if ($def =~ s/^-D// && $def !~ /^_/)
1490 #                       {
1491 #                       $thread_defines .= "#define $def\n";
1492 #                       }
1493 #               }
1494         }
1495
1496 $lflags="$libs$lflags" if ($libs ne "");
1497
1498 if ($no_asm)
1499         {
1500         $cpuid_obj=$bn_obj=$ec_obj=
1501         $des_obj=$aes_obj=$bf_obj=$cast_obj=$rc4_obj=$rc5_obj=$cmll_obj=
1502         $modes_obj=$sha1_obj=$md5_obj=$rmd160_obj=$wp_obj=$engines_obj="";
1503         $cflags=~s/\-D[BL]_ENDIAN//             if ($fips);
1504         $thread_cflags=~s/\-D[BL]_ENDIAN//      if ($fips);
1505         }
1506 elsif (defined($disabled{ec2m}))
1507         {
1508         $bn_obj =~ s/\w+-gf2m.o//;
1509         }
1510
1511 if (!$no_shared)
1512         {
1513         $cast_obj="";   # CAST assembler is not PIC
1514         }
1515
1516 if ($threads)
1517         {
1518         $cflags=$thread_cflags;
1519         $openssl_thread_defines .= $thread_defines;
1520         }
1521
1522 if ($zlib)
1523         {
1524         $cflags = "-DZLIB $cflags";
1525         if (defined($disabled{"zlib-dynamic"}))
1526                 {
1527                 if (defined($withargs{"zlib-lib"}))
1528                         {
1529                         $lflags = "$lflags -L" . $withargs{"zlib-lib"} . " -lz";
1530                         }
1531                 else
1532                         {
1533                         $lflags = "$lflags -lz";
1534                         }
1535                 }
1536         else
1537                 {
1538                 $cflags = "-DZLIB_SHARED $cflags";
1539                 }
1540         }
1541
1542 #Build the library with OPENSSL_USE_DEPRECATED if deprecation is not disabled
1543 if(!defined($disabled{"deprecated"}))
1544         {
1545         $cflags = "-DOPENSSL_USE_DEPRECATED $cflags";
1546         }
1547
1548 # You will find shlib_mark1 and shlib_mark2 explained in Makefile.org
1549 my $shared_mark = "";
1550 if ($shared_target eq "")
1551         {
1552         $no_shared_warn = 1 if !$no_shared && !$fips;
1553         $no_shared = 1;
1554         }
1555 if (!$no_shared)
1556         {
1557         if ($shared_cflag ne "")
1558                 {
1559                 $cflags = "$shared_cflag -DOPENSSL_PIC $cflags";
1560                 }
1561         }
1562
1563 if (!$IsMK1MF)
1564         {
1565         # add {no-}static-engine to options to allow mkdef.pl to work without extra arguments
1566         if ($no_shared)
1567                 {
1568                 $openssl_other_defines.="#define OPENSSL_NO_DYNAMIC_ENGINE\n";
1569                 $options.=" static-engine";
1570                 }
1571         else
1572                 {
1573                 $openssl_other_defines.="#define OPENSSL_NO_STATIC_ENGINE\n";
1574                 $options.=" no-static-engine";
1575                 }
1576         }
1577
1578 $cpuid_obj.=" uplink.o uplink-x86.o" if ($cflags =~ /\-DOPENSSL_USE_APPLINK/);
1579
1580 #
1581 # Platform fix-ups
1582 #
1583 if ($target =~ /\-icc$/)        # Intel C compiler
1584         {
1585         my $iccver=0;
1586         if (open(FD,"$cc -V 2>&1 |"))
1587                 {
1588                 while(<FD>) { $iccver=$1 if (/Version ([0-9]+)\./); }
1589                 close(FD);
1590                 }
1591         if ($iccver>=8)
1592                 {
1593                 $cflags=~s/\-KPIC/-fPIC/;
1594                 # Eliminate unnecessary dependency from libirc.a. This is
1595                 # essential for shared library support, as otherwise
1596                 # apps/openssl can end up in endless loop upon startup...
1597                 $cflags.=" -Dmemcpy=__builtin_memcpy -Dmemset=__builtin_memset";
1598                 }
1599         if ($iccver>=9)
1600                 {
1601                 $lflags.=" -i-static";
1602                 $lflags=~s/\-no_cpprt/-no-cpprt/;
1603                 }
1604         if ($iccver>=10)
1605                 {
1606                 $lflags=~s/\-i\-static/-static-intel/;
1607                 }
1608         if ($iccver>=11)
1609                 {
1610                 $cflags.=" -no-intel-extensions";       # disable Cilk
1611                 $lflags=~s/\-no\-cpprt/-no-cxxlib/;
1612                 }
1613         }
1614
1615 # Unlike other OSes (like Solaris, Linux, Tru64, IRIX) BSD run-time
1616 # linkers (tested OpenBSD, NetBSD and FreeBSD) "demand" RPATH set on
1617 # .so objects. Apparently application RPATH is not global and does
1618 # not apply to .so linked with other .so. Problem manifests itself
1619 # when libssl.so fails to load libcrypto.so. One can argue that we
1620 # should engrave this into Makefile.shared rules or into BSD-* config
1621 # lines above. Meanwhile let's try to be cautious and pass -rpath to
1622 # linker only when --prefix is not /usr.
1623 if ($target =~ /^BSD\-/)
1624         {
1625         $shared_ldflag.=" -Wl,-rpath,\$(LIBRPATH)" if ($prefix !~ m|^/usr[/]*$|);
1626         }
1627
1628 if ($sys_id ne "")
1629         {
1630         #$cflags="-DOPENSSL_SYS_$sys_id $cflags";
1631         $openssl_sys_defines="#define OPENSSL_SYS_$sys_id\n";
1632         }
1633
1634 if ($ranlib eq "")
1635         {
1636         $ranlib = $default_ranlib;
1637         }
1638
1639 #my ($bn1)=split(/\s+/,$bn_obj);
1640 #$bn1 = "" unless defined $bn1;
1641 #$bn1=$bn_asm unless ($bn1 =~ /\.o$/);
1642 #$bn_obj="$bn1";
1643
1644 $cpuid_obj="" if ($processor eq "386");
1645
1646 $bn_obj = $bn_asm unless $bn_obj ne "";
1647 # bn-586 is the only one implementing bn_*_part_words
1648 $cflags.=" -DOPENSSL_BN_ASM_PART_WORDS" if ($bn_obj =~ /bn-586/);
1649 $cflags.=" -DOPENSSL_IA32_SSE2" if (!$no_sse2 && $bn_obj =~ /86/);
1650
1651 $cflags.=" -DOPENSSL_BN_ASM_MONT" if ($bn_obj =~ /-mont/);
1652 $cflags.=" -DOPENSSL_BN_ASM_MONT5" if ($bn_obj =~ /-mont5/);
1653 $cflags.=" -DOPENSSL_BN_ASM_GF2m" if ($bn_obj =~ /-gf2m/);
1654
1655 if ($fips)
1656         {
1657         $openssl_other_defines.="#define OPENSSL_FIPS\n";
1658         }
1659
1660 $cpuid_obj="mem_clr.o"  unless ($cpuid_obj =~ /\.o$/);
1661 $des_obj=$des_enc       unless ($des_obj =~ /\.o$/);
1662 $bf_obj=$bf_enc         unless ($bf_obj =~ /\.o$/);
1663 $cast_obj=$cast_enc     unless ($cast_obj =~ /\.o$/);
1664 $rc4_obj=$rc4_enc       unless ($rc4_obj =~ /\.o$/);
1665 $rc5_obj=$rc5_enc       unless ($rc5_obj =~ /\.o$/);
1666 if ($sha1_obj =~ /\.o$/)
1667         {
1668 #       $sha1_obj=$sha1_enc;
1669         $cflags.=" -DSHA1_ASM"   if ($sha1_obj =~ /sx86/ || $sha1_obj =~ /sha1/);
1670         $cflags.=" -DSHA256_ASM" if ($sha1_obj =~ /sha256/);
1671         $cflags.=" -DSHA512_ASM" if ($sha1_obj =~ /sha512/);
1672         if ($sha1_obj =~ /sse2/)
1673             {   if ($no_sse2)
1674                 {   $sha1_obj =~ s/\S*sse2\S+//;        }
1675                 elsif ($cflags !~ /OPENSSL_IA32_SSE2/)
1676                 {   $cflags.=" -DOPENSSL_IA32_SSE2";    }
1677             }
1678         }
1679 if ($md5_obj =~ /\.o$/)
1680         {
1681 #       $md5_obj=$md5_enc;
1682         $cflags.=" -DMD5_ASM";
1683         }
1684 if ($rmd160_obj =~ /\.o$/)
1685         {
1686 #       $rmd160_obj=$rmd160_enc;
1687         $cflags.=" -DRMD160_ASM";
1688         }
1689 if ($aes_obj =~ /\.o$/)
1690         {
1691         $cflags.=" -DAES_ASM" if ($aes_obj =~ m/\baes\-/);;
1692         # aes-ctr.o is not a real file, only indication that assembler
1693         # module implements AES_ctr32_encrypt...
1694         $cflags.=" -DAES_CTR_ASM" if ($aes_obj =~ s/\s*aes\-ctr\.o//);
1695         # aes-xts.o indicates presence of AES_xts_[en|de]crypt...
1696         $cflags.=" -DAES_XTS_ASM" if ($aes_obj =~ s/\s*aes\-xts\.o//);
1697         $aes_obj =~ s/\s*(vpaes|aesni)\-x86\.o//g if ($no_sse2);
1698         $cflags.=" -DVPAES_ASM" if ($aes_obj =~ m/vpaes/);
1699         $cflags.=" -DBSAES_ASM" if ($aes_obj =~ m/bsaes/);
1700         }
1701 else    {
1702         $aes_obj=$aes_enc;
1703         }
1704 $wp_obj="" if ($wp_obj =~ /mmx/ && $processor eq "386");
1705 if ($wp_obj =~ /\.o$/ && !$disabled{"whirlpool"})
1706         {
1707         $cflags.=" -DWHIRLPOOL_ASM";
1708         }
1709 else    {
1710         $wp_obj="wp_block.o";
1711         }
1712 $cmll_obj=$cmll_enc     unless ($cmll_obj =~ /.o$/);
1713 if ($modes_obj =~ /ghash\-/)
1714         {
1715         $cflags.=" -DGHASH_ASM";
1716         }
1717 if ($ec_obj =~ /ecp_nistz256/)
1718         {
1719         $cflags.=" -DECP_NISTZ256_ASM";
1720         }
1721
1722 # "Stringify" the C flags string.  This permits it to be made part of a string
1723 # and works as well on command lines.
1724 $cflags =~ s/([\\\"])/\\\1/g;
1725
1726 my $version = "unknown";
1727 my $version_num = "unknown";
1728 my $major = "unknown";
1729 my $minor = "unknown";
1730 my $shlib_version_number = "unknown";
1731 my $shlib_version_history = "unknown";
1732 my $shlib_major = "unknown";
1733 my $shlib_minor = "unknown";
1734
1735 open(IN,'<crypto/opensslv.h') || die "unable to read opensslv.h:$!\n";
1736 while (<IN>)
1737         {
1738         $version=$1 if /OPENSSL.VERSION.TEXT.*OpenSSL (\S+) /;
1739         $version_num=$1 if /OPENSSL.VERSION.NUMBER.*0x(\S+)/;
1740         $shlib_version_number=$1 if /SHLIB_VERSION_NUMBER *"([^"]+)"/;
1741         $shlib_version_history=$1 if /SHLIB_VERSION_HISTORY *"([^"]*)"/;
1742         }
1743 close(IN);
1744 if ($shlib_version_history ne "") { $shlib_version_history .= ":"; }
1745
1746 if ($version =~ /(^[0-9]*)\.([0-9\.]*)/)
1747         {
1748         $major=$1;
1749         $minor=$2;
1750         }
1751
1752 if ($shlib_version_number =~ /(^[0-9]*)\.([0-9\.]*)/)
1753         {
1754         $shlib_major=$1;
1755         $shlib_minor=$2;
1756         }
1757
1758 if ($strict_warnings)
1759         {
1760         my $wopt;
1761         die "ERROR --strict-warnings requires gcc or clang" unless ($cc =~ /gcc$/ or $cc =~ /clang$/);
1762         foreach $wopt (split /\s+/, $gcc_devteam_warn)
1763                 {
1764                 $cflags .= " $wopt" unless ($cflags =~ /$wopt/)
1765                 }
1766         }
1767
1768 open(IN,"<Makefile.org") || die "unable to read Makefile.org:$!\n";
1769 unlink("$Makefile.new") || die "unable to remove old $Makefile.new:$!\n" if -e "$Makefile.new";
1770 open(OUT,">$Makefile.new") || die "unable to create $Makefile.new:$!\n";
1771 print OUT "### Generated automatically from Makefile.org by Configure.\n\n";
1772 my $sdirs=0;
1773
1774 while (<IN>)
1775         {
1776         chomp;
1777         $sdirs = 1 if /^SDIRS=/;
1778         if ($sdirs) {
1779                 my $dir;
1780                 foreach $dir (@skip) {
1781                         s/(\s)$dir /$1/;
1782                         s/\s$dir$//;
1783                         }
1784                 }
1785         $sdirs = 0 unless /\\$/;
1786         s/fips // if (/^DIRS=/ && !$fips);
1787         s/engines // if (/^DIRS=/ && $disabled{"engine"});
1788         s/ccgost// if (/^ENGDIRS=/ && $disabled{"gost"});
1789         s/^VERSION=.*/VERSION=$version/;
1790         s/^MAJOR=.*/MAJOR=$major/;
1791         s/^MINOR=.*/MINOR=$minor/;
1792         s/^SHLIB_VERSION_NUMBER=.*/SHLIB_VERSION_NUMBER=$shlib_version_number/;
1793         s/^SHLIB_VERSION_HISTORY=.*/SHLIB_VERSION_HISTORY=$shlib_version_history/;
1794         s/^SHLIB_MAJOR=.*/SHLIB_MAJOR=$shlib_major/;
1795         s/^SHLIB_MINOR=.*/SHLIB_MINOR=$shlib_minor/;
1796         s/^SHLIB_EXT=.*/SHLIB_EXT=$shared_extension/;
1797         s/^INSTALLTOP=.*$/INSTALLTOP=$prefix/;
1798         s/^MULTILIB=.*$/MULTILIB=$multilib/;
1799         s/^OPENSSLDIR=.*$/OPENSSLDIR=$openssldir/;
1800         s/^LIBDIR=.*$/LIBDIR=$libdir/;
1801         s/^INSTALL_PREFIX=.*$/INSTALL_PREFIX=$install_prefix/;
1802         s/^PLATFORM=.*$/PLATFORM=$target/;
1803         s/^OPTIONS=.*$/OPTIONS=$options/;
1804         s/^CONFIGURE_ARGS=.*$/CONFIGURE_ARGS=$argvstring/;
1805         if ($cross_compile_prefix)
1806                 {
1807                 s/^CC=.*$/CROSS_COMPILE= $cross_compile_prefix\nCC= \$\(CROSS_COMPILE\)$cc/;
1808                 s/^AR=\s*/AR= \$\(CROSS_COMPILE\)/;
1809                 s/^NM=\s*/NM= \$\(CROSS_COMPILE\)/;
1810                 s/^RANLIB=\s*/RANLIB= \$\(CROSS_COMPILE\)/;
1811                 s/^MAKEDEPPROG=.*$/MAKEDEPPROG= \$\(CROSS_COMPILE\)$cc/ if $cc eq "gcc";
1812                 }
1813         else    {
1814                 s/^CC=.*$/CC= $cc/;
1815                 s/^AR=\s*ar/AR= $ar/;
1816                 s/^RANLIB=.*/RANLIB= $ranlib/;
1817                 s/^MAKEDEPPROG=.*$/MAKEDEPPROG= $cc/ if $cc eq "gcc" || ($cc eq 'cc' && $target =~ /darwin/);
1818                 }
1819         s/^CFLAG=.*$/CFLAG= $cflags/;
1820         s/^DEPFLAG=.*$/DEPFLAG=$depflags/;
1821         s/^PEX_LIBS=.*$/PEX_LIBS= $prelflags/;
1822         s/^EX_LIBS=.*$/EX_LIBS= $lflags/;
1823         s/^EXE_EXT=.*$/EXE_EXT= $exe_ext/;
1824         s/^CPUID_OBJ=.*$/CPUID_OBJ= $cpuid_obj/;
1825         s/^BN_ASM=.*$/BN_ASM= $bn_obj/;
1826         s/^EC_ASM=.*$/EC_ASM= $ec_obj/;
1827         s/^DES_ENC=.*$/DES_ENC= $des_obj/;
1828         s/^AES_ENC=.*$/AES_ENC= $aes_obj/;
1829         s/^BF_ENC=.*$/BF_ENC= $bf_obj/;
1830         s/^CAST_ENC=.*$/CAST_ENC= $cast_obj/;
1831         s/^RC4_ENC=.*$/RC4_ENC= $rc4_obj/;
1832         s/^RC5_ENC=.*$/RC5_ENC= $rc5_obj/;
1833         s/^MD5_ASM_OBJ=.*$/MD5_ASM_OBJ= $md5_obj/;
1834         s/^SHA1_ASM_OBJ=.*$/SHA1_ASM_OBJ= $sha1_obj/;
1835         s/^RMD160_ASM_OBJ=.*$/RMD160_ASM_OBJ= $rmd160_obj/;
1836         s/^WP_ASM_OBJ=.*$/WP_ASM_OBJ= $wp_obj/;
1837         s/^CMLL_ENC=.*$/CMLL_ENC= $cmll_obj/;
1838         s/^MODES_ASM_OBJ.=*$/MODES_ASM_OBJ= $modes_obj/;
1839         s/^ENGINES_ASM_OBJ.=*$/ENGINES_ASM_OBJ= $engines_obj/;
1840         s/^PERLASM_SCHEME=.*$/PERLASM_SCHEME= $perlasm_scheme/;
1841         s/^PROCESSOR=.*/PROCESSOR= $processor/;
1842         s/^ARFLAGS=.*/ARFLAGS= $arflags/;
1843         s/^PERL=.*/PERL= $perl/;
1844         s/^KRB5_INCLUDES=.*/KRB5_INCLUDES=$withargs{"krb5-include"}/;
1845         s/^LIBKRB5=.*/LIBKRB5=$withargs{"krb5-lib"}/;
1846         s/^LIBZLIB=.*/LIBZLIB=$withargs{"zlib-lib"}/;
1847         s/^ZLIB_INCLUDE=.*/ZLIB_INCLUDE=$withargs{"zlib-include"}/;
1848         s/^FIPSLIBDIR=.*/FIPSLIBDIR=$fipslibdir/;
1849         s/^FIPSCANLIB=.*/FIPSCANLIB=libcrypto/ if $fips;
1850         s/^SHARED_FIPS=.*/SHARED_FIPS=/;
1851         s/^SHLIBDIRS=.*/SHLIBDIRS= crypto ssl/;
1852         s/^BASEADDR=.*/BASEADDR=$baseaddr/;
1853         s/^SHLIB_TARGET=.*/SHLIB_TARGET=$shared_target/;
1854         s/^SHLIB_MARK=.*/SHLIB_MARK=$shared_mark/;
1855         s/^SHARED_LIBS=.*/SHARED_LIBS=\$(SHARED_CRYPTO) \$(SHARED_SSL)/ if (!$no_shared);
1856         if ($shared_extension ne "" && $shared_extension =~ /^\.s([ol])\.[^\.]*$/)
1857                 {
1858                 my $sotmp = $1;
1859                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.s$sotmp/;
1860                 }
1861         elsif ($shared_extension ne "" && $shared_extension =~ /^\.[^\.]*\.dylib$/)
1862                 {
1863                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.dylib/;
1864                 }
1865         elsif ($shared_extension ne "" && $shared_extension =~ /^\.s([ol])\.[^\.]*\.[^\.]*$/)
1866                 {
1867                 my $sotmp = $1;
1868                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.s$sotmp.\$(SHLIB_MAJOR) .s$sotmp/;
1869                 }
1870         elsif ($shared_extension ne "" && $shared_extension =~ /^\.[^\.]*\.[^\.]*\.dylib$/)
1871                 {
1872                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.\$(SHLIB_MAJOR).dylib .dylib/;
1873                 }
1874         s/^SHARED_LDFLAGS=.*/SHARED_LDFLAGS=$shared_ldflag/;
1875         print OUT $_."\n";
1876         }
1877 close(IN);
1878 close(OUT);
1879 rename($Makefile,"$Makefile.bak") || die "unable to rename $Makefile\n" if -e $Makefile;
1880 rename("$Makefile.new",$Makefile) || die "unable to rename $Makefile.new\n";
1881
1882 print "CC            =$cc\n";
1883 print "CFLAG         =$cflags\n";
1884 print "EX_LIBS       =$lflags\n";
1885 print "CPUID_OBJ     =$cpuid_obj\n";
1886 print "BN_ASM        =$bn_obj\n";
1887 print "EC_ASM        =$ec_obj\n";
1888 print "DES_ENC       =$des_obj\n";
1889 print "AES_ENC       =$aes_obj\n";
1890 print "BF_ENC        =$bf_obj\n";
1891 print "CAST_ENC      =$cast_obj\n";
1892 print "RC4_ENC       =$rc4_obj\n";
1893 print "RC5_ENC       =$rc5_obj\n";
1894 print "MD5_OBJ_ASM   =$md5_obj\n";
1895 print "SHA1_OBJ_ASM  =$sha1_obj\n";
1896 print "RMD160_OBJ_ASM=$rmd160_obj\n";
1897 print "CMLL_ENC      =$cmll_obj\n";
1898 print "MODES_OBJ     =$modes_obj\n";
1899 print "ENGINES_OBJ   =$engines_obj\n";
1900 print "PROCESSOR     =$processor\n";
1901 print "RANLIB        =$ranlib\n";
1902 print "ARFLAGS       =$arflags\n";
1903 print "PERL          =$perl\n";
1904 print "KRB5_INCLUDES =",$withargs{"krb5-include"},"\n"
1905         if $withargs{"krb5-include"} ne "";
1906
1907 my $des_ptr=0;
1908 my $des_risc1=0;
1909 my $des_risc2=0;
1910 my $des_unroll=0;
1911 my $bn_ll=0;
1912 my $def_int=2;
1913 my $rc4_int=$def_int;
1914 my $md2_int=$def_int;
1915 my $idea_int=$def_int;
1916 my $rc2_int=$def_int;
1917 my $rc4_idx=0;
1918 my $rc4_chunk=0;
1919 my $bf_ptr=0;
1920 my @type=("char","short","int","long");
1921 my ($b64l,$b64,$b32,$b16,$b8)=(0,0,1,0,0);
1922 my $export_var_as_fn=0;
1923
1924 my $des_int;
1925
1926 foreach (sort split(/\s+/,$bn_ops))
1927         {
1928         $des_ptr=1 if /DES_PTR/;
1929         $des_risc1=1 if /DES_RISC1/;
1930         $des_risc2=1 if /DES_RISC2/;
1931         $des_unroll=1 if /DES_UNROLL/;
1932         $des_int=1 if /DES_INT/;
1933         $bn_ll=1 if /BN_LLONG/;
1934         $rc4_int=0 if /RC4_CHAR/;
1935         $rc4_int=3 if /RC4_LONG/;
1936         $rc4_idx=1 if /RC4_INDEX/;
1937         $rc4_chunk=1 if /RC4_CHUNK/;
1938         $rc4_chunk=2 if /RC4_CHUNK_LL/;
1939         $md2_int=0 if /MD2_CHAR/;
1940         $md2_int=3 if /MD2_LONG/;
1941         $idea_int=1 if /IDEA_SHORT/;
1942         $idea_int=3 if /IDEA_LONG/;
1943         $rc2_int=1 if /RC2_SHORT/;
1944         $rc2_int=3 if /RC2_LONG/;
1945         $bf_ptr=1 if $_ eq "BF_PTR";
1946         $bf_ptr=2 if $_ eq "BF_PTR2";
1947         ($b64l,$b64,$b32,$b16,$b8)=(0,1,0,0,0) if /SIXTY_FOUR_BIT/;
1948         ($b64l,$b64,$b32,$b16,$b8)=(1,0,0,0,0) if /SIXTY_FOUR_BIT_LONG/;
1949         ($b64l,$b64,$b32,$b16,$b8)=(0,0,1,0,0) if /THIRTY_TWO_BIT/;
1950         ($b64l,$b64,$b32,$b16,$b8)=(0,0,0,1,0) if /SIXTEEN_BIT/;
1951         ($b64l,$b64,$b32,$b16,$b8)=(0,0,0,0,1) if /EIGHT_BIT/;
1952         $export_var_as_fn=1 if /EXPORT_VAR_AS_FN/;
1953         }
1954
1955 open(IN,'<crypto/opensslconf.h.in') || die "unable to read crypto/opensslconf.h.in:$!\n";
1956 unlink("crypto/opensslconf.h.new") || die "unable to remove old crypto/opensslconf.h.new:$!\n" if -e "crypto/opensslconf.h.new";
1957 open(OUT,'>crypto/opensslconf.h.new') || die "unable to create crypto/opensslconf.h.new:$!\n";
1958 print OUT "/* opensslconf.h */\n";
1959 print OUT "/* WARNING: Generated automatically from opensslconf.h.in by Configure. */\n\n";
1960
1961 print OUT "#ifdef  __cplusplus\n";
1962 print OUT "extern \"C\" {\n";
1963 print OUT "#endif\n";
1964 print OUT "/* OpenSSL was configured with the following options: */\n";
1965 my $openssl_algorithm_defines_trans = $openssl_algorithm_defines;
1966 $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;
1967 $openssl_algorithm_defines_trans =~ s/^\s*#\s*define\s+OPENSSL_(.*)/# if defined(OPENSSL_$1) \&\& !defined($1)\n#  define $1\n# endif/mg;
1968 $openssl_algorithm_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1969 $openssl_algorithm_defines = "   /* no ciphers excluded */\n" if $openssl_algorithm_defines eq "";
1970 $openssl_thread_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1971 $openssl_sys_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1972 $openssl_other_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1973 print OUT $openssl_sys_defines;
1974 print OUT "#ifndef OPENSSL_DOING_MAKEDEPEND\n\n";
1975 print OUT $openssl_experimental_defines;
1976 print OUT "\n";
1977 print OUT $openssl_algorithm_defines;
1978 print OUT "\n#endif /* OPENSSL_DOING_MAKEDEPEND */\n\n";
1979 print OUT $openssl_thread_defines;
1980 print OUT $openssl_other_defines,"\n";
1981
1982 print OUT "/* The OPENSSL_NO_* macros are also defined as NO_* if the application\n";
1983 print OUT "   asks for it.  This is a transient feature that is provided for those\n";
1984 print OUT "   who haven't had the time to do the appropriate changes in their\n";
1985 print OUT "   applications.  */\n";
1986 print OUT "#ifdef OPENSSL_ALGORITHM_DEFINES\n";
1987 print OUT $openssl_algorithm_defines_trans;
1988 print OUT "#endif\n\n";
1989
1990 print OUT "#define OPENSSL_CPUID_OBJ\n\n" if ($cpuid_obj ne "mem_clr.o");
1991
1992 while (<IN>)
1993         {
1994         if      (/^#define\s+OPENSSLDIR/)
1995                 {
1996                 my $foo = $openssldir;
1997                 $foo =~ s/\\/\\\\/g;
1998                 print OUT "#define OPENSSLDIR \"$foo\"\n";
1999                 }
2000         elsif   (/^#define\s+ENGINESDIR/)
2001                 {
2002                 my $foo = "$prefix/$libdir/engines";
2003                 $foo =~ s/\\/\\\\/g;
2004                 print OUT "#define ENGINESDIR \"$foo\"\n";
2005                 }
2006         elsif   (/^#((define)|(undef))\s+OPENSSL_EXPORT_VAR_AS_FUNCTION/)
2007                 { printf OUT "#undef OPENSSL_EXPORT_VAR_AS_FUNCTION\n"
2008                         if $export_var_as_fn;
2009                   printf OUT "#%s OPENSSL_EXPORT_VAR_AS_FUNCTION\n",
2010                         ($export_var_as_fn)?"define":"undef"; }
2011         elsif   (/^#define\s+OPENSSL_UNISTD/)
2012                 {
2013                 $unistd = "<unistd.h>" if $unistd eq "";
2014                 print OUT "#define OPENSSL_UNISTD $unistd\n";
2015                 }
2016         elsif   (/^#((define)|(undef))\s+SIXTY_FOUR_BIT_LONG/)
2017                 { printf OUT "#%s SIXTY_FOUR_BIT_LONG\n",($b64l)?"define":"undef"; }
2018         elsif   (/^#((define)|(undef))\s+SIXTY_FOUR_BIT/)
2019                 { printf OUT "#%s SIXTY_FOUR_BIT\n",($b64)?"define":"undef"; }
2020         elsif   (/^#((define)|(undef))\s+THIRTY_TWO_BIT/)
2021                 { printf OUT "#%s THIRTY_TWO_BIT\n",($b32)?"define":"undef"; }
2022         elsif   (/^#((define)|(undef))\s+SIXTEEN_BIT/)
2023                 { printf OUT "#%s SIXTEEN_BIT\n",($b16)?"define":"undef"; }
2024         elsif   (/^#((define)|(undef))\s+EIGHT_BIT/)
2025                 { printf OUT "#%s EIGHT_BIT\n",($b8)?"define":"undef"; }
2026         elsif   (/^#((define)|(undef))\s+BN_LLONG\s*$/)
2027                 { printf OUT "#%s BN_LLONG\n",($bn_ll)?"define":"undef"; }
2028         elsif   (/^\#define\s+DES_LONG\s+.*/)
2029                 { printf OUT "#define DES_LONG unsigned %s\n",
2030                         ($des_int)?'int':'long'; }
2031         elsif   (/^\#(define|undef)\s+DES_PTR/)
2032                 { printf OUT "#%s DES_PTR\n",($des_ptr)?'define':'undef'; }
2033         elsif   (/^\#(define|undef)\s+DES_RISC1/)
2034                 { printf OUT "#%s DES_RISC1\n",($des_risc1)?'define':'undef'; }
2035         elsif   (/^\#(define|undef)\s+DES_RISC2/)
2036                 { printf OUT "#%s DES_RISC2\n",($des_risc2)?'define':'undef'; }
2037         elsif   (/^\#(define|undef)\s+DES_UNROLL/)
2038                 { printf OUT "#%s DES_UNROLL\n",($des_unroll)?'define':'undef'; }
2039         elsif   (/^#define\s+RC4_INT\s/)
2040                 { printf OUT "#define RC4_INT unsigned %s\n",$type[$rc4_int]; }
2041         elsif   (/^#undef\s+RC4_CHUNK/)
2042                 {
2043                 printf OUT "#undef RC4_CHUNK\n" if $rc4_chunk==0;
2044                 printf OUT "#define RC4_CHUNK unsigned long\n" if $rc4_chunk==1;
2045                 printf OUT "#define RC4_CHUNK unsigned long long\n" if $rc4_chunk==2;
2046                 }
2047         elsif   (/^#((define)|(undef))\s+RC4_INDEX/)
2048                 { printf OUT "#%s RC4_INDEX\n",($rc4_idx)?"define":"undef"; }
2049         elsif (/^#(define|undef)\s+I386_ONLY/)
2050                 { printf OUT "#%s I386_ONLY\n", ($processor eq "386")?
2051                         "define":"undef"; }
2052         elsif   (/^#define\s+MD2_INT\s/)
2053                 { printf OUT "#define MD2_INT unsigned %s\n",$type[$md2_int]; }
2054         elsif   (/^#define\s+IDEA_INT\s/)
2055                 {printf OUT "#define IDEA_INT unsigned %s\n",$type[$idea_int];}
2056         elsif   (/^#define\s+RC2_INT\s/)
2057                 {printf OUT "#define RC2_INT unsigned %s\n",$type[$rc2_int];}
2058         elsif (/^#(define|undef)\s+BF_PTR/)
2059                 {
2060                 printf OUT "#undef BF_PTR\n" if $bf_ptr == 0;
2061                 printf OUT "#define BF_PTR\n" if $bf_ptr == 1;
2062                 printf OUT "#define BF_PTR2\n" if $bf_ptr == 2;
2063                 }
2064         else
2065                 { print OUT $_; }
2066         }
2067 close(IN);
2068 print OUT "#ifdef  __cplusplus\n";
2069 print OUT "}\n";
2070 print OUT "#endif\n";
2071 close(OUT);
2072 rename("crypto/opensslconf.h","crypto/opensslconf.h.bak") || die "unable to rename crypto/opensslconf.h\n" if -e "crypto/opensslconf.h";
2073 rename("crypto/opensslconf.h.new","crypto/opensslconf.h") || die "unable to rename crypto/opensslconf.h.new\n";
2074
2075
2076 # Fix the date
2077
2078 print "SIXTY_FOUR_BIT_LONG mode\n" if $b64l;
2079 print "SIXTY_FOUR_BIT mode\n" if $b64;
2080 print "THIRTY_TWO_BIT mode\n" if $b32;
2081 print "SIXTEEN_BIT mode\n" if $b16;
2082 print "EIGHT_BIT mode\n" if $b8;
2083 print "DES_PTR used\n" if $des_ptr;
2084 print "DES_RISC1 used\n" if $des_risc1;
2085 print "DES_RISC2 used\n" if $des_risc2;
2086 print "DES_UNROLL used\n" if $des_unroll;
2087 print "DES_INT used\n" if $des_int;
2088 print "BN_LLONG mode\n" if $bn_ll;
2089 print "RC4 uses u$type[$rc4_int]\n" if $rc4_int != $def_int;
2090 print "RC4_INDEX mode\n" if $rc4_idx;
2091 print "RC4_CHUNK is undefined\n" if $rc4_chunk==0;
2092 print "RC4_CHUNK is unsigned long\n" if $rc4_chunk==1;
2093 print "RC4_CHUNK is unsigned long long\n" if $rc4_chunk==2;
2094 print "MD2 uses u$type[$md2_int]\n" if $md2_int != $def_int;
2095 print "IDEA uses u$type[$idea_int]\n" if $idea_int != $def_int;
2096 print "RC2 uses u$type[$rc2_int]\n" if $rc2_int != $def_int;
2097 print "BF_PTR used\n" if $bf_ptr == 1;
2098 print "BF_PTR2 used\n" if $bf_ptr == 2;
2099
2100 if($IsMK1MF) {
2101         open (OUT,">crypto/buildinf.h") || die "Can't open buildinf.h";
2102         printf OUT <<EOF;
2103 #ifndef MK1MF_BUILD
2104   /* auto-generated by Configure for crypto/cversion.c:
2105    * for Unix builds, crypto/Makefile.ssl generates functional definitions;
2106    * Windows builds (and other mk1mf builds) compile cversion.c with
2107    * -DMK1MF_BUILD and use definitions added to this file by util/mk1mf.pl. */
2108   #error "Windows builds (PLATFORM=$target) use mk1mf.pl-created Makefiles"
2109 #endif
2110 EOF
2111         close(OUT);
2112 } else {
2113         my $make_command = "$make PERL=\'$perl\'";
2114         my $make_targets = "";
2115         $make_targets .= " links" if $symlink;
2116         $make_targets .= " depend" if $depflags ne $default_depflags && $make_depend;
2117         $make_targets .= " gentests" if $symlink;
2118         (system $make_command.$make_targets) == 0 or die "make $make_targets failed"
2119                 if $make_targets ne "";
2120         if ( $perl =~ m@^/@) {
2121             &dofile("tools/c_rehash",$perl,'^#!/', '#!%s','^my \$dir;$', 'my $dir = "' . $openssldir . '";', '^my \$prefix;$', 'my $prefix = "' . $prefix . '";');
2122             &dofile("apps/CA.pl",$perl,'^#!/', '#!%s');
2123         } else {
2124             # No path for Perl known ...
2125             &dofile("tools/c_rehash",'/usr/local/bin/perl','^#!/', '#!%s','^my \$dir;$', 'my $dir = "' . $openssldir . '";',  '^my \$prefix;$', 'my $prefix = "' . $prefix . '";');
2126             &dofile("apps/CA.pl",'/usr/local/bin/perl','^#!/', '#!%s');
2127         }
2128         if ($depflags ne $default_depflags && !$make_depend) {
2129                 print <<EOF;
2130
2131 Since you've disabled or enabled at least one algorithm, you need to do
2132 the following before building:
2133
2134         make depend
2135 EOF
2136         }
2137 }
2138
2139 # create the ms/version32.rc file if needed
2140 if ($IsMK1MF && ($target !~ /^netware/)) {
2141         my ($v1, $v2, $v3, $v4);
2142         if ($version_num =~ /(^[0-9a-f]{1})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})/i) {
2143                 $v1=hex $1;
2144                 $v2=hex $2;
2145                 $v3=hex $3;
2146                 $v4=hex $4;
2147         }
2148         open (OUT,">ms/version32.rc") || die "Can't open ms/version32.rc";
2149         print OUT <<EOF;
2150 #include <winver.h>
2151
2152 LANGUAGE 0x09,0x01
2153
2154 1 VERSIONINFO
2155   FILEVERSION $v1,$v2,$v3,$v4
2156   PRODUCTVERSION $v1,$v2,$v3,$v4
2157   FILEFLAGSMASK 0x3fL
2158 #ifdef _DEBUG
2159   FILEFLAGS 0x01L
2160 #else
2161   FILEFLAGS 0x00L
2162 #endif
2163   FILEOS VOS__WINDOWS32
2164   FILETYPE VFT_DLL
2165   FILESUBTYPE 0x0L
2166 BEGIN
2167     BLOCK "StringFileInfo"
2168     BEGIN
2169         BLOCK "040904b0"
2170         BEGIN
2171             // Required:
2172             VALUE "CompanyName", "The OpenSSL Project, http://www.openssl.org/\\0"
2173             VALUE "FileDescription", "OpenSSL Shared Library\\0"
2174             VALUE "FileVersion", "$version\\0"
2175 #if defined(CRYPTO)
2176             VALUE "InternalName", "libeay32\\0"
2177             VALUE "OriginalFilename", "libeay32.dll\\0"
2178 #elif defined(SSL)
2179             VALUE "InternalName", "ssleay32\\0"
2180             VALUE "OriginalFilename", "ssleay32.dll\\0"
2181 #endif
2182             VALUE "ProductName", "The OpenSSL Toolkit\\0"
2183             VALUE "ProductVersion", "$version\\0"
2184             // Optional:
2185             //VALUE "Comments", "\\0"
2186             VALUE "LegalCopyright", "Copyright © 1998-2005 The OpenSSL Project. Copyright © 1995-1998 Eric A. Young, Tim J. Hudson. All rights reserved.\\0"
2187             //VALUE "LegalTrademarks", "\\0"
2188             //VALUE "PrivateBuild", "\\0"
2189             //VALUE "SpecialBuild", "\\0"
2190         END
2191     END
2192     BLOCK "VarFileInfo"
2193     BEGIN
2194         VALUE "Translation", 0x409, 0x4b0
2195     END
2196 END
2197 EOF
2198         close(OUT);
2199   }
2200
2201 print <<EOF;
2202
2203 Configured for $target.
2204 EOF
2205
2206 print <<\EOF if (!$no_threads && !$threads);
2207
2208 The library could not be configured for supporting multi-threaded
2209 applications as the compiler options required on this system are not known.
2210 See file INSTALL for details if you need multi-threading.
2211 EOF
2212
2213 print <<\EOF if ($no_shared_warn);
2214
2215 You gave the option 'shared'.  Normally, that would give you shared libraries.
2216 Unfortunately, the OpenSSL configuration doesn't include shared library support
2217 for this platform yet, so it will pretend you gave the option 'no-shared'.  If
2218 you can inform the developpers (openssl-dev\@openssl.org) how to support shared
2219 libraries on this platform, they will at least look at it and try their best
2220 (but please first make sure you have tried with a current version of OpenSSL).
2221 EOF
2222
2223 exit(0);
2224
2225 sub usage
2226         {
2227         print STDERR $usage;
2228         print STDERR "\npick os/compiler from:\n";
2229         my $j=0;
2230         my $i;
2231         my $k=0;
2232         foreach $i (sort keys %table)
2233                 {
2234                 next if $i =~ /^debug/;
2235                 $k += length($i) + 1;
2236                 if ($k > 78)
2237                         {
2238                         print STDERR "\n";
2239                         $k=length($i);
2240                         }
2241                 print STDERR $i . " ";
2242                 }
2243         foreach $i (sort keys %table)
2244                 {
2245                 next if $i !~ /^debug/;
2246                 $k += length($i) + 1;
2247                 if ($k > 78)
2248                         {
2249                         print STDERR "\n";
2250                         $k=length($i);
2251                         }
2252                 print STDERR $i . " ";
2253                 }
2254         print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
2255         exit(1);
2256         }
2257
2258 sub which
2259         {
2260         my($name)=@_;
2261         my $path;
2262         foreach $path (split /:/, $ENV{PATH})
2263                 {
2264                 if (-f "$path/$name$exe_ext" and -x _)
2265                         {
2266                         return "$path/$name$exe_ext" unless ($name eq "perl" and
2267                          system("$path/$name$exe_ext -e " . '\'exit($]<5.0);\''));
2268                         }
2269                 }
2270         }
2271
2272 sub dofile
2273         {
2274         my $f; my $p; my %m; my @a; my $k; my $ff;
2275         ($f,$p,%m)=@_;
2276
2277         open(IN,"<$f.in") || open(IN,"<$f") || die "unable to open $f:$!\n";
2278         @a=<IN>;
2279         close(IN);
2280         foreach $k (keys %m)
2281                 {
2282                 grep(/$k/ && ($_=sprintf($m{$k}."\n",$p)),@a);
2283                 }
2284         open(OUT,">$f.new") || die "unable to open $f.new:$!\n";
2285         print OUT @a;
2286         close(OUT);
2287         rename($f,"$f.bak") || die "unable to rename $f\n" if -e $f;
2288         rename("$f.new",$f) || die "unable to rename $f.new\n";
2289         }
2290
2291 sub print_table_entry
2292         {
2293         my $target = shift;
2294         my $type = shift;
2295
2296         # Don't print the templates
2297         return if $table{$target}->{template};
2298
2299         if ($type eq "TABLE") {
2300             print <<EOF
2301
2302 *** $target
2303 \$cc           = $table{$target}->{cc}
2304 \$cflags       = $table{$target}->{cflags}
2305 \$debug_cflags   = $table{$target}->{debug_cflags}
2306 \$release_cflags = $table{$target}->{release_cflags}
2307 \$unistd       = $table{$target}->{unistd}
2308 \$thread_cflag = $table{$target}->{thread_cflag}
2309 \$sys_id       = $table{$target}->{sys_id}
2310 \$lflags       = $table{$target}->{lflags}
2311 \$debug_lflags   = $table{$target}->{debug_lflags}
2312 \$release_lflags = $table{$target}->{release_lflags}
2313 \$bn_ops       = $table{$target}->{bn_ops}
2314 \$cpuid_obj    = $table{$target}->{cpuid_obj}
2315 \$bn_obj       = $table{$target}->{bn_obj}
2316 \$ec_obj       = $table{$target}->{ec_obj}
2317 \$des_obj      = $table{$target}->{des_obj}
2318 \$aes_obj      = $table{$target}->{aes_obj}
2319 \$bf_obj       = $table{$target}->{bf_obj}
2320 \$md5_obj      = $table{$target}->{md5_obj}
2321 \$sha1_obj     = $table{$target}->{sha1_obj}
2322 \$cast_obj     = $table{$target}->{cast_obj}
2323 \$rc4_obj      = $table{$target}->{rc4_obj}
2324 \$rmd160_obj   = $table{$target}->{rmd160_obj}
2325 \$rc5_obj      = $table{$target}->{rc5_obj}
2326 \$wp_obj       = $table{$target}->{wp_obj}
2327 \$cmll_obj     = $table{$target}->{cmll_obj}
2328 \$modes_obj    = $table{$target}->{modes_obj}
2329 \$engines_obj  = $table{$target}->{engines_obj}
2330 \$perlasm_scheme = $table{$target}->{perlasm_scheme}
2331 \$dso_scheme   = $table{$target}->{dso_scheme}
2332 \$shared_target= $table{$target}->{shared_target}
2333 \$shared_cflag = $table{$target}->{shared_cflag}
2334 \$shared_ldflag = $table{$target}->{shared_ldflag}
2335 \$shared_extension = $table{$target}->{shared_extension}
2336 \$ranlib       = $table{$target}->{ranlib}
2337 \$arflags      = $table{$target}->{arflags}
2338 \$multilib     = $table{$target}->{multilib}
2339 EOF
2340         } elsif ($type eq "HASH") {
2341             my @sequence = (
2342                 "cc",
2343                 "cflags",
2344                 "debug_cflags",
2345                 "release_cflags",
2346                 "unistd",
2347                 "thread_cflag",
2348                 "sys_id",
2349                 "lflags",
2350                 "debug_lflags",
2351                 "release_lflags",
2352                 "bn_ops",
2353                 "cpuid_obj",
2354                 "bn_obj",
2355                 "ec_obj",
2356                 "des_obj",
2357                 "aes_obj",
2358                 "bf_obj",
2359                 "md5_obj",
2360                 "sha1_obj",
2361                 "cast_obj",
2362                 "rc4_obj",
2363                 "rmd160_obj",
2364                 "rc5_obj",
2365                 "wp_obj",
2366                 "cmll_obj",
2367                 "modes_obj",
2368                 "engines_obj",
2369                 "perlasm_scheme",
2370                 "dso_scheme",
2371                 "shared_target",
2372                 "shared_cflag",
2373                 "shared_ldflag",
2374                 "shared_extension",
2375                 "ranlib",
2376                 "arflags",
2377                 "multilib",
2378                 );
2379             my $largest =
2380                 length((sort { length($a) <=> length($b) } @sequence)[-1]);
2381             print "    '$target' => {\n";
2382             foreach (@sequence) {
2383                 if ($table{$target}->{$_}) {
2384                     print "      '",$_,"'"," " x ($largest - length($_))," => '",$table{$target}->{$_},"',\n";
2385                 }
2386             }
2387             print "    },\n";
2388         }
2389         }
2390
2391 sub test_sanity
2392         {
2393         my $errorcnt = 0;
2394
2395         print STDERR "=" x 70, "\n";
2396         print STDERR "=== SANITY TESTING!\n";
2397         print STDERR "=== No configuration will be done, all other arguments will be ignored!\n";
2398         print STDERR "=" x 70, "\n";
2399
2400         foreach $target (sort keys %table)
2401                 {
2402                 my $pre_dso_scheme = "perlasm_scheme";
2403                 my $dso_scheme = "dso_scheme";
2404                 my $post_dso_scheme = "shared_target";
2405
2406
2407                 if ($table{$target}->{$pre_dso_scheme} =~ /^(beos|dl|dlfcn|win32|vms)$/)
2408                         {
2409                         $errorcnt++;
2410                         print STDERR "SANITY ERROR: '$target' has the dso_scheme values\n";
2411                         print STDERR "              in the previous field\n";
2412                         }
2413                 elsif ($table{$target}->{$post_dso_scheme} =~ /^(beos|dl|dlfcn|win32|vms)$/)
2414                         {
2415                         $errorcnt++;
2416                         print STDERR "SANITY ERROR: '$target' has the dso_scheme values\n";
2417                         print STDERR "              in the following field\n";
2418                         }
2419                 elsif ($table{$target}->{$dso_scheme} !~ /^(beos|dl|dlfcn|win32|vms|)$/)
2420                         {
2421                         $errorcnt++;
2422                         print STDERR "SANITY ERROR: '$target' has the dso_scheme field = ",$table{$target}->{$dso_scheme},"\n";
2423                         print STDERR "              valid values are 'beos', 'dl', 'dlfcn', 'win32' and 'vms'\n";
2424                         }
2425                 }
2426         print STDERR "No sanity errors detected!\n" if $errorcnt == 0;
2427         return $errorcnt;
2428         }