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