Configure

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