Configure

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