Configure

   1 #! /usr/bin/env perl
   2 # -*- mode: perl; -*-
   3 # Copyright 2016-2022 The OpenSSL Project Authors. All Rights Reserved.
   4 #
   5 # Licensed under the Apache License 2.0 (the "License").  You may not use
   6 # this file except in compliance with the License.  You can obtain a copy
   7 # in the file LICENSE in the source distribution or at
   8 # https://www.openssl.org/source/license.html
   9
  10 ##  Configure -- OpenSSL source tree configuration script
  11
  12 use 5.10.0;
  13 use strict;
  14 use Config;
  15 use FindBin;
  16 use lib "$FindBin::Bin/util/perl";
  17 use File::Basename;
  18 use File::Spec::Functions qw/:DEFAULT abs2rel rel2abs splitdir/;
  19 use File::Path qw/mkpath/;
  20 use OpenSSL::fallback "$FindBin::Bin/external/perl/MODULES.txt";
  21 use OpenSSL::Glob;
  22 use OpenSSL::Template;
  23 use OpenSSL::config;
  24
  25 # see INSTALL.md for instructions.
  26
  27 my $orig_death_handler = $SIG{__DIE__};
  28 $SIG{__DIE__} = \&death_handler;
  29
  30 my $usage="Usage: Configure [no-<feature> ...] [enable-<feature> ...] [-Dxxx] [-lxxx] [-Lxxx] [-fxxx] [-Kxxx] [no-hw-xxx|no-hw] [[no-]threads] [[no-]thread-pool] [[no-]default-thread-pool] [[no-]shared] [[no-]zlib|zlib-dynamic] [no-asm] [no-egd] [sctp] [386] [--prefix=DIR] [--openssldir=OPENSSLDIR] [--with-xxx[=vvv]] [--config=FILE] os/compiler[:flags]\n";
  31
  32 my $banner = <<"EOF";
  33
  34 **********************************************************************
  35 ***                                                                ***
  36 ***   OpenSSL has been successfully configured                     ***
  37 ***                                                                ***
  38 ***   If you encounter a problem while building, please open an    ***
  39 ***   issue on GitHub <https://github.com/openssl/openssl/issues>  ***
  40 ***   and include the output from the following command:           ***
  41 ***                                                                ***
  42 ***       perl configdata.pm --dump                                ***
  43 ***                                                                ***
  44 ***   (If you are new to OpenSSL, you might want to consult the    ***
  45 ***   'Troubleshooting' section in the INSTALL.md file first)      ***
  46 ***                                                                ***
  47 **********************************************************************
  48 EOF
  49
  50 # Options:
  51 #
  52 # --config      add the given configuration file, which will be read after
  53 #               any "Configurations*" files that are found in the same
  54 #               directory as this script.
  55 # --prefix      prefix for the OpenSSL installation, which includes the
  56 #               directories bin, lib, include, share/man, share/doc/openssl
  57 #               This becomes the value of INSTALLTOP in Makefile
  58 #               (Default: /usr/local)
  59 # --openssldir  OpenSSL data area, such as openssl.cnf, certificates and keys.
  60 #               If it's a relative directory, it will be added on the directory
  61 #               given with --prefix.
  62 #               This becomes the value of OPENSSLDIR in Makefile and in C.
  63 #               (Default: PREFIX/ssl)
  64 # --banner=".." Output specified text instead of default completion banner
  65 #
  66 # -w            Don't wait after showing a Configure warning
  67 #
  68 # --cross-compile-prefix Add specified prefix to binutils components.
  69 #
  70 # --api         One of 0.9.8, 1.0.0, 1.0.1, 1.0.2, 1.1.0, 1.1.1, or 3.0
  71 #               Define the public APIs as they were for that version
  72 #               including patch releases.  If 'no-deprecated' is also
  73 #               given, do not compile support for interfaces deprecated
  74 #               up to and including the specified OpenSSL version.
  75 #
  76 # no-hw-xxx     do not compile support for specific crypto hardware.
  77 #               Generic OpenSSL-style methods relating to this support
  78 #               are always compiled but return NULL if the hardware
  79 #               support isn't compiled.
  80 # no-hw         do not compile support for any crypto hardware.
  81 # [no-]threads  [don't] try to create a library that is suitable for
  82 #               multithreaded applications (default is "threads" if we
  83 #               know how to do it)
  84 # [no-]thread-pool
  85 #               [don't] allow thread pool functionality
  86 # [no-]default-thread-pool
  87 #               [don't] allow default thread pool functionality
  88 # [no-]shared   [don't] try to create shared libraries when supported.
  89 # [no-]pic      [don't] try to build position independent code when supported.
  90 #               If disabled, it also disables shared and dynamic-engine.
  91 # no-asm        do not use assembler
  92 # no-egd        do not compile support for the entropy-gathering daemon APIs
  93 # [no-]zlib     [don't] compile support for zlib compression.
  94 # zlib-dynamic  Like "zlib", but the zlib library is expected to be a shared
  95 #               library and will be loaded at run-time by the OpenSSL library.
  96 # sctp          include SCTP support
  97 # enable-quic   include QUIC support (currently just for developers as the
  98 #               implementation is by no means complete and usable)
  99 # no-uplink     Don't build support for UPLINK interface.
 100 # enable-weak-ssl-ciphers
 101 #               Enable weak ciphers that are disabled by default.
 102 # 386           generate 80386 code in assembly modules
 103 # no-sse2       disables IA-32 SSE2 code in assembly modules, the above
 104 #               mentioned '386' option implies this one
 105 # no-<cipher>   build without specified algorithm (dsa, idea, rc5, ...)
 106 # -<xxx> +<xxx> All options which are unknown to the 'Configure' script are
 107 # /<xxx>        passed through to the compiler. Unix-style options beginning
 108 #               with a '-' or '+' are recognized, as well as Windows-style
 109 #               options beginning with a '/'. If the option contains arguments
 110 #               separated by spaces, then the URL-style notation %20 can be
 111 #               used for the space character in order to avoid having to quote
 112 #               the option. For example, -opt%20arg gets expanded to -opt arg.
 113 #               In fact, any ASCII character can be encoded as %xx using its
 114 #               hexadecimal encoding.
 115 # -static       while -static is also a pass-through compiler option (and
 116 #               as such is limited to environments where it's actually
 117 #               meaningful), it triggers a number configuration options,
 118 #               namely no-pic, no-shared and no-threads. It is
 119 #               argued that the only reason to produce statically linked
 120 #               binaries (and in context it means executables linked with
 121 #               -static flag, and not just executables linked with static
 122 #               libcrypto.a) is to eliminate dependency on specific run-time,
 123 #               a.k.a. libc version. The mentioned config options are meant
 124 #               to achieve just that. Unfortunately on Linux it's impossible
 125 #               to eliminate the dependency completely for openssl executable
 126 #               because of getaddrinfo and gethostbyname calls, which can
 127 #               invoke dynamically loadable library facility anyway to meet
 128 #               the lookup requests. For this reason on Linux statically
 129 #               linked openssl executable has rather debugging value than
 130 #               production quality.
 131 #
 132 # BN_LLONG      use the type 'long long' in crypto/bn/bn.h
 133 # RC4_CHAR      use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
 134 # Following are set automatically by this script
 135 #
 136 # MD5_ASM       use some extra md5 assembler,
 137 # SHA1_ASM      use some extra sha1 assembler, must define L_ENDIAN for x86
 138 # RMD160_ASM    use some extra ripemd160 assembler,
 139 # SHA256_ASM    sha256_block is implemented in assembler
 140 # SHA512_ASM    sha512_block is implemented in assembler
 141 # AES_ASM       AES_[en|de]crypt is implemented in assembler
 142
 143 # Minimum warning options... any contributions to OpenSSL should at least
 144 # get past these.  Note that we only use these with C compilers, not with
 145 # C++ compilers.
 146
 147 # -DPEDANTIC complements -pedantic and is meant to mask code that
 148 # is not strictly standard-compliant and/or implementation-specific,
 149 # e.g. inline assembly, disregards to alignment requirements, such
 150 # that -pedantic would complain about. Incidentally -DPEDANTIC has
 151 # to be used even in sanitized builds, because sanitizer too is
 152 # supposed to and does take notice of non-standard behaviour. Then
 153 # -pedantic with pre-C9x compiler would also complain about 'long
 154 # long' not being supported. As 64-bit algorithms are common now,
 155 # it grew impossible to resolve this without sizeable additional
 156 # code, so we just tell compiler to be pedantic about everything
 157 # but 'long long' type.
 158
 159 my @gcc_devteam_warn = qw(
 160     -DPEDANTIC -pedantic -Wno-long-long -DUNUSEDRESULT_DEBUG
 161     -Wall
 162     -Wmissing-declarations
 163     -Wextra
 164     -Wno-unused-parameter
 165     -Wno-missing-field-initializers
 166     -Wswitch
 167     -Wsign-compare
 168     -Wshadow
 169     -Wformat
 170     -Wno-type-limits
 171     -Wno-tautological-constant-out-of-range-compare
 172     -Wundef
 173     -Werror
 174     -Wmissing-prototypes
 175     -Wstrict-prototypes
 176 );
 177
 178 # These are used in addition to $gcc_devteam_warn when the compiler is clang.
 179 # TODO(openssl-team): fix problems and investigate if (at least) the
 180 # following warnings can also be enabled:
 181 #       -Wcast-align
 182 #       -Wunreachable-code -- no, too ugly/compiler-specific
 183 #       -Wlanguage-extension-token -- no, we use asm()
 184 #       -Wunused-macros -- no, too tricky for BN and _XOPEN_SOURCE etc
 185 #       -Wextended-offsetof -- no, needed in CMS ASN1 code
 186 my @clang_devteam_warn = qw(
 187     -Wno-unknown-warning-option
 188     -Wswitch-default
 189     -Wno-parentheses-equality
 190     -Wno-language-extension-token
 191     -Wno-extended-offsetof
 192     -Wconditional-uninitialized
 193     -Wincompatible-pointer-types-discards-qualifiers
 194     -Wmissing-variable-declarations
 195 );
 196
 197 my @cl_devteam_warn = qw(
 198     /WX
 199 );
 200
 201 my $strict_warnings = 0;
 202
 203 # As for $BSDthreads. Idea is to maintain "collective" set of flags,
 204 # which would cover all BSD flavors. -pthread applies to them all,
 205 # but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
 206 # -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
 207 # which has to be accompanied by explicit -D_THREAD_SAFE and
 208 # sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
 209 # seems to be sufficient?
 210 our $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
 211
 212 #
 213 # API compatibility name to version number mapping.
 214 #
 215 my $apitable = {
 216     # This table expresses when API additions or changes can occur.
 217     # The numbering used changes from 3.0 and on because we updated
 218     # (solidified) our version numbering scheme at that point.
 219
 220     # From 3.0 and on, we internalise the given version number in decimal
 221     # as MAJOR * 10000 + MINOR * 100 + 0
 222     "3.0.0" => 30000,
 223     "3.0"   => 30000,
 224
 225     # Note that before 3.0, we didn't have the same version number scheme.
 226     # Still, the numbering we use here covers what we need.
 227     "1.1.1" => 10101,
 228     "1.1.0" => 10100,
 229     "1.0.2" => 10002,
 230     "1.0.1" => 10001,
 231     "1.0.0" => 10000,
 232     "0.9.8" =>   908,
 233 };
 234
 235 # For OpenSSL::config::get_platform
 236 my %guess_opts = ();
 237
 238 my $dryrun = 0;
 239
 240 our %table = ();
 241 our %config = ();
 242 our %withargs = ();
 243 our $now_printing;      # set to current entry's name in print_table_entry
 244                         # (todo: right thing would be to encapsulate name
 245                         # into %target [class] and make print_table_entry
 246                         # a method)
 247
 248 # Forward declarations ###############################################
 249
 250 # read_config(filename)
 251 #
 252 # Reads a configuration file and populates %table with the contents
 253 # (which the configuration file places in %targets).
 254 sub read_config;
 255
 256 # resolve_config(target)
 257 #
 258 # Resolves all the late evaluations, inheritances and so on for the
 259 # chosen target and any target it inherits from.
 260 sub resolve_config;
 261
 262
 263 # Information collection #############################################
 264
 265 # Unified build supports separate build dir
 266 my $srcdir = catdir(absolutedir(dirname($0))); # catdir ensures local syntax
 267 my $blddir = catdir(absolutedir("."));         # catdir ensures local syntax
 268
 269 # File::Spec::Unix doesn't detect case insensitivity, so we make sure to
 270 # check if the source and build directory are really the same, and make
 271 # them so.  This avoids all kinds of confusion later on.
 272 # We must check @File::Spec::ISA rather than using File::Spec->isa() to
 273 # know if File::Spec ended up loading File::Spec::Unix.
 274 $srcdir = $blddir
 275     if (grep(/::Unix$/, @File::Spec::ISA)
 276         && samedir($srcdir, $blddir));
 277
 278 my $dofile = abs2rel(catfile($srcdir, "util/dofile.pl"));
 279
 280 my $local_config_envname = 'OPENSSL_LOCAL_CONFIG_DIR';
 281
 282 $config{sourcedir} = abs2rel($srcdir, $blddir);
 283 $config{builddir} = abs2rel($blddir, $blddir);
 284 # echo -n 'holy hand grenade of antioch' | openssl sha256
 285 $config{FIPSKEY} =
 286     'f4556650ac31d35461610bac4ed81b1a181b2d8a43ea2854cbae22ca74560813';
 287
 288 # Collect reconfiguration information if needed
 289 my @argvcopy=@ARGV;
 290
 291 if (grep /^reconf(igure)?$/, @argvcopy) {
 292     die "reconfiguring with other arguments present isn't supported"
 293         if scalar @argvcopy > 1;
 294     if (-f "./configdata.pm") {
 295         my $file = "./configdata.pm";
 296         unless (my $return = do $file) {
 297             die "couldn't parse $file: $@" if $@;
 298             die "couldn't do $file: $!"    unless defined $return;
 299             die "couldn't run $file"       unless $return;
 300         }
 301
 302         @argvcopy = defined($configdata::config{perlargv}) ?
 303             @{$configdata::config{perlargv}} : ();
 304         die "Incorrect data to reconfigure, please do a normal configuration\n"
 305             if (grep(/^reconf/,@argvcopy));
 306         $config{perlenv} = $configdata::config{perlenv} // {};
 307     } else {
 308         die "Insufficient data to reconfigure, please do a normal configuration\n";
 309     }
 310 }
 311
 312 $config{perlargv} = [ @argvcopy ];
 313
 314 # Historical: if known directories in crypto/ have been removed, it means
 315 # that those sub-systems are disabled.
 316 # (the other option would be to removed them from the SUBDIRS statement in
 317 # crypto/build.info)
 318 # We reverse the input list for cosmetic purely reasons, to compensate that
 319 # 'unshift' adds at the front of the list (i.e. in reverse input order).
 320 foreach ( reverse sort( 'aes', 'aria', 'bf', 'camellia', 'cast', 'des', 'dh',
 321                         'dsa', 'ec', 'hmac', 'idea', 'md2', 'md5', 'mdc2',
 322                         'rc2', 'rc4', 'rc5', 'ripemd', 'seed', 'sha',
 323                         'sm2', 'sm3', 'sm4') ) {
 324     unshift @argvcopy, "no-$_" if ! -d catdir($srcdir, 'crypto', $_);
 325 }
 326
 327 # Collect version numbers
 328 my %version = ();
 329
 330 collect_information(
 331     collect_from_file(catfile($srcdir,'VERSION.dat')),
 332     qr/\s*(\w+)\s*=\s*(.*?)\s*$/ =>
 333         sub {
 334             # Only define it if there is a value at all
 335             if ($2 ne '') {
 336                 my $k = $1;
 337                 my $v = $2;
 338                 # Some values are quoted.  Trim the quotes
 339                 $v = $1 if $v =~ /^"(.*)"$/;
 340                 $version{uc $k} = $v;
 341             }
 342         },
 343     "OTHERWISE" =>
 344         sub { die "Something wrong with this line:\n$_\nin $srcdir/VERSION.dat" },
 345     );
 346
 347 $config{major} = $version{MAJOR} // 'unknown';
 348 $config{minor} = $version{MINOR} // 'unknown';
 349 $config{patch} = $version{PATCH} // 'unknown';
 350 $config{prerelease} =
 351     defined $version{PRE_RELEASE_TAG} ? "-$version{PRE_RELEASE_TAG}" : '';
 352 $config{build_metadata} =
 353     defined $version{BUILD_METADATA} ? "+$version{BUILD_METADATA}" : '';
 354 $config{shlib_version} = $version{SHLIB_VERSION} // 'unknown';
 355 $config{release_date} = $version{RELEASE_DATE} // 'xx XXX xxxx';
 356
 357 $config{version} = "$config{major}.$config{minor}.$config{patch}";
 358 $config{full_version} = "$config{version}$config{prerelease}$config{build_metadata}";
 359
 360 die "erroneous version information in VERSION.dat: ",
 361     "$config{version}, $config{shlib_version}\n"
 362     unless (defined $version{MAJOR}
 363             && defined $version{MINOR}
 364             && defined $version{PATCH}
 365             && defined $version{SHLIB_VERSION});
 366
 367 # Collect target configurations
 368
 369 my $pattern = catfile(dirname($0), "Configurations", "*.conf");
 370 foreach (sort glob($pattern)) {
 371     &read_config($_);
 372 }
 373
 374 if (defined env($local_config_envname)) {
 375     if ($^O eq 'VMS') {
 376         # VMS environment variables are logical names,
 377         # which can be used as is
 378         $pattern = $local_config_envname . ':' . '*.conf';
 379     } else {
 380         $pattern = catfile(env($local_config_envname), '*.conf');
 381     }
 382
 383     foreach (sort glob($pattern)) {
 384         &read_config($_);
 385     }
 386 }
 387
 388 # Save away perl command information
 389 $config{perl_cmd} = $^X;
 390 $config{perl_version} = $Config{version};
 391 $config{perl_archname} = $Config{archname};
 392
 393 $config{prefix}="";
 394 $config{openssldir}="";
 395 $config{processor}="";
 396 $config{libdir}="";
 397 my $auto_threads=1;    # enable threads automatically? true by default
 398 my $default_ranlib;
 399
 400 # Known TLS and DTLS protocols
 401 my @tls = qw(ssl3 tls1 tls1_1 tls1_2 tls1_3);
 402 my @dtls = qw(dtls1 dtls1_2);
 403
 404 # Explicitly known options that are possible to disable.  They can
 405 # be regexps, and will be used like this: /^no-${option}$/
 406 # For developers: keep it sorted alphabetically
 407
 408 my @disablables = (
 409     "acvp-tests",
 410     "afalgeng",
 411     "argon2",
 412     "aria",
 413     "asan",
 414     "asm",
 415     "async",
 416     "autoalginit",
 417     "autoerrinit",
 418     "autoload-config",
 419     "bf",
 420     "blake2",
 421     "brotli",
 422     "brotli-dynamic",
 423     "buildtest-c++",
 424     "bulk",
 425     "cached-fetch",
 426     "camellia",
 427     "capieng",
 428     "winstore",
 429     "cast",
 430     "chacha",
 431     "cmac",
 432     "cmp",
 433     "cms",
 434     "comp",
 435     "crypto-mdebug",
 436     "ct",
 437     "default-thread-pool",
 438     "deprecated",
 439     "des",
 440     "devcryptoeng",
 441     "dgram",
 442     "dh",
 443     "dsa",
 444     "dso",
 445     "dtls",
 446     "dynamic-engine",
 447     "ec",
 448     "ec2m",
 449     "ec_nistp_64_gcc_128",
 450     "ecdh",
 451     "ecdsa",
 452     "egd",
 453     "engine",
 454     "err",
 455     "external-tests",
 456     "filenames",
 457     "fips",
 458     "fips-securitychecks",
 459     "fuzz-afl",
 460     "fuzz-libfuzzer",
 461     "gost",
 462     "idea",
 463     "ktls",
 464     "legacy",
 465     "loadereng",
 466     "makedepend",
 467     "md2",
 468     "md4",
 469     "mdc2",
 470     "module",
 471     "msan",
 472     "multiblock",
 473     "nextprotoneg",
 474     "ocb",
 475     "ocsp",
 476     "padlockeng",
 477     "pic",
 478     "pinshared",
 479     "poly1305",
 480     "posix-io",
 481     "psk",
 482     "quic",
 483     "rc2",
 484     "rc4",
 485     "rc5",
 486     "rdrand",
 487     "rfc3779",
 488     "rmd160",
 489     "scrypt",
 490     "sctp",
 491     "secure-memory",
 492     "seed",
 493     "shared",
 494     "siphash",
 495     "siv",
 496     "sm2",
 497     "sm3",
 498     "sm4",
 499     "sock",
 500     "srp",
 501     "srtp",
 502     "sse2",
 503     "ssl",
 504     "ssl-trace",
 505     "static-engine",
 506     "stdio",
 507     "tests",
 508     "tfo",
 509     "thread-pool",
 510     "threads",
 511     "tls",
 512     "trace",
 513     "ts",
 514     "ubsan",
 515     "ui-console",
 516     "unit-test",
 517     "uplink",
 518     "weak-ssl-ciphers",
 519     "whirlpool",
 520     "zlib",
 521     "zlib-dynamic",
 522     "zstd",
 523     "zstd-dynamic",
 524     );
 525 foreach my $proto ((@tls, @dtls))
 526         {
 527         push(@disablables, $proto);
 528         push(@disablables, "$proto-method") unless $proto eq "tls1_3";
 529         }
 530
 531 # Internal disablables, for aliasing purposes.  They serve no special
 532 # purpose here, but allow scripts to get to know them through configdata.pm,
 533 # where these are merged with @disablables.
 534 # The actual aliasing mechanism is done via %disable_cascades
 535 my @disablables_int = qw(
 536     crmf
 537     );
 538
 539 my %deprecated_disablables = (
 540     "ssl2" => undef,
 541     "buf-freelists" => undef,
 542     "crypto-mdebug-backtrace" => undef,
 543     "hw" => "hw",               # causes cascade, but no macro
 544     "hw-padlock" => "padlockeng",
 545     "ripemd" => "rmd160",
 546     "ui" => "ui-console",
 547     "heartbeats" => undef,
 548     );
 549
 550 # All of the following are disabled by default:
 551
 552 our %disabled = ( # "what"         => "comment"
 553                   "fips"                => "default",
 554                   "asan"                => "default",
 555                   "brotli"              => "default",
 556                   "brotli-dynamic"      => "default",
 557                   "buildtest-c++"       => "default",
 558                   "crypto-mdebug"       => "default",
 559                   "crypto-mdebug-backtrace" => "default",
 560                   "devcryptoeng"        => "default",
 561                   "ec_nistp_64_gcc_128" => "default",
 562                   "egd"                 => "default",
 563                   "external-tests"      => "default",
 564                   "fuzz-afl"            => "default",
 565                   "fuzz-libfuzzer"      => "default",
 566                   "ktls"                => "default",
 567                   "md2"                 => "default",
 568                   "msan"                => "default",
 569                   "quic"                => "default",
 570                   "rc5"                 => "default",
 571                   "sctp"                => "default",
 572                   "ssl3"                => "default",
 573                   "ssl3-method"         => "default",
 574                   "tfo"                 => "default",
 575                   "trace"               => "default",
 576                   "ubsan"               => "default",
 577                   "unit-test"           => "default",
 578                   "weak-ssl-ciphers"    => "default",
 579                   "zlib"                => "default",
 580                   "zlib-dynamic"        => "default",
 581                   "zstd"                => "default",
 582                   "zstd-dynamic"        => "default",
 583                 );
 584
 585 # Note: => pair form used for aesthetics, not to truly make a hash table
 586 my @disable_cascades = (
 587     # "what"            => [ "cascade", ... ]
 588     "bulk"              => [ "shared", "dso",
 589                              "aria", "async", "autoload-config",
 590                              "blake2", "bf", "camellia", "cast", "chacha",
 591                              "cmac", "cms", "cmp", "comp", "ct",
 592                              "des", "dgram", "dh", "dsa",
 593                              "ec", "engine",
 594                              "filenames",
 595                              "idea", "ktls",
 596                              "md4", "multiblock", "nextprotoneg",
 597                              "ocsp", "ocb", "poly1305", "psk",
 598                              "rc2", "rc4", "rmd160",
 599                              "seed", "siphash", "siv",
 600                              "sm3", "sm4", "srp",
 601                              "srtp", "ssl3-method", "ssl-trace",
 602                              "tfo",
 603                              "ts", "ui-console", "whirlpool",
 604                              "fips-securitychecks" ],
 605     sub { $config{processor} eq "386" }
 606                         => [ "sse2" ],
 607     "ssl"               => [ "ssl3" ],
 608     "ssl3-method"       => [ "ssl3" ],
 609     "zlib"              => [ "zlib-dynamic" ],
 610     "brotli"            => [ "brotli-dynamic" ],
 611     "zstd"              => [ "zstd-dynamic" ],
 612     "des"               => [ "mdc2" ],
 613     "ec"                => [ "ec2m", "ecdsa", "ecdh", "sm2", "gost" ],
 614     "dgram"             => [ "dtls", "quic", "sctp" ],
 615     "sock"              => [ "dgram", "tfo" ],
 616     "dtls"              => [ @dtls ],
 617     sub { 0 == scalar grep { !$disabled{$_} } @dtls }
 618                         => [ "dtls" ],
 619
 620     "tls"               => [ @tls ],
 621     sub { 0 == scalar grep { !$disabled{$_} } @tls }
 622                         => [ "tls" ],
 623
 624     "crypto-mdebug"     => [ "crypto-mdebug-backtrace" ],
 625
 626     # If no modules, then no dynamic engines either
 627     "module"            => [ "dynamic-engine" ],
 628
 629     # Without shared libraries, dynamic engines aren't possible.
 630     # This is due to them having to link with libcrypto and register features
 631     # using the ENGINE functionality, and since that relies on global tables,
 632     # those *have* to be exactly the same as the ones accessed from the app,
 633     # which cannot be guaranteed if shared libraries aren't present.
 634     # (note that even with shared libraries, both the app and dynamic engines
 635     # must be linked with the same library)
 636     "shared"            => [ "dynamic-engine", "uplink" ],
 637     "dso"               => [ "dynamic-engine", "module" ],
 638     # Other modules don't necessarily have to link with libcrypto, so shared
 639     # libraries do not have to be a condition to produce those.
 640
 641     # Without position independent code, there can be no shared libraries
 642     # or modules.
 643     "pic"               => [ "shared", "module" ],
 644
 645     "module"            => [ "fips", "dso" ],
 646
 647     "engine"            => [ "dynamic-engine", grep(/eng$/, @disablables) ],
 648     "dynamic-engine"    => [ "loadereng" ],
 649     "hw"                => [ "padlockeng" ],
 650
 651     # no-autoalginit is only useful when building non-shared
 652     "autoalginit"       => [ "shared", "apps", "fips" ],
 653
 654     "stdio"             => [ "apps", "capieng", "egd" ],
 655     "apps"              => [ "tests" ],
 656     "tests"             => [ "external-tests" ],
 657     "comp"              => [ "zlib", "brotli", "zstd" ],
 658     "sm3"               => [ "sm2" ],
 659     sub { !$disabled{"unit-test"} } => [ "heartbeats" ],
 660
 661     sub { !$disabled{"msan"} } => [ "asm" ],
 662
 663     "cmac"              => [ "siv" ],
 664     "legacy"            => [ "md2" ],
 665
 666     "cmp"               => [ "crmf" ],
 667
 668     "fips"              => [ "fips-securitychecks", "acvp-tests" ],
 669
 670     "threads"           => [ "thread-pool" ],
 671     "thread-pool"       => [ "default-thread-pool" ],
 672
 673     "blake2"            => [ "argon2" ],
 674
 675     "deprecated-3.0"    => [ "engine", "srp" ]
 676     );
 677
 678 # Avoid protocol support holes.  Also disable all versions below N, if version
 679 # N is disabled while N+1 is enabled.
 680 #
 681 my @list = (reverse @tls);
 682 while ((my $first, my $second) = (shift @list, shift @list)) {
 683     last unless @list;
 684     push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
 685                               => [ @list ] );
 686     unshift @list, $second;
 687 }
 688 my @list = (reverse @dtls);
 689 while ((my $first, my $second) = (shift @list, shift @list)) {
 690     last unless @list;
 691     push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
 692                               => [ @list ] );
 693     unshift @list, $second;
 694 }
 695
 696 # Explicit "no-..." options will be collected in %disabled along with the defaults.
 697 # To remove something from %disabled, use "enable-foo".
 698 # For symmetry, "disable-foo" is a synonym for "no-foo".
 699
 700 # For the "make variables" CPPINCLUDES and CPPDEFINES, we support lists with
 701 # platform specific list separators.  Users from those platforms should
 702 # recognise those separators from how you set up the PATH to find executables.
 703 # The default is the Unix like separator, :, but as an exception, we also
 704 # support the space as separator.
 705 my $list_separator_re =
 706     { VMS           => qr/(?<!\^),/,
 707       MSWin32       => qr/(?<!\\);/ } -> {$^O} // qr/(?<!\\)[:\s]/;
 708 # All the "make variables" we support
 709 # Some get pre-populated for the sake of backward compatibility
 710 # (we supported those before the change to "make variable" support.
 711 my %user = (
 712     AR          => env('AR'),
 713     ARFLAGS     => [],
 714     AS          => undef,
 715     ASFLAGS     => [],
 716     CC          => env('CC'),
 717     CFLAGS      => [ env('CFLAGS') || () ],
 718     CXX         => env('CXX'),
 719     CXXFLAGS    => [ env('CXXFLAGS') || () ],
 720     CPP         => undef,
 721     CPPFLAGS    => [ env('CPPFLAGS') || () ],  # -D, -I, -Wp,
 722     CPPDEFINES  => [],  # Alternative for -D
 723     CPPINCLUDES => [],  # Alternative for -I
 724     CROSS_COMPILE => env('CROSS_COMPILE'),
 725     HASHBANGPERL=> env('HASHBANGPERL') || env('PERL'),
 726     LD          => undef,
 727     LDFLAGS     => [ env('LDFLAGS') || () ],  # -L, -Wl,
 728     LDLIBS      => [ env('LDLIBS') || () ],  # -l
 729     MT          => undef,
 730     MTFLAGS     => [],
 731     PERL        => env('PERL') || ($^O ne "VMS" ? $^X : "perl"),
 732     RANLIB      => env('RANLIB'),
 733     RC          => env('RC') || env('WINDRES'),
 734     RCFLAGS     => [ env('RCFLAGS') || () ],
 735     RM          => undef,
 736    );
 737 # Info about what "make variables" may be prefixed with the cross compiler
 738 # prefix.  This should NEVER mention any such variable with a list for value.
 739 my @user_crossable = qw ( AR AS CC CXX CPP LD MT RANLIB RC );
 740 # The same but for flags given as Configure options.  These are *additional*
 741 # input, as opposed to the VAR=string option that override the corresponding
 742 # config target attributes
 743 my %useradd = (
 744     CPPDEFINES  => [],
 745     CPPINCLUDES => [],
 746     CPPFLAGS    => [],
 747     CFLAGS      => [],
 748     CXXFLAGS    => [],
 749     LDFLAGS     => [],
 750     LDLIBS      => [],
 751     RCFLAGS     => [],
 752    );
 753
 754 my %user_synonyms = (
 755     HASHBANGPERL=> 'PERL',
 756     RC          => 'WINDRES',
 757    );
 758
 759 # Some target attributes have been renamed, this is the translation table
 760 my %target_attr_translate =(
 761     ar          => 'AR',
 762     as          => 'AS',
 763     cc          => 'CC',
 764     cxx         => 'CXX',
 765     cpp         => 'CPP',
 766     hashbangperl => 'HASHBANGPERL',
 767     ld          => 'LD',
 768     mt          => 'MT',
 769     ranlib      => 'RANLIB',
 770     rc          => 'RC',
 771     rm          => 'RM',
 772    );
 773
 774 # Initialisers coming from 'config' scripts
 775 $config{defines} = [ split(/$list_separator_re/, env('__CNF_CPPDEFINES')) ];
 776 $config{includes} = [ split(/$list_separator_re/, env('__CNF_CPPINCLUDES')) ];
 777 $config{cppflags} = [ env('__CNF_CPPFLAGS') || () ];
 778 $config{cflags} = [ env('__CNF_CFLAGS') || () ];
 779 $config{cxxflags} = [ env('__CNF_CXXFLAGS') || () ];
 780 $config{lflags} = [ env('__CNF_LDFLAGS') || () ];
 781 $config{ex_libs} = [ env('__CNF_LDLIBS') || () ];
 782
 783 $config{openssl_api_defines}=[];
 784 $config{openssl_sys_defines}=[];
 785 $config{openssl_feature_defines}=[];
 786 $config{options}="";
 787 $config{build_type} = "release";
 788 my $target="";
 789
 790 my %cmdvars = ();               # Stores FOO='blah' type arguments
 791 my %unsupported_options = ();
 792 my %deprecated_options = ();
 793 # If you change this, update apps/version.c
 794 my @known_seed_sources = qw(getrandom devrandom os egd none rdcpu librandom);
 795 my @seed_sources = ();
 796 while (@argvcopy)
 797         {
 798         $_ = shift @argvcopy;
 799
 800         # Support env variable assignments among the options
 801         if (m|^(\w+)=(.+)?$|)
 802                 {
 803                 $cmdvars{$1} = $2;
 804                 # Every time a variable is given as a configuration argument,
 805                 # it acts as a reset if the variable.
 806                 if (exists $user{$1})
 807                         {
 808                         $user{$1} = ref $user{$1} eq "ARRAY" ? [] : undef;
 809                         }
 810                 #if (exists $useradd{$1})
 811                 #       {
 812                 #       $useradd{$1} = [];
 813                 #       }
 814                 next;
 815                 }
 816
 817         # VMS is a case insensitive environment, and depending on settings
 818         # out of our control, we may receive options uppercased.  Let's
 819         # downcase at least the part before any equal sign.
 820         if ($^O eq "VMS")
 821                 {
 822                 s/^([^=]*)/lc($1)/e;
 823                 }
 824
 825         # some people just can't read the instructions, clang people have to...
 826         s/^-no-(?!integrated-as)/no-/;
 827
 828         # rewrite some options in "enable-..." form
 829         s /^-?-?shared$/enable-shared/;
 830         s /^sctp$/enable-sctp/;
 831         s /^threads$/enable-threads/;
 832         s /^zlib$/enable-zlib/;
 833         s /^zlib-dynamic$/enable-zlib-dynamic/;
 834         s /^fips$/enable-fips/;
 835
 836         if (/^(no|disable|enable)-(.+)$/)
 837                 {
 838                 my $word = $2;
 839                 if ($word !~ m|hw(?:-.+)| # special treatment for hw regexp opt
 840                         && !exists $deprecated_disablables{$word}
 841                         && !grep { $word eq $_ } @disablables)
 842                         {
 843                         $unsupported_options{$_} = 1;
 844                         next;
 845                         }
 846                 }
 847         if (/^no-(.+)$/ || /^disable-(.+)$/)
 848                 {
 849                 foreach my $proto ((@tls, @dtls))
 850                         {
 851                         if ($1 eq "$proto-method")
 852                                 {
 853                                 $disabled{"$proto"} = "option($proto-method)";
 854                                 last;
 855                                 }
 856                         }
 857                 if ($1 eq "dtls")
 858                         {
 859                         foreach my $proto (@dtls)
 860                                 {
 861                                 $disabled{$proto} = "option(dtls)";
 862                                 }
 863                         $disabled{"dtls"} = "option(dtls)";
 864                         }
 865                 elsif ($1 eq "ssl")
 866                         {
 867                         # Last one of its kind
 868                         $disabled{"ssl3"} = "option(ssl)";
 869                         }
 870                 elsif ($1 eq "tls")
 871                         {
 872                         # XXX: Tests will fail if all SSL/TLS
 873                         # protocols are disabled.
 874                         foreach my $proto (@tls)
 875                                 {
 876                                 $disabled{$proto} = "option(tls)";
 877                                 }
 878                         }
 879                 elsif ($1 eq "static-engine")
 880                         {
 881                         delete $disabled{"dynamic-engine"};
 882                         }
 883                 elsif ($1 eq "dynamic-engine")
 884                         {
 885                         $disabled{"dynamic-engine"} = "option";
 886                         }
 887                 elsif (exists $deprecated_disablables{$1})
 888                         {
 889                         $deprecated_options{$_} = 1;
 890                         if (defined $deprecated_disablables{$1})
 891                                 {
 892                                 $disabled{$deprecated_disablables{$1}} = "option";
 893                                 }
 894                         }
 895                 elsif ($1 =~ m|hw(?:-.+)|) # deprecate hw options in regexp form
 896                         {
 897                         $deprecated_options{$_} = 1;
 898                         }
 899                 else
 900                         {
 901                         $disabled{$1} = "option";
 902                         }
 903                 # No longer an automatic choice
 904                 $auto_threads = 0 if ($1 eq "threads");
 905                 }
 906         elsif (/^enable-(.+)$/)
 907                 {
 908                 if ($1 eq "static-engine")
 909                         {
 910                         $disabled{"dynamic-engine"} = "option";
 911                         }
 912                 elsif ($1 eq "dynamic-engine")
 913                         {
 914                         delete $disabled{"dynamic-engine"};
 915                         }
 916                 elsif ($1 eq "zlib-dynamic")
 917                         {
 918                         delete $disabled{"zlib"};
 919                         }
 920                 elsif ($1 eq "brotli-dynamic")
 921                         {
 922                         delete $disabled{"brotli"};
 923                         }
 924                 elsif ($1 eq "zstd-dynamic")
 925                         {
 926                         delete $disabled{"zstd"};
 927                         }
 928                 my $algo = $1;
 929                 delete $disabled{$algo};
 930
 931                 # No longer an automatic choice
 932                 $auto_threads = 0 if ($1 eq "threads");
 933                 }
 934         elsif (/^-d$/)          # From older 'config'
 935                 {
 936                 $config{build_type} = "debug";
 937                 }
 938         elsif (/^-v$/)          # From older 'config'
 939                 {
 940                 $guess_opts{verbose} = 1;
 941                 }
 942         elsif (/^-w$/)
 943                 {
 944                 $guess_opts{nowait} = 1;
 945                 }
 946         elsif (/^-t$/)          # From older 'config'
 947                 {
 948                 $dryrun = 1;
 949                 }
 950         elsif (/^--strict-warnings$/)
 951                 {
 952                 # Pretend that our strict flags is a C flag, and replace it
 953                 # with the proper flags later on
 954                 push @{$useradd{CFLAGS}}, '--ossl-strict-warnings';
 955                 $strict_warnings=1;
 956                 }
 957         elsif (/^--debug$/)
 958                 {
 959                 $config{build_type} = "debug";
 960                 }
 961         elsif (/^--release$/)
 962                 {
 963                 $config{build_type} = "release";
 964                 }
 965         elsif (/^386$/)
 966                 { $config{processor}=386; }
 967         elsif (/^rsaref$/)
 968                 {
 969                 # No RSAref support any more since it's not needed.
 970                 # The check for the option is there so scripts aren't
 971                 # broken
 972                 }
 973         elsif (m|^[-+/]|)
 974                 {
 975                 if (/^--prefix=(.*)$/)
 976                         {
 977                         $config{prefix}=$1;
 978                         die "Directory given with --prefix MUST be absolute\n"
 979                                 unless file_name_is_absolute($config{prefix});
 980                         }
 981                 elsif (/^--api=(.*)$/)
 982                         {
 983                         my $api = $1;
 984                         die "Unknown API compatibility level $api"
 985                                 unless defined $apitable->{$api};
 986                         $config{api}=$apitable->{$api};
 987                         }
 988                 elsif (/^--libdir=(.*)$/)
 989                         {
 990                         $config{libdir}=$1;
 991                         }
 992                 elsif (/^--openssldir=(.*)$/)
 993                         {
 994                         $config{openssldir}=$1;
 995                         }
 996                 elsif (/^--with-zlib-lib=(.*)$/)
 997                         {
 998                         $withargs{zlib_lib}=$1;
 999                         }
1000                 elsif (/^--with-zlib-include=(.*)$/)
1001                         {
1002                         $withargs{zlib_include}=$1;
1003                         }
1004                 elsif (/^--with-brotli-lib=(.*)$/)
1005                         {
1006                         $withargs{brotli_lib}=$1;
1007                         }
1008                 elsif (/^--with-brotli-include=(.*)$/)
1009                         {
1010                         $withargs{brotli_include}=$1;
1011                         }
1012                 elsif (/^--with-zstd-lib=(.*)$/)
1013                         {
1014                         $withargs{zstd_lib}=$1;
1015                         }
1016                 elsif (/^--with-zstd-include=(.*)$/)
1017                         {
1018                         $withargs{zstd_include}=$1;
1019                         }
1020                 elsif (/^--with-fuzzer-lib=(.*)$/)
1021                         {
1022                         $withargs{fuzzer_lib}=$1;
1023                         }
1024                 elsif (/^--with-fuzzer-include=(.*)$/)
1025                         {
1026                         $withargs{fuzzer_include}=$1;
1027                         }
1028                 elsif (/^--with-rand-seed=(.*)$/)
1029                         {
1030                         foreach my $x (split(m|,|, $1))
1031                             {
1032                             die "Unknown --with-rand-seed choice $x\n"
1033                                 if ! grep { $x eq $_ } @known_seed_sources;
1034                             push @seed_sources, $x;
1035                             }
1036                         }
1037                 elsif (/^--fips-key=(.*)$/)
1038                         {
1039                         $user{FIPSKEY}=lc($1);
1040                         die "Non-hex character in FIPS key\n"
1041                            if $user{FIPSKEY} =~ /[^a-f0-9]/;
1042                         die "FIPS key must have even number of characters\n"
1043                            if length $1 & 1;
1044                         die "FIPS key too long (64 bytes max)\n"
1045                            if length $1 > 64;
1046                         }
1047                 elsif (/^--banner=(.*)$/)
1048                         {
1049                         $banner = $1 . "\n";
1050                         }
1051                 elsif (/^--cross-compile-prefix=(.*)$/)
1052                         {
1053                         $user{CROSS_COMPILE}=$1;
1054                         }
1055                 elsif (/^--config=(.*)$/)
1056                         {
1057                         read_config $1;
1058                         }
1059                 elsif (/^-l(.*)$/)
1060                         {
1061                         push @{$useradd{LDLIBS}}, $_;
1062                         }
1063                 elsif (/^-framework$/)
1064                         {
1065                         push @{$useradd{LDLIBS}}, $_, shift(@argvcopy);
1066                         }
1067                 elsif (/^-L(.*)$/ or /^-Wl,/)
1068                         {
1069                         push @{$useradd{LDFLAGS}}, $_;
1070                         }
1071                 elsif (/^-rpath$/ or /^-R$/)
1072                         # -rpath is the OSF1 rpath flag
1073                         # -R is the old Solaris rpath flag
1074                         {
1075                         my $rpath = shift(@argvcopy) || "";
1076                         $rpath .= " " if $rpath ne "";
1077                         push @{$useradd{LDFLAGS}}, $_, $rpath;
1078                         }
1079                 elsif (/^-static$/)
1080                         {
1081                         push @{$useradd{LDFLAGS}}, $_;
1082                         }
1083                 elsif (m|^[-/]D(.*)$|)
1084                         {
1085                         push @{$useradd{CPPDEFINES}}, $1;
1086                         }
1087                 elsif (m|^[-/]I(.*)$|)
1088                         {
1089                         push @{$useradd{CPPINCLUDES}}, $1;
1090                         }
1091                 elsif (/^-Wp,$/)
1092                         {
1093                         push @{$useradd{CPPFLAGS}}, $1;
1094                         }
1095                 else    # common if (/^[-+]/), just pass down...
1096                         {
1097                         # Treat %xx as an ASCII code (e.g. replace %20 by a space character).
1098                         # This provides a simple way to pass options with arguments separated
1099                         # by spaces without quoting (e.g. -opt%20arg translates to -opt arg).
1100                         $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
1101                         push @{$useradd{CFLAGS}}, $_;
1102                         push @{$useradd{CXXFLAGS}}, $_;
1103                         }
1104                 }
1105         elsif (m|^/|)
1106                 {
1107                 # Treat %xx as an ASCII code (e.g. replace %20 by a space character).
1108                 # This provides a simple way to pass options with arguments separated
1109                 # by spaces without quoting (e.g. /opt%20arg translates to /opt arg).
1110                 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
1111                 push @{$useradd{CFLAGS}}, $_;
1112                 push @{$useradd{CXXFLAGS}}, $_;
1113                 }
1114         else
1115                 {
1116                 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
1117                 $target=$_;
1118                 }
1119         unless ($_ eq $target || /^no-/ || /^disable-/)
1120                 {
1121                 # "no-..." follows later after implied deactivations
1122                 # have been derived.  (Don't take this too seriously,
1123                 # we really only write OPTIONS to the Makefile out of
1124                 # nostalgia.)
1125
1126                 if ($config{options} eq "")
1127                         { $config{options} = $_; }
1128                 else
1129                         { $config{options} .= " ".$_; }
1130                 }
1131         }
1132
1133 if (keys %deprecated_options)
1134         {
1135         warn "***** Deprecated options: ",
1136                 join(", ", keys %deprecated_options), "\n";
1137         }
1138 if (keys %unsupported_options)
1139         {
1140         die "***** Unsupported options: ",
1141                 join(", ", keys %unsupported_options), "\n";
1142         }
1143
1144 # If any %useradd entry has been set, we must check that the "make
1145 # variables" haven't been set.  We start by checking of any %useradd entry
1146 # is set.
1147 if (grep { scalar @$_ > 0 } values %useradd) {
1148     # Hash of env / make variables names.  The possible values are:
1149     # 1 - "make vars"
1150     # 2 - %useradd entry set
1151     # 3 - both set
1152     my %detected_vars =
1153         map { my $v = 0;
1154               $v += 1 if $cmdvars{$_};
1155               $v += 2 if @{$useradd{$_}};
1156               $_ => $v }
1157         keys %useradd;
1158
1159     # If any of the corresponding "make variables" is set, we error
1160     if (grep { $_ & 1 } values %detected_vars) {
1161         my $names = join(', ', grep { $detected_vars{$_} > 0 }
1162                                sort keys %detected_vars);
1163         die <<"_____";
1164 ***** Mixing make variables and additional compiler/linker flags as
1165 ***** configure command line option is not permitted.
1166 ***** Affected make variables: $names
1167 _____
1168     }
1169 }
1170
1171 # Check through all supported command line variables to see if any of them
1172 # were set, and canonicalise the values we got.  If no compiler or linker
1173 # flag or anything else that affects %useradd was set, we also check the
1174 # environment for values.
1175 my $anyuseradd =
1176     grep { defined $_ && (ref $_ ne 'ARRAY' || @$_) } values %useradd;
1177 foreach (keys %user) {
1178     my $value = $cmdvars{$_};
1179     $value //= env($_) unless $anyuseradd;
1180     $value //=
1181         defined $user_synonyms{$_} ? $cmdvars{$user_synonyms{$_}} : undef;
1182     $value //= defined $user_synonyms{$_} ? env($user_synonyms{$_}) : undef
1183         unless $anyuseradd;
1184
1185     if (defined $value) {
1186         if (ref $user{$_} eq 'ARRAY') {
1187             if ($_ eq 'CPPDEFINES' || $_ eq 'CPPINCLUDES') {
1188                 $user{$_} = [ split /$list_separator_re/, $value ];
1189             } else {
1190                 $user{$_} = [ $value ];
1191             }
1192         } elsif (!defined $user{$_}) {
1193             $user{$_} = $value;
1194         }
1195     }
1196 }
1197
1198 if (grep { /-rpath\b/ } ($user{LDFLAGS} ? @{$user{LDFLAGS}} : ())
1199     && !$disabled{shared}
1200     && !($disabled{asan} && $disabled{msan} && $disabled{ubsan})) {
1201     die "***** Cannot simultaneously use -rpath, shared libraries, and\n",
1202         "***** any of asan, msan or ubsan\n";
1203 }
1204
1205 # If no target was given, try guessing.
1206 unless ($target) {
1207     my %system_config = OpenSSL::config::get_platform(%guess_opts, %user);
1208
1209     # The $system_config{disable} is used to populate %disabled with
1210     # entries that aren't already there.
1211     foreach ( @{$system_config{disable} // []} ) {
1212         $disabled{$_} = 'system' unless defined $disabled{$_};
1213     }
1214     delete $system_config{disable};
1215
1216     # Override config entries with stuff from the guesser.
1217     # It's assumed that this really is nothing new.
1218     %config = ( %config, %system_config );
1219     $target = $system_config{target};
1220 }
1221
1222 sub disable {
1223     my $disable_type = shift;
1224
1225     for (@_) {
1226         $disabled{$_} = $disable_type;
1227     }
1228
1229     my @tocheckfor = (@_ ? @_ : keys %disabled);
1230     while (@tocheckfor) {
1231         my %new_tocheckfor = ();
1232         my @cascade_copy = (@disable_cascades);
1233         while (@cascade_copy) {
1234             my ($test, $descendents) =
1235                 (shift @cascade_copy, shift @cascade_copy);
1236             if (ref($test) eq "CODE" ? $test->() : defined($disabled{$test})) {
1237                 foreach (grep { !defined($disabled{$_}) } @$descendents) {
1238                     $new_tocheckfor{$_} = 1; $disabled{$_} = "cascade";
1239                 }
1240             }
1241         }
1242         @tocheckfor = (keys %new_tocheckfor);
1243     }
1244 }
1245 disable();                     # First cascade run
1246
1247 our $die = sub { die @_; };
1248 if ($target eq "TABLE") {
1249     local $die = sub { warn @_; };
1250     foreach (sort keys %table) {
1251         print_table_entry($_, "TABLE");
1252     }
1253     exit 0;
1254 }
1255
1256 if ($target eq "LIST") {
1257     foreach (sort keys %table) {
1258         print $_,"\n" unless $table{$_}->{template};
1259     }
1260     exit 0;
1261 }
1262
1263 if ($target eq "HASH") {
1264     local $die = sub { warn @_; };
1265     print "%table = (\n";
1266     foreach (sort keys %table) {
1267         print_table_entry($_, "HASH");
1268     }
1269     exit 0;
1270 }
1271
1272 print "Configuring OpenSSL version $config{full_version} ";
1273 print "for target $target\n";
1274
1275 if (scalar(@seed_sources) == 0) {
1276     print "Using os-specific seed configuration\n";
1277     push @seed_sources, 'os';
1278 }
1279 if (scalar(grep { $_ eq 'egd' } @seed_sources) > 0) {
1280     delete $disabled{'egd'};
1281 }
1282 if (scalar(grep { $_ eq 'none' } @seed_sources) > 0) {
1283     die "Cannot seed with none and anything else" if scalar(@seed_sources) > 1;
1284     warn <<_____ if scalar(@seed_sources) == 1;
1285
1286 ============================== WARNING ===============================
1287 You have selected the --with-rand-seed=none option, which effectively
1288 disables automatic reseeding of the OpenSSL random generator.
1289 All operations depending on the random generator such as creating keys
1290 will not work unless the random generator is seeded manually by the
1291 application.
1292
1293 Please read the 'Note on random number generation' section in the
1294 INSTALL.md instructions and the RAND_DRBG(7) manual page for more
1295 details.
1296 ============================== WARNING ===============================
1297
1298 _____
1299 }
1300 push @{$config{openssl_feature_defines}},
1301      map { (my $x = $_) =~ tr|[\-a-z]|[_A-Z]|; "OPENSSL_RAND_SEED_$x" }
1302         @seed_sources;
1303
1304 # Backward compatibility?
1305 if ($target =~ m/^CygWin32(-.*)$/) {
1306     $target = "Cygwin".$1;
1307 }
1308
1309 # Support for legacy targets having a name starting with 'debug-'
1310 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
1311 if ($d) {
1312     $config{build_type} = "debug";
1313
1314     # If we do not find debug-foo in the table, the target is set to foo.
1315     if (!$table{$target}) {
1316         $target = $t;
1317     }
1318 }
1319
1320 if ($target) {
1321     # It's possible that we have different config targets for specific
1322     # toolchains, so we try to detect them, and go for the plain config
1323     # target if not.
1324     my $found;
1325     foreach ( ( "$target-$user{CC}", "$target", undef ) ) {
1326         $found=$_ if $table{$_} && !$table{$_}->{template};
1327         last if $found;
1328     }
1329     $target = $found;
1330 } else {
1331     # If we don't have a config target now, we try the C compiler as we
1332     # fallback
1333     my $cc = $user{CC} // 'cc';
1334     $target = $cc if $table{$cc} && !$table{$cc}->{template};
1335 }
1336
1337 &usage unless $target;
1338
1339 exit 0 if $dryrun;              # From older 'config'
1340
1341 $config{target} = $target;
1342 my %target = resolve_config($target);
1343
1344 foreach (keys %target_attr_translate) {
1345     $target{$target_attr_translate{$_}} = $target{$_}
1346         if $target{$_};
1347     delete $target{$_};
1348 }
1349
1350 %target = ( %{$table{DEFAULTS}}, %target );
1351
1352 my %conf_files = map { $_ => 1 } (@{$target{_conf_fname_int}});
1353 $config{conf_files} = [ sort keys %conf_files ];
1354
1355 # Using sub disable within these loops may prove fragile, so we run
1356 # a cascade afterwards
1357 foreach my $feature (@{$target{disable}}) {
1358     if (exists $deprecated_disablables{$feature}) {
1359         warn "***** config $target disables deprecated feature $feature\n";
1360     } elsif (!grep { $feature eq $_ } @disablables) {
1361         die "***** config $target disables unknown feature $feature\n";
1362     }
1363     $disabled{$feature} = 'config';
1364 }
1365 foreach my $feature (@{$target{enable}}) {
1366     if ("default" eq ($disabled{$feature} // "")) {
1367         if (exists $deprecated_disablables{$feature}) {
1368             warn "***** config $target enables deprecated feature $feature\n";
1369         } elsif (!grep { $feature eq $_ } @disablables) {
1370             die "***** config $target enables unknown feature $feature\n";
1371         }
1372         delete $disabled{$feature};
1373     }
1374 }
1375
1376 # If uplink_arch isn't defined, disable uplink
1377 $disabled{uplink} = 'no uplink_arch' unless (defined $target{uplink_arch});
1378 # If asm_arch isn't defined, disable asm
1379 $disabled{asm} = 'no asm_arch' unless (defined $target{asm_arch});
1380
1381 disable();                      # Run a cascade now
1382
1383 $target{CXXFLAGS}//=$target{CFLAGS} if $target{CXX};
1384 $target{cxxflags}//=$target{cflags} if $target{CXX};
1385 $target{exe_extension}=".exe" if ($config{target} eq "DJGPP");
1386 $target{exe_extension}=".pm"  if ($config{target} =~ /vos/);
1387
1388 # Fill %config with values from %user, and in case those are undefined or
1389 # empty, use values from %target (acting as a default).
1390 foreach (keys %user) {
1391     my $ref_type = ref $user{$_};
1392
1393     # Temporary function.  Takes an intended ref type (empty string or "ARRAY")
1394     # and a value that's to be coerced into that type.
1395     my $mkvalue = sub {
1396         my $type = shift;
1397         my $value = shift;
1398         my $undef_p = shift;
1399
1400         die "Too many arguments for \$mkvalue" if @_;
1401
1402         while (ref $value eq 'CODE') {
1403             $value = $value->();
1404         }
1405
1406         if ($type eq 'ARRAY') {
1407             return undef unless defined $value;
1408             return undef if ref $value ne 'ARRAY' && !$value;
1409             return undef if ref $value eq 'ARRAY' && !@$value;
1410             return [ $value ] unless ref $value eq 'ARRAY';
1411         }
1412         return undef unless $value;
1413         return $value;
1414     };
1415
1416     $config{$_} =
1417         $mkvalue->($ref_type, $user{$_})
1418         || $mkvalue->($ref_type, $target{$_});
1419     delete $config{$_} unless defined $config{$_};
1420 }
1421
1422 # Finish up %config by appending things the user gave us on the command line
1423 # apart from "make variables"
1424 foreach (keys %useradd) {
1425     # The must all be lists, so we assert that here
1426     die "internal error: \$useradd{$_} isn't an ARRAY\n"
1427         unless ref $useradd{$_} eq 'ARRAY';
1428
1429     if (defined $config{$_}) {
1430         push @{$config{$_}}, @{$useradd{$_}};
1431     } else {
1432         $config{$_} = [ @{$useradd{$_}} ];
1433     }
1434 }
1435 # At this point, we can forget everything about %user and %useradd,
1436 # because it's now all been merged into the corresponding $config entry
1437
1438 if (grep { $_ =~ /(?:^|\s)-static(?:\s|$)/ } @{$config{LDFLAGS}}) {
1439     disable('static', 'pic', 'threads');
1440 }
1441
1442 # Allow overriding the build file name
1443 $config{build_file} = env('BUILDFILE') || $target{build_file} || "Makefile";
1444
1445 # Make sure build_scheme is consistent.
1446 $target{build_scheme} = [ $target{build_scheme} ]
1447     if ref($target{build_scheme}) ne "ARRAY";
1448
1449 my ($builder, $builder_platform, @builder_opts) =
1450     @{$target{build_scheme}};
1451
1452 foreach my $checker (($builder_platform."-".$config{build_file}."-checker.pm",
1453                       $builder_platform."-checker.pm")) {
1454     my $checker_path = catfile($srcdir, "Configurations", $checker);
1455     if (-f $checker_path) {
1456         my $fn = $ENV{CONFIGURE_CHECKER_WARN}
1457             ? sub { warn $@; } : sub { die $@; };
1458         if (! do $checker_path) {
1459             if ($@) {
1460                 $fn->($@);
1461             } elsif ($!) {
1462                 $fn->($!);
1463             } else {
1464                 $fn->("The detected tools didn't match the platform\n");
1465             }
1466         }
1467         last;
1468     }
1469 }
1470
1471 push @{$config{defines}}, "NDEBUG"    if $config{build_type} eq "release";
1472
1473 if ($target =~ /^mingw/ && `$config{CC} --target-help 2>&1` =~ m/-mno-cygwin/m)
1474         {
1475         push @{$config{cflags}}, "-mno-cygwin";
1476         push @{$config{cxxflags}}, "-mno-cygwin" if $config{CXX};
1477         push @{$config{shared_ldflag}}, "-mno-cygwin";
1478         }
1479
1480 if ($target =~ /linux.*-mips/ && !$disabled{asm}
1481         && !grep { $_ !~ /-m(ips|arch=)/ } (@{$config{CFLAGS}})) {
1482         # minimally required architecture flags for assembly modules
1483         my $value;
1484         $value = '-mips2' if ($target =~ /mips32/);
1485         $value = '-mips3' if ($target =~ /mips64/);
1486         unshift @{$config{cflags}}, $value;
1487         unshift @{$config{cxxflags}}, $value if $config{CXX};
1488 }
1489
1490 # If threads aren't disabled, check how possible they are
1491 unless ($disabled{threads}) {
1492     if ($auto_threads) {
1493         # Enabled by default, disable it forcibly if unavailable
1494         if ($target{thread_scheme} eq "(unknown)") {
1495             disable("unavailable", 'threads');
1496         }
1497     } else {
1498         # The user chose to enable threads explicitly, let's see
1499         # if there's a chance that's possible
1500         if ($target{thread_scheme} eq "(unknown)") {
1501             # If the user asked for "threads" and we don't have internal
1502             # knowledge how to do it, [s]he is expected to provide any
1503             # system-dependent compiler options that are necessary.  We
1504             # can't truly check that the given options are correct, but
1505             # we expect the user to know what [s]He is doing.
1506             if (!@{$config{CFLAGS}} && !@{$config{CPPDEFINES}}) {
1507                 die "You asked for multi-threading support, but didn't\n"
1508                     ,"provide any system-specific compiler options\n";
1509             }
1510         }
1511     }
1512 }
1513
1514 # Find out if clang's sanitizers have been enabled with -fsanitize
1515 # flags and ensure that the corresponding %disabled elements area
1516 # removed to reflect that the sanitizers are indeed enabled.
1517 my %detected_sanitizers = ();
1518 foreach (grep /^-fsanitize=/, @{$config{CFLAGS} || []}) {
1519     (my $checks = $_) =~ s/^-fsanitize=//;
1520     foreach (split /,/, $checks) {
1521         my $d = { address       => 'asan',
1522                   undefined     => 'ubsan',
1523                   memory        => 'msan' } -> {$_};
1524         next unless defined $d;
1525
1526         $detected_sanitizers{$d} = 1;
1527         if (defined $disabled{$d}) {
1528             die "***** Conflict between disabling $d and enabling $_ sanitizer"
1529                 if $disabled{$d} ne "default";
1530             delete $disabled{$d};
1531         }
1532     }
1533 }
1534
1535 # If threads still aren't disabled, add a C macro to ensure the source
1536 # code knows about it.  Any other flag is taken care of by the configs.
1537 unless($disabled{threads}) {
1538     push @{$config{openssl_feature_defines}}, "OPENSSL_THREADS";
1539 }
1540
1541 my $no_shared_warn=0;
1542 if (($target{shared_target} // '') eq "")
1543         {
1544         $no_shared_warn = 1
1545             if (!$disabled{shared} || !$disabled{"dynamic-engine"});
1546         disable('no-shared-target', 'pic');
1547         }
1548
1549 if ($disabled{"dynamic-engine"}) {
1550         $config{dynamic_engines} = 0;
1551 } else {
1552         $config{dynamic_engines} = 1;
1553 }
1554
1555 unless ($disabled{asan} || defined $detected_sanitizers{asan}) {
1556     push @{$config{cflags}}, "-fsanitize=address";
1557 }
1558
1559 unless ($disabled{ubsan} || defined $detected_sanitizers{ubsan}) {
1560     push @{$config{cflags}}, "-fsanitize=undefined", "-fno-sanitize-recover=all", "-DPEDANTIC";
1561 }
1562
1563 unless ($disabled{msan} || defined $detected_sanitizers{msan}) {
1564   push @{$config{cflags}}, "-fsanitize=memory";
1565 }
1566
1567 unless ($disabled{"fuzz-libfuzzer"} && $disabled{"fuzz-afl"}
1568         && $disabled{asan} && $disabled{ubsan} && $disabled{msan}) {
1569     push @{$config{cflags}}, "-fno-omit-frame-pointer", "-g";
1570     push @{$config{cxxflags}}, "-fno-omit-frame-pointer", "-g" if $config{CXX};
1571 }
1572 #
1573 # Platform fix-ups
1574 #
1575
1576 # This saves the build files from having to check
1577 if ($disabled{pic})
1578         {
1579         foreach (qw(shared_cflag shared_cxxflag shared_cppflag
1580                     shared_defines shared_includes shared_ldflag
1581                     module_cflags module_cxxflags module_cppflags
1582                     module_defines module_includes module_lflags))
1583                 {
1584                 delete $config{$_};
1585                 $target{$_} = "";
1586                 }
1587         }
1588 else
1589         {
1590         push @{$config{lib_defines}}, "OPENSSL_PIC";
1591         }
1592
1593 if ($target{sys_id} ne "")
1594         {
1595         push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
1596         }
1597
1598 my %predefined_C = compiler_predefined($config{CROSS_COMPILE}.$config{CC});
1599 my %predefined_CXX = $config{CXX}
1600     ? compiler_predefined($config{CROSS_COMPILE}.$config{CXX})
1601     : ();
1602
1603 unless ($disabled{asm}) {
1604     # big endian systems can use ELFv2 ABI
1605     if ($target eq "linux-ppc64" || $target eq "BSD-ppc64") {
1606         $target{perlasm_scheme} = "linux64v2" if ($predefined_C{_CALL_ELF} == 2);
1607     }
1608 }
1609
1610 # Check for makedepend capabilities.
1611 if (!$disabled{makedepend}) {
1612     # If the attribute makedep_scheme is defined, then we assume that the
1613     # config target and its associated build file are programmed to deal
1614     # with it.
1615     # If makedep_scheme is undefined, we go looking for GCC compatible
1616     # dependency making, and if that's not available, we try to fall back
1617     # on 'makedepend'.
1618     if ($target{makedep_scheme}) {
1619         $config{makedep_scheme} = $target{makedep_scheme};
1620         # If the makedepcmd attribute is defined, copy it.  If not, the
1621         # build files will have to fend for themselves.
1622         $config{makedepcmd} = $target{makedepcmd} if $target{makedepcmd};
1623     } elsif (($predefined_C{__GNUC__} // -1) >= 3
1624              && !($predefined_C{__APPLE_CC__} && !$predefined_C{__clang__})) {
1625         # We know that GNU C version 3 and up as well as all clang
1626         # versions support dependency generation, but Xcode did not
1627         # handle $cc -M before clang support (but claims __GNUC__ = 3)
1628         $config{makedep_scheme} = 'gcc';
1629     } else {
1630         # In all other cases, we look for 'makedepend', and set the
1631         # makedep_scheme value if we found it.
1632         $config{makedepcmd} = which('makedepend');
1633         $config{makedep_scheme} = 'makedepend' if $config{makedepcmd};
1634     }
1635
1636     # If no depend scheme is set, we disable makedepend
1637     disable('unavailable', 'makedepend') unless $config{makedep_scheme};
1638 }
1639
1640 if (!$disabled{asm} && !$predefined_C{__MACH__} && $^O ne 'VMS') {
1641     # probe for -Wa,--noexecstack option...
1642     if ($predefined_C{__clang__}) {
1643         # clang has builtin assembler, which doesn't recognize --help,
1644         # but it apparently recognizes the option in question on all
1645         # supported platforms even when it's meaningless. In other words
1646         # probe would fail, but probed option always accepted...
1647         push @{$config{cflags}}, "-Wa,--noexecstack", "-Qunused-arguments";
1648     } else {
1649         my $cc = $config{CROSS_COMPILE}.$config{CC};
1650         open(PIPE, "$cc -Wa,--help -c -o null.$$.o -x assembler /dev/null 2>&1 |");
1651         while(<PIPE>) {
1652             if (m/--noexecstack/) {
1653                 push @{$config{cflags}}, "-Wa,--noexecstack";
1654                 last;
1655             }
1656         }
1657         close(PIPE);
1658         unlink("null.$$.o");
1659     }
1660 }
1661
1662 # Deal with bn_ops ###################################################
1663
1664 $config{bn_ll}                  =0;
1665 my $def_int="unsigned int";
1666 $config{rc4_int}                =$def_int;
1667 ($config{b64l},$config{b64},$config{b32})=(0,0,1);
1668
1669 my $count = 0;
1670 foreach (sort split(/\s+/,$target{bn_ops})) {
1671     $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1672     $config{bn_ll}=1                            if $_ eq 'BN_LLONG';
1673     $config{rc4_int}="unsigned char"            if $_ eq 'RC4_CHAR';
1674     ($config{b64l},$config{b64},$config{b32})
1675         =(0,1,0)                                if $_ eq 'SIXTY_FOUR_BIT';
1676     ($config{b64l},$config{b64},$config{b32})
1677         =(1,0,0)                                if $_ eq 'SIXTY_FOUR_BIT_LONG';
1678     ($config{b64l},$config{b64},$config{b32})
1679         =(0,0,1)                                if $_ eq 'THIRTY_TWO_BIT';
1680 }
1681 die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1682     if $count > 1;
1683
1684 $config{api} = $config{major} * 10000 + $config{minor} * 100
1685     unless $config{api};
1686 foreach (keys %$apitable) {
1687     $disabled{"deprecated-$_"} = "deprecation"
1688         if $disabled{deprecated} && $config{api} >= $apitable->{$_};
1689 }
1690
1691 disable();                      # Run a cascade now
1692
1693 # Hack cflags for better warnings (dev option) #######################
1694
1695 # "Stringify" the C and C++ flags string.  This permits it to be made part of
1696 # a string and works as well on command lines.
1697 $config{cflags} = [ map { (my $x = $_) =~ s/([\\\"])/\\$1/g; $x }
1698                         @{$config{cflags}} ];
1699 $config{cxxflags} = [ map { (my $x = $_) =~ s/([\\\"])/\\$1/g; $x }
1700                           @{$config{cxxflags}} ] if $config{CXX};
1701
1702 $config{openssl_api_defines} = [
1703     "OPENSSL_CONFIGURED_API=".$config{api},
1704 ];
1705
1706 my @strict_warnings_collection=();
1707 if ($strict_warnings)
1708         {
1709         my $wopt;
1710         my $gccver = $predefined_C{__GNUC__} // -1;
1711
1712         if ($gccver >= 4)
1713                 {
1714                 push @strict_warnings_collection, @gcc_devteam_warn;
1715                 push @strict_warnings_collection, @clang_devteam_warn
1716                     if (defined($predefined_C{__clang__}));
1717                 }
1718         elsif ($config{target} =~ /^VC-/)
1719                 {
1720                 push @strict_warnings_collection, @cl_devteam_warn;
1721                 }
1722         else
1723                 {
1724                 warn "WARNING --strict-warnings requires gcc[>=4] or gcc-alike, or MSVC"
1725                 }
1726         }
1727
1728 $config{CFLAGS} = [ map { $_ eq '--ossl-strict-warnings'
1729                               ? @strict_warnings_collection
1730                               : ( $_ ) }
1731                     @{$config{CFLAGS}} ];
1732
1733 unless ($disabled{afalgeng}) {
1734     $config{afalgeng}="";
1735     if (grep { $_ eq 'afalgeng' } @{$target{enable}}) {
1736         push @{$config{engdirs}}, "afalg";
1737     } else {
1738         disable('not-linux', 'afalgeng');
1739     }
1740 }
1741
1742 unless ($disabled{devcryptoeng}) {
1743     if ($target =~ m/^BSD/) {
1744         my $maxver = 5*100 + 7;
1745         my $sysstr = `uname -s`;
1746         my $verstr = `uname -r`;
1747         $sysstr =~ s|\R$||;
1748         $verstr =~ s|\R$||;
1749         my ($ma, $mi, @rest) = split m|\.|, $verstr;
1750         my $ver = $ma*100 + $mi;
1751         if ($sysstr eq 'OpenBSD' && $ver >= $maxver) {
1752             disable('too-new-kernel', 'devcryptoeng');
1753         }
1754     }
1755 }
1756
1757 unless ($disabled{ktls}) {
1758     $config{ktls}="";
1759     my $cc = $config{CROSS_COMPILE}.$config{CC};
1760     if ($target =~ m/^linux/) {
1761         system("printf '#include <sys/types.h>\n#include <linux/tls.h>' | $cc -E - >/dev/null 2>&1");
1762         if ($? != 0) {
1763             disable('too-old-kernel', 'ktls');
1764         }
1765     } elsif ($target =~ m/^BSD/) {
1766         system("printf '#include <sys/types.h>\n#include <sys/ktls.h>' | $cc -E - >/dev/null 2>&1");
1767         if ($? != 0) {
1768             disable('too-old-freebsd', 'ktls');
1769         }
1770     } else {
1771         disable('not-linux-or-freebsd', 'ktls');
1772     }
1773 }
1774
1775 unless ($disabled{winstore}) {
1776     unless ($target =~ /^(?:Cygwin|mingw|VC-|BC-)/) {
1777         disable('not-windows', 'winstore');
1778     }
1779 }
1780
1781 push @{$config{openssl_other_defines}}, "OPENSSL_NO_KTLS" if ($disabled{ktls});
1782
1783 # Get the extra flags used when building shared libraries and modules.  We
1784 # do this late because some of them depend on %disabled.
1785
1786 # Make the flags to build DSOs the same as for shared libraries unless they
1787 # are already defined
1788 $target{module_cflags} = $target{shared_cflag} unless defined $target{module_cflags};
1789 $target{module_cxxflags} = $target{shared_cxxflag} unless defined $target{module_cxxflags};
1790 $target{module_ldflags} = $target{shared_ldflag} unless defined $target{module_ldflags};
1791 {
1792     my $shared_info_pl =
1793         catfile(dirname($0), "Configurations", "shared-info.pl");
1794     my %shared_info = read_eval_file($shared_info_pl);
1795     push @{$target{_conf_fname_int}}, $shared_info_pl;
1796     my $si = $target{shared_target};
1797     while (ref $si ne "HASH") {
1798         last if ! defined $si;
1799         if (ref $si eq "CODE") {
1800             $si = $si->();
1801         } else {
1802             $si = $shared_info{$si};
1803         }
1804     }
1805
1806     # Some of the 'shared_target' values don't have any entries in
1807     # %shared_info.  That's perfectly fine, AS LONG AS the build file
1808     # template knows how to handle this.  That is currently the case for
1809     # Windows and VMS.
1810     if (defined $si) {
1811         # Just as above, copy certain shared_* attributes to the corresponding
1812         # module_ attribute unless the latter is already defined
1813         $si->{module_cflags} = $si->{shared_cflag} unless defined $si->{module_cflags};
1814         $si->{module_cxxflags} = $si->{shared_cxxflag} unless defined $si->{module_cxxflags};
1815         $si->{module_ldflags} = $si->{shared_ldflag} unless defined $si->{module_ldflags};
1816         foreach (sort keys %$si) {
1817             $target{$_} = defined $target{$_}
1818                 ? add($si->{$_})->($target{$_})
1819                 : $si->{$_};
1820         }
1821     }
1822 }
1823
1824 # ALL MODIFICATIONS TO %disabled, %config and %target MUST BE DONE FROM HERE ON
1825
1826 ######################################################################
1827 # Build up information for skipping certain directories depending on disabled
1828 # features, as well as setting up macros for disabled features.
1829
1830 # This is a tentative database of directories to skip.  Some entries may not
1831 # correspond to anything real, but that's ok, they will simply be ignored.
1832 # The actual processing of these entries is done in the build.info lookup
1833 # loop further down.
1834 #
1835 # The key is a Unix formatted path in the source tree, the value is an index
1836 # into %disabled_info, so any existing path gets added to a corresponding
1837 # 'skipped' entry in there with the list of skipped directories.
1838 my %skipdir = ();
1839 my %disabled_info = ();         # For configdata.pm
1840 foreach my $what (sort keys %disabled) {
1841     # There are deprecated disablables that translate to themselves.
1842     # They cause disabling cascades, but should otherwise not register.
1843     next if $deprecated_disablables{$what};
1844     # The generated $disabled{"deprecated-x.y"} entries are special
1845     # and treated properly elsewhere
1846     next if $what =~ m|^deprecated-|;
1847
1848     $config{options} .= " no-$what";
1849
1850     if (!grep { $what eq $_ } ( 'buildtest-c++', 'fips', 'threads', 'shared',
1851                                 'module', 'pic', 'dynamic-engine', 'makedepend',
1852                                 'sse2', 'legacy' )) {
1853         (my $WHAT = uc $what) =~ s|-|_|g;
1854         my $skipdir = $what;
1855
1856         # fix-up crypto/directory name(s)
1857         $skipdir = "ripemd" if $what eq "rmd160";
1858         $skipdir = "whrlpool" if $what eq "whirlpool";
1859
1860         my $macro = $disabled_info{$what}->{macro} = "OPENSSL_NO_$WHAT";
1861         push @{$config{openssl_feature_defines}}, $macro;
1862
1863         $skipdir{engines} = $what if $what eq 'engine';
1864         $skipdir{"crypto/$skipdir"} = $what
1865             unless $what eq 'async' || $what eq 'err' || $what eq 'dso';
1866     }
1867 }
1868
1869 if ($disabled{"dynamic-engine"}) {
1870     push @{$config{openssl_feature_defines}}, "OPENSSL_NO_DYNAMIC_ENGINE";
1871 } else {
1872     push @{$config{openssl_feature_defines}}, "OPENSSL_NO_STATIC_ENGINE";
1873 }
1874
1875 # If we use the unified build, collect information from build.info files
1876 my %unified_info = ();
1877
1878 my $buildinfo_debug = defined($ENV{CONFIGURE_DEBUG_BUILDINFO});
1879 if ($builder eq "unified") {
1880     use Text::Template 1.46;
1881
1882     sub cleandir {
1883         my $base = shift;
1884         my $dir = shift;
1885         my $relativeto = shift || ".";
1886
1887         $dir = catdir($base,$dir) unless isabsolute($dir);
1888
1889         # Make sure the directories we're building in exists
1890         mkpath($dir);
1891
1892         my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
1893         #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1894         return $res;
1895     }
1896
1897     sub cleanfile {
1898         my $base = shift;
1899         my $file = shift;
1900         my $relativeto = shift || ".";
1901
1902         $file = catfile($base,$file) unless isabsolute($file);
1903
1904         my $d = dirname($file);
1905         my $f = basename($file);
1906
1907         # Make sure the directories we're building in exists
1908         mkpath($d);
1909
1910         my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
1911         #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1912         return $res;
1913     }
1914
1915     # Store the name of the template file we will build the build file from
1916     # in %config.  This may be useful for the build file itself.
1917     my @build_file_template_names =
1918         ( $builder_platform."-".$config{build_file}.".tmpl",
1919           $config{build_file}.".tmpl" );
1920     my @build_file_templates = ();
1921
1922     # First, look in the user provided directory, if given
1923     if (defined env($local_config_envname)) {
1924         @build_file_templates =
1925             map {
1926                 if ($^O eq 'VMS') {
1927                     # VMS environment variables are logical names,
1928                     # which can be used as is
1929                     $local_config_envname . ':' . $_;
1930                 } else {
1931                     catfile(env($local_config_envname), $_);
1932                 }
1933             }
1934             @build_file_template_names;
1935     }
1936     # Then, look in our standard directory
1937     push @build_file_templates,
1938         ( map { cleanfile($srcdir, catfile("Configurations", $_), $blddir) }
1939           @build_file_template_names );
1940
1941     my $build_file_template;
1942     for $_ (@build_file_templates) {
1943         $build_file_template = $_;
1944         last if -f $build_file_template;
1945
1946         $build_file_template = undef;
1947     }
1948     if (!defined $build_file_template) {
1949         die "*** Couldn't find any of:\n", join("\n", @build_file_templates), "\n";
1950     }
1951     $config{build_file_templates}
1952       = [ cleanfile($srcdir, catfile("Configurations", "common0.tmpl"),
1953                     $blddir),
1954            $build_file_template ];
1955
1956     my @build_dirs = ( [ ] );   # current directory
1957
1958     $config{build_infos} = [ ];
1959
1960     # We want to detect configdata.pm in the source tree, so we
1961     # don't use it if the build tree is different.
1962     my $src_configdata = cleanfile($srcdir, "configdata.pm", $blddir);
1963
1964     # Any source file that we recognise is placed in this hash table, with
1965     # the list of its intended destinations as value.  When everything has
1966     # been collected, there's a routine that checks that these source files
1967     # exist, or if they are generated, that the generator exists.
1968     my %check_exist = ();
1969     my %check_generate = ();
1970
1971     my %ordinals = ();
1972     while (@build_dirs) {
1973         my @curd = @{shift @build_dirs};
1974         my $sourced = catdir($srcdir, @curd);
1975         my $buildd = catdir($blddir, @curd);
1976
1977         my $unixdir = join('/', @curd);
1978         if (exists $skipdir{$unixdir}) {
1979             my $what = $skipdir{$unixdir};
1980             push @{$disabled_info{$what}->{skipped}}, catdir(@curd);
1981             next;
1982         }
1983
1984         mkpath($buildd);
1985
1986         my $f = 'build.info';
1987         # The basic things we're trying to build
1988         my @programs = ();
1989         my @libraries = ();
1990         my @modules = ();
1991         my @scripts = ();
1992
1993         my %sources = ();
1994         my %shared_sources = ();
1995         my %includes = ();
1996         my %defines = ();
1997         my %depends = ();
1998         my %generate = ();
1999         my %imagedocs = ();
2000         my %htmldocs = ();
2001         my %mandocs = ();
2002
2003         # Support for $variablename in build.info files.
2004         # Embedded perl code is the ultimate master, still.  If its output
2005         # contains a dollar sign, it had better be escaped, or it will be
2006         # taken for a variable name prefix.
2007         my %variables = ();
2008         # Variable name syntax
2009         my $variable_name_re = qr/(?P<VARIABLE>[[:alpha:]][[:alnum:]_]*)/;
2010         # Value modifier syntaxes
2011         my $variable_subst_re = qr/\/(?P<RE>(?:\\\/|.)*?)\/(?P<SUBST>.*?)/;
2012         # Variable reference
2013         my $variable_simple_re = qr/(?<!\\)\$${variable_name_re}/;
2014         my $variable_w_mod_re =
2015             qr/(?<!\\)\$\{${variable_name_re}(?P<MOD>(?:\\\/|.)*?)\}/;
2016         # Tie it all together
2017         my $variable_re = qr/${variable_simple_re}|${variable_w_mod_re}/;
2018
2019         my $expand_variables = sub {
2020             my $value = '';
2021             my $value_rest = shift;
2022
2023             if ($ENV{CONFIGURE_DEBUG_VARIABLE_EXPAND}) {
2024                 print STDERR
2025                     "DEBUG[\$expand_variables] Parsed '$value_rest' ...\n"
2026             }
2027
2028             while ($value_rest =~ /${variable_re}/) {
2029                 # We must save important regexp values, because the next
2030                 # regexp clears them
2031                 my $mod = $+{MOD};
2032                 my $variable_value = $variables{$+{VARIABLE}};
2033
2034                 $value_rest = $';
2035                 $value .= $`;
2036
2037                 # Process modifier expressions, if present
2038                 if (defined $mod) {
2039                     if ($mod =~ /^${variable_subst_re}$/) {
2040                         my $re = $+{RE};
2041                         my $subst = $+{SUBST};
2042
2043                         $variable_value =~ s/\Q$re\E/$subst/g;
2044
2045                         if ($ENV{CONFIGURE_DEBUG_VARIABLE_EXPAND}) {
2046                             print STDERR
2047                                 "DEBUG[\$expand_variables] ... and substituted ",
2048                                 "'$re' with '$subst'\n";
2049                         }
2050                     }
2051                 }
2052
2053                 $value .= $variable_value;
2054             }
2055             if ($ENV{CONFIGURE_DEBUG_VARIABLE_EXPAND}) {
2056                 print STDERR
2057                     "DEBUG[\$expand_variables] ... into: '$value$value_rest'\n";
2058             }
2059             return $value . $value_rest;
2060         };
2061
2062         # Support for attributes in build.info files
2063         my %attributes = ();
2064         my $handle_attributes = sub {
2065             my $attr_str = shift;
2066             my $ref = shift;
2067             my @goals = @_;
2068
2069             return unless defined $attr_str;
2070
2071             my @a = tokenize($attr_str, qr|\s*,\s*|);
2072             foreach my $a (@a) {
2073                 my $ac = 1;
2074                 my $ak = $a;
2075                 my $av = 1;
2076                 if ($a =~ m|^(!)?(.*?)\s* = \s*(.*?)$|x) {
2077                     $ac = ! $1;
2078                     $ak = $2;
2079                     $av = $3;
2080                 }
2081                 foreach my $g (@goals) {
2082                     if ($ac) {
2083                         $$ref->{$g}->{$ak} = $av;
2084                     } else {
2085                         delete $$ref->{$g}->{$ak};
2086                     }
2087                 }
2088             }
2089         };
2090
2091         # Support for pushing values on multiple indexes of a given hash
2092         # array.
2093         my $push_to = sub {
2094             my $valueref = shift;
2095             my $index_str = shift; # May be undef or empty
2096             my $attrref = shift;   # May be undef
2097             my $attr_str = shift;
2098             my @values = @_;
2099
2100             if (defined $index_str) {
2101                 my @indexes = ( '' );
2102                 if ($index_str !~ m|^\s*$|) {
2103                     @indexes = tokenize($index_str);
2104                 }
2105                 foreach (@indexes) {
2106                     push @{$valueref->{$_}}, @values;
2107                     if (defined $attrref) {
2108                         $handle_attributes->($attr_str, \$$attrref->{$_},
2109                                              @values);
2110                     }
2111                 }
2112             } else {
2113                 push @$valueref, @values;
2114                 $handle_attributes->($attr_str, $attrref, @values)
2115                     if defined $attrref;
2116             }
2117         };
2118
2119         if ($buildinfo_debug) {
2120             print STDERR "DEBUG: Reading ",catfile($sourced, $f),"\n";
2121         }
2122         push @{$config{build_infos}}, catfile(abs2rel($sourced, $blddir), $f);
2123         my $template =
2124             Text::Template->new(TYPE => 'FILE',
2125                                 SOURCE => catfile($sourced, $f),
2126                                 PREPEND => qq{use lib "$FindBin::Bin/util/perl";});
2127         die "Something went wrong with $sourced/$f: $!\n" unless $template;
2128         my @text =
2129             split /^/m,
2130             $template->fill_in(HASH => { config => \%config,
2131                                          target => \%target,
2132                                          disabled => \%disabled,
2133                                          withargs => \%withargs,
2134                                          builddir => abs2rel($buildd, $blddir),
2135                                          sourcedir => abs2rel($sourced, $blddir),
2136                                          buildtop => abs2rel($blddir, $blddir),
2137                                          sourcetop => abs2rel($srcdir, $blddir) },
2138                                DELIMITERS => [ "{-", "-}" ]);
2139
2140         # The top item of this stack has the following values
2141         # -2 positive already run and we found ELSE (following ELSIF should fail)
2142         # -1 positive already run (skip until ENDIF)
2143         # 0 negatives so far (if we're at a condition, check it)
2144         # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
2145         # 2 positive ELSE (following ELSIF should fail)
2146         my @skip = ();
2147
2148         # A few useful generic regexps
2149         my $index_re = qr/\[\s*(?P<INDEX>(?:\\.|.)*?)\s*\]/;
2150         my $cond_re = qr/\[\s*(?P<COND>(?:\\.|.)*?)\s*\]/;
2151         my $attribs_re = qr/(?:\{\s*(?P<ATTRIBS>(?:\\.|.)*?)\s*\})?/;
2152         my $value_re = qr/(?P<VALUE>.*?)/;
2153         collect_information(
2154             collect_from_array([ @text ],
2155                                qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
2156                                                 $l1 =~ s/\\$//; $l1.$l2 }),
2157             # Info we're looking for
2158             qr/^\s* IF ${cond_re} \s*$/x
2159             => sub {
2160                 if (! @skip || $skip[$#skip] > 0) {
2161                     push @skip, !! $expand_variables->($+{COND});
2162                 } else {
2163                     push @skip, -1;
2164                 }
2165             },
2166             qr/^\s* ELSIF ${cond_re} \s*$/x
2167             => sub { die "ELSIF out of scope" if ! @skip;
2168                      die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
2169                      $skip[$#skip] = -1 if $skip[$#skip] != 0;
2170                      $skip[$#skip] = !! $expand_variables->($+{COND})
2171                          if $skip[$#skip] == 0; },
2172             qr/^\s* ELSE \s*$/x
2173             => sub { die "ELSE out of scope" if ! @skip;
2174                      $skip[$#skip] = -2 if $skip[$#skip] != 0;
2175                      $skip[$#skip] = 2 if $skip[$#skip] == 0; },
2176             qr/^\s* ENDIF \s*$/x
2177             => sub { die "ENDIF out of scope" if ! @skip;
2178                      pop @skip; },
2179             qr/^\s* ${variable_re} \s* = \s* ${value_re} \s* $/x
2180             => sub {
2181                 if (!@skip || $skip[$#skip] > 0) {
2182                     $variables{$+{VARIABLE}} = $expand_variables->($+{VALUE});
2183                 }
2184             },
2185             qr/^\s* SUBDIRS \s* = \s* ${value_re} \s* $/x
2186             => sub {
2187                 if (!@skip || $skip[$#skip] > 0) {
2188                     foreach (tokenize($expand_variables->($+{VALUE}))) {
2189                         push @build_dirs, [ @curd, splitdir($_, 1) ];
2190                     }
2191                 }
2192             },
2193             qr/^\s* PROGRAMS ${attribs_re} \s* =  \s* ${value_re} \s* $/x
2194             => sub { $push_to->(\@programs, undef,
2195                                 \$attributes{programs}, $+{ATTRIBS},
2196                                 tokenize($expand_variables->($+{VALUE})))
2197                          if !@skip || $skip[$#skip] > 0; },
2198             qr/^\s* LIBS ${attribs_re} \s* =  \s* ${value_re} \s* $/x
2199             => sub { $push_to->(\@libraries, undef,
2200                                 \$attributes{libraries}, $+{ATTRIBS},
2201                                 tokenize($expand_variables->($+{VALUE})))
2202                          if !@skip || $skip[$#skip] > 0; },
2203             qr/^\s* MODULES ${attribs_re} \s* =  \s* ${value_re} \s* $/x
2204             => sub { $push_to->(\@modules, undef,
2205                                 \$attributes{modules}, $+{ATTRIBS},
2206                                 tokenize($expand_variables->($+{VALUE})))
2207                          if !@skip || $skip[$#skip] > 0; },
2208             qr/^\s* SCRIPTS ${attribs_re} \s* = \s* ${value_re} \s* $/x
2209             => sub { $push_to->(\@scripts, undef,
2210                                 \$attributes{scripts}, $+{ATTRIBS},
2211                                 tokenize($expand_variables->($+{VALUE})))
2212                          if !@skip || $skip[$#skip] > 0; },
2213             qr/^\s* IMAGEDOCS ${index_re} \s* = \s* ${value_re} \s* $/x
2214             => sub { $push_to->(\%imagedocs, $expand_variables->($+{INDEX}),
2215                                 undef, undef,
2216                                 tokenize($expand_variables->($+{VALUE})))
2217                          if !@skip || $skip[$#skip] > 0; },
2218             qr/^\s* HTMLDOCS ${index_re} \s* = \s* ${value_re} \s* $/x
2219             => sub { $push_to->(\%htmldocs, $expand_variables->($+{INDEX}),
2220                                 undef, undef,
2221                                 tokenize($expand_variables->($+{VALUE})))
2222                          if !@skip || $skip[$#skip] > 0; },
2223             qr/^\s* MANDOCS ${index_re} \s* = \s* ${value_re} \s* $/x
2224             => sub { $push_to->(\%mandocs, $expand_variables->($+{INDEX}),
2225                                 undef, undef,
2226                                 tokenize($expand_variables->($+{VALUE})))
2227                          if !@skip || $skip[$#skip] > 0; },
2228             qr/^\s* SOURCE ${index_re} ${attribs_re} \s* = \s* ${value_re} \s* $/x
2229             => sub { $push_to->(\%sources, $expand_variables->($+{INDEX}),
2230                                 \$attributes{sources}, $+{ATTRIBS},
2231                                 tokenize($expand_variables->($+{VALUE})))
2232                          if !@skip || $skip[$#skip] > 0; },
2233             qr/^\s* SHARED_SOURCE ${index_re} ${attribs_re} \s* = \s* ${value_re} \s* $/x
2234             => sub { $push_to->(\%shared_sources, $expand_variables->($+{INDEX}),
2235                                 \$attributes{sources}, $+{ATTRIBS},
2236                                 tokenize($expand_variables->($+{VALUE})))
2237                          if !@skip || $skip[$#skip] > 0; },
2238             qr/^\s* INCLUDE ${index_re} \s* = \s* ${value_re} \s* $/x
2239             => sub { $push_to->(\%includes, $expand_variables->($+{INDEX}),
2240                                 undef, undef,
2241                                 tokenize($expand_variables->($+{VALUE})))
2242                          if !@skip || $skip[$#skip] > 0; },
2243             qr/^\s* DEFINE ${index_re} \s* = \s* ${value_re} \s* $/x
2244             => sub { $push_to->(\%defines, $expand_variables->($+{INDEX}),
2245                                 undef, undef,
2246                                 tokenize($expand_variables->($+{VALUE})))
2247                          if !@skip || $skip[$#skip] > 0; },
2248             qr/^\s* DEPEND ${index_re} ${attribs_re} \s* = \s* ${value_re} \s* $/x
2249             => sub { $push_to->(\%depends, $expand_variables->($+{INDEX}),
2250                                 \$attributes{depends}, $+{ATTRIBS},
2251                                 tokenize($expand_variables->($+{VALUE})))
2252                          if !@skip || $skip[$#skip] > 0; },
2253             qr/^\s* GENERATE ${index_re} ${attribs_re} \s* = \s* ${value_re} \s* $/x
2254             => sub { $push_to->(\%generate, $expand_variables->($+{INDEX}),
2255                                 \$attributes{generate}, $+{ATTRIBS},
2256                                 $expand_variables->($+{VALUE}))
2257                          if !@skip || $skip[$#skip] > 0; },
2258             qr/^\s* (?:\#.*)? $/x => sub { },
2259             "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" },
2260             "BEFORE" => sub {
2261                 if ($buildinfo_debug) {
2262                     print STDERR "DEBUG: Parsing ",join(" ", @_),"\n";
2263                     print STDERR "DEBUG: ... before parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
2264                 }
2265             },
2266             "AFTER" => sub {
2267                 if ($buildinfo_debug) {
2268                     print STDERR "DEBUG: .... after parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
2269                 }
2270             },
2271             );
2272         die "runaway IF?" if (@skip);
2273
2274         if (grep { defined $attributes{modules}->{$_}->{engine} } keys %attributes
2275                 and !$config{dynamic_engines}) {
2276             die <<"EOF"
2277 ENGINES can only be used if configured with 'dynamic-engine'.
2278 This is usually a fault in a build.info file.
2279 EOF
2280         }
2281
2282         {
2283             my %infos = ( programs  => [ @programs  ],
2284                           libraries => [ @libraries ],
2285                           modules   => [ @modules   ],
2286                           scripts   => [ @scripts   ] );
2287             foreach my $k (keys %infos) {
2288                 foreach (@{$infos{$k}}) {
2289                     my $item = cleanfile($buildd, $_, $blddir);
2290                     $unified_info{$k}->{$item} = 1;
2291
2292                     # Fix up associated attributes
2293                     $unified_info{attributes}->{$k}->{$item} =
2294                         $attributes{$k}->{$_}
2295                         if defined $attributes{$k}->{$_};
2296                 }
2297             }
2298         }
2299
2300         # Check that we haven't defined any library as both shared and
2301         # explicitly static.  That is forbidden.
2302         my @doubles = ();
2303         foreach (grep /\.a$/, keys %{$unified_info{libraries}}) {
2304             (my $l = $_) =~ s/\.a$//;
2305             push @doubles, $l if defined $unified_info{libraries}->{$l};
2306         }
2307         die "these libraries are both explicitly static and shared:\n  ",
2308             join(" ", @doubles), "\n"
2309             if @doubles;
2310
2311         foreach (keys %sources) {
2312             my $dest = $_;
2313             my $ddest = cleanfile($buildd, $_, $blddir);
2314             foreach (@{$sources{$dest}}) {
2315                 my $s = cleanfile($sourced, $_, $blddir);
2316
2317                 # If it's generated or we simply don't find it in the source
2318                 # tree, we assume it's in the build tree.
2319                 if ($s eq $src_configdata || $generate{$_} || ! -f $s) {
2320                     $s = cleanfile($buildd, $_, $blddir);
2321                 }
2322                 my $o = $_;
2323                 # We recognise C++, C and asm files
2324                 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
2325                     push @{$check_exist{$s}}, $ddest;
2326                     $o =~ s/\.[csS]$/.o/; # C and assembler
2327                     $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
2328                     $o = cleanfile($buildd, $o, $blddir);
2329                     $unified_info{sources}->{$ddest}->{$o} = -1;
2330                     $unified_info{sources}->{$o}->{$s} = -1;
2331                 } elsif ($s =~ /\.rc$/) {
2332                     # We also recognise resource files
2333                     push @{$check_exist{$s}}, $ddest;
2334                     $o =~ s/\.rc$/.res/; # Resource configuration
2335                     $o = cleanfile($buildd, $o, $blddir);
2336                     $unified_info{sources}->{$ddest}->{$o} = -1;
2337                     $unified_info{sources}->{$o}->{$s} = -1;
2338                 } else {
2339                     push @{$check_exist{$s}}, $ddest;
2340                     $unified_info{sources}->{$ddest}->{$s} = 1;
2341                 }
2342                 # Fix up associated attributes
2343                 if ($o ne $_) {
2344                     $unified_info{attributes}->{sources}->{$ddest}->{$o} =
2345                         $unified_info{attributes}->{sources}->{$o}->{$s} =
2346                         $attributes{sources}->{$dest}->{$_}
2347                         if defined $attributes{sources}->{$dest}->{$_};
2348                 } else {
2349                     $unified_info{attributes}->{sources}->{$ddest}->{$s} =
2350                         $attributes{sources}->{$dest}->{$_}
2351                         if defined $attributes{sources}->{$dest}->{$_};
2352                 }
2353             }
2354         }
2355
2356         foreach (keys %shared_sources) {
2357             my $dest = $_;
2358             my $ddest = cleanfile($buildd, $_, $blddir);
2359             foreach (@{$shared_sources{$dest}}) {
2360                 my $s = cleanfile($sourced, $_, $blddir);
2361
2362                 # If it's generated or we simply don't find it in the source
2363                 # tree, we assume it's in the build tree.
2364                 if ($s eq $src_configdata || $generate{$_} || ! -f $s) {
2365                     $s = cleanfile($buildd, $_, $blddir);
2366                 }
2367
2368                 my $o = $_;
2369                 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
2370                     # We recognise C++, C and asm files
2371                     push @{$check_exist{$s}}, $ddest;
2372                     $o =~ s/\.[csS]$/.o/; # C and assembler
2373                     $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
2374                     $o = cleanfile($buildd, $o, $blddir);
2375                     $unified_info{shared_sources}->{$ddest}->{$o} = -1;
2376                     $unified_info{sources}->{$o}->{$s} = -1;
2377                 } elsif ($s =~ /\.rc$/) {
2378                     # We also recognise resource files
2379                     push @{$check_exist{$s}}, $ddest;
2380                     $o =~ s/\.rc$/.res/; # Resource configuration
2381                     $o = cleanfile($buildd, $o, $blddir);
2382                     $unified_info{shared_sources}->{$ddest}->{$o} = -1;
2383                     $unified_info{sources}->{$o}->{$s} = -1;
2384                 } elsif ($s =~ /\.ld$/) {
2385                     # We also recognise linker scripts (or corresponding)
2386                     # We know they are generated files
2387                     push @{$check_exist{$s}}, $ddest;
2388                     $o = cleanfile($buildd, $_, $blddir);
2389                     $unified_info{shared_sources}->{$ddest}->{$o} = 1;
2390                 } else {
2391                     die "unrecognised source file type for shared library: $s\n";
2392                 }
2393                 # Fix up associated attributes
2394                 if ($o ne $_) {
2395                     $unified_info{attributes}->{shared_sources}->{$ddest}->{$o} =
2396                         $unified_info{attributes}->{sources}->{$o}->{$s} =
2397                         $attributes{sources}->{$dest}->{$_}
2398                         if defined $attributes{sources}->{$dest}->{$_};
2399                 } else {
2400                     $unified_info{attributes}->{shared_sources}->{$ddest}->{$o} =
2401                         $attributes{sources}->{$dest}->{$_}
2402                         if defined $attributes{sources}->{$dest}->{$_};
2403                 }
2404             }
2405         }
2406
2407         foreach (keys %generate) {
2408             my $dest = $_;
2409             my $ddest = cleanfile($buildd, $_, $blddir);
2410             die "more than one generator for $dest: "
2411                 ,join(" ", @{$generate{$_}}),"\n"
2412                 if scalar @{$generate{$_}} > 1;
2413             my @generator = split /\s+/, $generate{$dest}->[0];
2414             my $gen = $generator[0];
2415             $generator[0] = cleanfile($sourced, $gen, $blddir);
2416
2417             # If the generator is itself generated, it's in the build tree
2418             if ($generate{$gen} || ! -f $generator[0]) {
2419                 $generator[0] = cleanfile($buildd, $gen, $blddir);
2420             }
2421             $check_generate{$ddest}->{$generator[0]}++;
2422
2423             $unified_info{generate}->{$ddest} = [ @generator ];
2424             # Fix up associated attributes
2425             $unified_info{attributes}->{generate}->{$ddest} =
2426                 $attributes{generate}->{$dest}->{$gen}
2427                 if defined $attributes{generate}->{$dest}->{$gen};
2428         }
2429
2430         foreach (keys %depends) {
2431             my $dest = $_;
2432             my $ddest = $dest;
2433
2434             if ($dest =~ /^\|(.*)\|$/) {
2435                 # Collect the raw target
2436                 $unified_info{targets}->{$1} = 1;
2437                 $ddest = $1;
2438             } elsif ($dest eq '') {
2439                 $ddest = '';
2440             } else {
2441                 $ddest = cleanfile($sourced, $_, $blddir);
2442
2443                 # If the destination doesn't exist in source, it can only be
2444                 # a generated file in the build tree.
2445                 if ($ddest eq $src_configdata || ! -f $ddest) {
2446                     $ddest = cleanfile($buildd, $_, $blddir);
2447                 }
2448             }
2449             foreach (@{$depends{$dest}}) {
2450                 my $d = cleanfile($sourced, $_, $blddir);
2451                 my $d2 = cleanfile($buildd, $_, $blddir);
2452
2453                 # If we know it's generated, or assume it is because we can't
2454                 # find it in the source tree, we set file we depend on to be
2455                 # in the build tree rather than the source tree.
2456                 if ($d eq $src_configdata
2457                     || (grep { $d2 eq $_ }
2458                         keys %{$unified_info{generate}})
2459                     || ! -f $d) {
2460                     $d = $d2;
2461                 }
2462                 $unified_info{depends}->{$ddest}->{$d} = 1;
2463
2464                 # Fix up associated attributes
2465                 $unified_info{attributes}->{depends}->{$ddest}->{$d} =
2466                     $attributes{depends}->{$dest}->{$_}
2467                     if defined $attributes{depends}->{$dest}->{$_};
2468             }
2469         }
2470
2471         foreach (keys %includes) {
2472             my $dest = $_;
2473             my $ddest = cleanfile($sourced, $_, $blddir);
2474
2475             # If the destination doesn't exist in source, it can only be
2476             # a generated file in the build tree.
2477             if ($ddest eq $src_configdata || ! -f $ddest) {
2478                 $ddest = cleanfile($buildd, $_, $blddir);
2479             }
2480             foreach (@{$includes{$dest}}) {
2481                 my $is = cleandir($sourced, $_, $blddir);
2482                 my $ib = cleandir($buildd, $_, $blddir);
2483                 push @{$unified_info{includes}->{$ddest}->{source}}, $is
2484                     unless grep { $_ eq $is } @{$unified_info{includes}->{$ddest}->{source}};
2485                 push @{$unified_info{includes}->{$ddest}->{build}}, $ib
2486                     unless grep { $_ eq $ib } @{$unified_info{includes}->{$ddest}->{build}};
2487             }
2488         }
2489
2490         foreach my $dest (keys %defines) {
2491             my $ddest;
2492
2493             if ($dest ne "") {
2494                 $ddest = cleanfile($sourced, $dest, $blddir);
2495
2496                 # If the destination doesn't exist in source, it can only
2497                 # be a generated file in the build tree.
2498                 if (! -f $ddest) {
2499                     $ddest = cleanfile($buildd, $dest, $blddir);
2500                 }
2501             }
2502             foreach my $v (@{$defines{$dest}}) {
2503                 $v =~ m|^([^=]*)(=.*)?$|;
2504                 die "0 length macro name not permitted\n" if $1 eq "";
2505                 if ($dest ne "") {
2506                     die "$1 defined more than once\n"
2507                         if defined $unified_info{defines}->{$ddest}->{$1};
2508                     $unified_info{defines}->{$ddest}->{$1} = $2;
2509                 } else {
2510                     die "$1 defined more than once\n"
2511                         if grep { $v eq $_ } @{$config{defines}};
2512                     push @{$config{defines}}, $v;
2513                 }
2514             }
2515         }
2516
2517         foreach my $section (keys %imagedocs) {
2518             foreach (@{$imagedocs{$section}}) {
2519                 my $imagedocs = cleanfile($buildd, $_, $blddir);
2520                 $unified_info{imagedocs}->{$section}->{$imagedocs} = 1;
2521             }
2522         }
2523
2524         foreach my $section (keys %htmldocs) {
2525             foreach (@{$htmldocs{$section}}) {
2526                 my $htmldocs = cleanfile($buildd, $_, $blddir);
2527                 $unified_info{htmldocs}->{$section}->{$htmldocs} = 1;
2528             }
2529         }
2530
2531         foreach my $section (keys %mandocs) {
2532             foreach (@{$mandocs{$section}}) {
2533                 my $mandocs = cleanfile($buildd, $_, $blddir);
2534                 $unified_info{mandocs}->{$section}->{$mandocs} = 1;
2535             }
2536         }
2537     }
2538
2539     my $ordinals_text = join(', ', sort keys %ordinals);
2540     warn <<"EOF" if $ordinals_text;
2541
2542 WARNING: ORDINALS were specified for $ordinals_text
2543 They are ignored and should be replaced with a combination of GENERATE,
2544 DEPEND and SHARED_SOURCE.
2545 EOF
2546
2547     # Check that each generated file is only generated once
2548     my $ambiguous_generation = 0;
2549     foreach (sort keys %check_generate) {
2550         my @generators = sort keys %{$check_generate{$_}};
2551         my $generators_txt = join(', ', @generators);
2552         if (scalar @generators > 1) {
2553             warn "$_ is GENERATEd by more than one generator ($generators_txt)\n";
2554             $ambiguous_generation++;
2555         }
2556         if ($check_generate{$_}->{$generators[0]} > 1) {
2557             warn "INFO: $_ has more than one GENERATE declaration (same generator)\n"
2558         }
2559     }
2560     die "There are ambiguous source file generations\n"
2561         if $ambiguous_generation > 0;
2562
2563     # All given source files should exist, or if generated, their
2564     # generator should exist.  This loop ensures this is true.
2565     my $missing = 0;
2566     foreach my $orig (sort keys %check_exist) {
2567         foreach my $dest (@{$check_exist{$orig}}) {
2568             if ($orig ne $src_configdata) {
2569                 if ($orig =~ /\.a$/) {
2570                     # Static library names may be used as sources, so we
2571                     # need to detect those and give them special treatment.
2572                     unless (grep { $_ eq $orig }
2573                             keys %{$unified_info{libraries}}) {
2574                         warn "$orig is given as source for $dest, but no such library is built\n";
2575                         $missing++;
2576                     }
2577                 } else {
2578                     # A source may be generated, and its generator may be
2579                     # generated as well.  We therefore loop to dig out the
2580                     # first generator.
2581                     my $gen = $orig;
2582
2583                     while (my @next = keys %{$check_generate{$gen}}) {
2584                         $gen = $next[0];
2585                     }
2586
2587                     if (! -f $gen) {
2588                         if ($gen ne $orig) {
2589                             $missing++;
2590                             warn "$orig is given as source for $dest, but its generator (leading to $gen) is missing\n";
2591                         } else {
2592                             $missing++;
2593                             warn "$orig is given as source for $dest, but is missing\n";
2594                         }
2595                     }
2596                 }
2597             }
2598         }
2599     }
2600     die "There are files missing\n" if $missing > 0;
2601
2602     # Go through the sources of all libraries and check that the same basename
2603     # doesn't appear more than once.  Some static library archivers depend on
2604     # them being unique.
2605     {
2606         my $err = 0;
2607         foreach my $prod (keys %{$unified_info{libraries}}) {
2608             my @prod_sources =
2609                 map { keys %{$unified_info{sources}->{$_}} }
2610                 keys %{$unified_info{sources}->{$prod}};
2611             my %srccnt = ();
2612
2613             # Count how many times a given each source basename
2614             # appears for each product.
2615             foreach my $src (@prod_sources) {
2616                 $srccnt{basename $src}++;
2617             }
2618
2619             foreach my $src (keys %srccnt) {
2620                 if ((my $cnt = $srccnt{$src}) > 1) {
2621                     print STDERR "$src appears $cnt times for the product $prod\n";
2622                     $err++
2623                 }
2624             }
2625         }
2626         die if $err > 0;
2627     }
2628
2629     # Massage the result
2630
2631     # If we depend on a header file or a perl module, add an inclusion of
2632     # its directory to allow smoothe inclusion
2633     foreach my $dest (keys %{$unified_info{depends}}) {
2634         next if $dest eq "";
2635         foreach my $d (keys %{$unified_info{depends}->{$dest}}) {
2636             next unless $d =~ /\.(h|pm)$/;
2637             my $i = dirname($d);
2638             my $spot =
2639                 $d eq "configdata.pm" || defined($unified_info{generate}->{$d})
2640                 ? 'build' : 'source';
2641             push @{$unified_info{includes}->{$dest}->{$spot}}, $i
2642                 unless grep { $_ eq $i } @{$unified_info{includes}->{$dest}->{$spot}};
2643         }
2644     }
2645
2646     # Go through all intermediary files and change their names to something that
2647     # reflects what they will be built for.  Note that for some source files,
2648     # this leads to duplicate object files because they are used multiple times.
2649     # the goal is to rename all object files according to this scheme:
2650     #    {productname}-{midfix}-{origobjname}.[o|res]
2651     # the {midfix} is a keyword indicating the type of product, which is mostly
2652     # valuable for libraries since they come in two forms.
2653     #
2654     # This also reorganises the {sources} and {shared_sources} so that the
2655     # former only contains ALL object files that are supposed to end up in
2656     # static libraries and programs, while the latter contains ALL object files
2657     # that are supposed to end up in shared libraries and DSOs.
2658     # The main reason for having two different source structures is to allow
2659     # the same name to be used for the static and the shared variants of a
2660     # library.
2661     {
2662         # Take copies so we don't get interference from added stuff
2663         my %unified_copy = ();
2664         foreach (('sources', 'shared_sources')) {
2665             $unified_copy{$_} = { %{$unified_info{$_}} }
2666                 if defined($unified_info{$_});
2667             delete $unified_info{$_};
2668         }
2669         foreach my $prodtype (('programs', 'libraries', 'modules', 'scripts')) {
2670             # $intent serves multi purposes:
2671             # - give a prefix for the new object files names
2672             # - in the case of libraries, rearrange the object files so static
2673             #   libraries use the 'sources' structure exclusively, while shared
2674             #   libraries use the 'shared_sources' structure exclusively.
2675             my $intent = {
2676                 programs  => { bin    => { src => [ 'sources' ],
2677                                            dst => 'sources' } },
2678                 libraries => { lib    => { src => [ 'sources' ],
2679                                            dst => 'sources' },
2680                                shlib  => { prodselect =>
2681                                                sub { grep !/\.a$/, @_ },
2682                                            src => [ 'sources',
2683                                                     'shared_sources' ],
2684                                            dst => 'shared_sources' } },
2685                 modules   => { dso    => { src => [ 'sources' ],
2686                                            dst => 'sources' } },
2687                 scripts   => { script => { src => [ 'sources' ],
2688                                            dst => 'sources' } }
2689                } -> {$prodtype};
2690             foreach my $kind (keys %$intent) {
2691                 next if ($intent->{$kind}->{dst} eq 'shared_sources'
2692                              && $disabled{shared});
2693
2694                 my @src = @{$intent->{$kind}->{src}};
2695                 my $dst = $intent->{$kind}->{dst};
2696                 my $prodselect = $intent->{$kind}->{prodselect} // sub { @_ };
2697                 foreach my $prod ($prodselect->(keys %{$unified_info{$prodtype}})) {
2698                     # %prod_sources has all applicable objects as keys, and
2699                     # their corresponding sources as values
2700                     my %prod_sources =
2701                         map { $_ => [ keys %{$unified_copy{sources}->{$_}} ] }
2702                         map { keys %{$unified_copy{$_}->{$prod}} }
2703                         @src;
2704                     foreach (keys %prod_sources) {
2705                         # Only affect object files and resource files,
2706                         # the others simply get a new value
2707                         # (+1 instead of -1)
2708                         if ($_ =~ /\.(o|res)$/) {
2709                             (my $prodname = $prod) =~ s|\.a$||;
2710                             my $newobj =
2711                                 catfile(dirname($_),
2712                                         basename($prodname)
2713                                             . '-' . $kind
2714                                             . '-' . basename($_));
2715                             $unified_info{$dst}->{$prod}->{$newobj} = 1;
2716                             foreach my $src (@{$prod_sources{$_}}) {
2717                                 $unified_info{sources}->{$newobj}->{$src} = 1;
2718                                 # Adjust source attributes
2719                                 my $attrs = $unified_info{attributes}->{sources};
2720                                 if (defined $attrs->{$prod}
2721                                     && defined $attrs->{$prod}->{$_}) {
2722                                     $attrs->{$prod}->{$newobj} =
2723                                         $attrs->{$prod}->{$_};
2724                                     delete $attrs->{$prod}->{$_};
2725                                 }
2726                                 foreach my $objsrc (keys %{$attrs->{$_} // {}}) {
2727                                     $attrs->{$newobj}->{$objsrc} =
2728                                         $attrs->{$_}->{$objsrc};
2729                                     delete $attrs->{$_}->{$objsrc};
2730                                 }
2731                             }
2732                             # Adjust dependencies
2733                             foreach my $deps (keys %{$unified_info{depends}->{$_}}) {
2734                                 $unified_info{depends}->{$_}->{$deps} = -1;
2735                                 $unified_info{depends}->{$newobj}->{$deps} = 1;
2736                             }
2737                             # Adjust includes
2738                             foreach my $k (('source', 'build')) {
2739                                 next unless
2740                                     defined($unified_info{includes}->{$_}->{$k});
2741                                 my @incs = @{$unified_info{includes}->{$_}->{$k}};
2742                                 $unified_info{includes}->{$newobj}->{$k} = [ @incs ];
2743                             }
2744                         } else {
2745                             $unified_info{$dst}->{$prod}->{$_} = 1;
2746                         }
2747                     }
2748                 }
2749             }
2750         }
2751     }
2752
2753     # At this point, we have a number of sources with the value -1.  They
2754     # aren't part of the local build and are probably meant for a different
2755     # platform, and can therefore be cleaned away.  That happens when making
2756     # %unified_info more efficient below.
2757
2758     ### Make unified_info a bit more efficient
2759     # One level structures
2760     foreach (("programs", "libraries", "modules", "scripts", "targets")) {
2761         $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
2762     }
2763     # Two level structures
2764     foreach my $l1 (("sources", "shared_sources", "ldadd", "depends",
2765                      "imagedocs", "htmldocs", "mandocs")) {
2766         foreach my $l2 (sort keys %{$unified_info{$l1}}) {
2767             my @items =
2768                 sort
2769                 grep { $unified_info{$l1}->{$l2}->{$_} > 0 }
2770                 keys %{$unified_info{$l1}->{$l2}};
2771             if (@items) {
2772                 $unified_info{$l1}->{$l2} = [ @items ];
2773             } else {
2774                 delete $unified_info{$l1}->{$l2};
2775             }
2776         }
2777     }
2778     # Defines
2779     foreach my $dest (sort keys %{$unified_info{defines}}) {
2780         $unified_info{defines}->{$dest}
2781             = [ map { $_.$unified_info{defines}->{$dest}->{$_} }
2782                 sort keys %{$unified_info{defines}->{$dest}} ];
2783     }
2784     # Includes
2785     foreach my $dest (sort keys %{$unified_info{includes}}) {
2786         if (defined($unified_info{includes}->{$dest}->{build})) {
2787             my @source_includes = ();
2788             @source_includes = ( @{$unified_info{includes}->{$dest}->{source}} )
2789                 if defined($unified_info{includes}->{$dest}->{source});
2790             $unified_info{includes}->{$dest} =
2791                 [ @{$unified_info{includes}->{$dest}->{build}} ];
2792             foreach my $inc (@source_includes) {
2793                 push @{$unified_info{includes}->{$dest}}, $inc
2794                     unless grep { $_ eq $inc } @{$unified_info{includes}->{$dest}};
2795             }
2796         } elsif (defined($unified_info{includes}->{$dest}->{source})) {
2797             $unified_info{includes}->{$dest} =
2798                 [ @{$unified_info{includes}->{$dest}->{source}} ];
2799         } else {
2800             delete $unified_info{includes}->{$dest};
2801         }
2802     }
2803
2804     # For convenience collect information regarding directories where
2805     # files are generated, those generated files and the end product
2806     # they end up in where applicable.  Then, add build rules for those
2807     # directories
2808     my %loopinfo = ( "lib" => [ @{$unified_info{libraries}} ],
2809                      "dso" => [ @{$unified_info{modules}} ],
2810                      "bin" => [ @{$unified_info{programs}} ],
2811                      "script" => [ @{$unified_info{scripts}} ],
2812                      "docs" => [ (map { @{$unified_info{imagedocs}->{$_} // []} }
2813                                   keys %{$unified_info{imagedocs} // {}}),
2814                                  (map { @{$unified_info{htmldocs}->{$_} // []} }
2815                                   keys %{$unified_info{htmldocs} // {}}),
2816                                  (map { @{$unified_info{mandocs}->{$_} // []} }
2817                                   keys %{$unified_info{mandocs} // {}}) ] );
2818     foreach my $type (sort keys %loopinfo) {
2819         foreach my $product (@{$loopinfo{$type}}) {
2820             my %dirs = ();
2821             my $pd = dirname($product);
2822
2823             foreach (@{$unified_info{sources}->{$product} // []},
2824                      @{$unified_info{shared_sources}->{$product} // []}) {
2825                 my $d = dirname($_);
2826
2827                 # We don't want to create targets for source directories
2828                 # when building out of source
2829                 next if ($config{sourcedir} ne $config{builddir}
2830                              && $d =~ m|^\Q$config{sourcedir}\E|);
2831                 # We already have a "test" target, and the current directory
2832                 # is just silly to make a target for
2833                 next if $d eq "test" || $d eq ".";
2834
2835                 $dirs{$d} = 1;
2836                 push @{$unified_info{dirinfo}->{$d}->{deps}}, $_
2837                     if $d ne $pd;
2838             }
2839             foreach (sort keys %dirs) {
2840                 push @{$unified_info{dirinfo}->{$_}->{products}->{$type}},
2841                     $product;
2842             }
2843         }
2844     }
2845 }
2846
2847 # For the schemes that need it, we provide the old *_obj configs
2848 # from the *_asm_obj ones
2849 foreach (grep /_(asm|aux)_src$/, keys %target) {
2850     my $src = $_;
2851     (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
2852     $target{$obj} = $target{$src};
2853     $target{$obj} =~ s/\.[csS]\b/.o/g; # C and assembler
2854     $target{$obj} =~ s/\.(cc|cpp)\b/_cc.o/g; # C++
2855 }
2856
2857 # Write down our configuration where it fits #########################
2858
2859 my %template_vars = (
2860     config => \%config,
2861     target => \%target,
2862     disablables => \@disablables,
2863     disablables_int => \@disablables_int,
2864     disabled => \%disabled,
2865     withargs => \%withargs,
2866     unified_info => \%unified_info,
2867     tls => \@tls,
2868     dtls => \@dtls,
2869     makevars => [ sort keys %user ],
2870     disabled_info => \%disabled_info,
2871     user_crossable => \@user_crossable,
2872 );
2873 my $configdata_outname = 'configdata.pm';
2874 open CONFIGDATA, ">$configdata_outname.new"
2875     or die "Trying to create $configdata_outname.new: $!";
2876 my $configdata_tmplname = cleanfile($srcdir, "configdata.pm.in", $blddir);
2877 my $configdata_tmpl =
2878     OpenSSL::Template->new(TYPE => 'FILE', SOURCE => $configdata_tmplname);
2879 $configdata_tmpl->fill_in(
2880     FILENAME => $configdata_tmplname,
2881     OUTPUT => \*CONFIGDATA,
2882     HASH => { %template_vars,
2883               autowarntext => [
2884                   'WARNING: do not edit!',
2885                   "Generated by Configure from $configdata_tmplname",
2886               ] }
2887 ) or die $Text::Template::ERROR;
2888 close CONFIGDATA;
2889
2890 rename "$configdata_outname.new", $configdata_outname;
2891 if ($builder_platform eq 'unix') {
2892     my $mode = (0755 & ~umask);
2893     chmod $mode, 'configdata.pm'
2894         or warn sprintf("WARNING: Couldn't change mode for 'configdata.pm' to 0%03o: %s\n",$mode,$!);
2895 }
2896 print "Created $configdata_outname\n";
2897
2898 print "Running $configdata_outname\n";
2899 my $perlcmd = (quotify("maybeshell", $config{PERL}))[0];
2900 my $cmd = "$perlcmd $configdata_outname";
2901 #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
2902 system($cmd);
2903 exit 1 if $? != 0;
2904
2905 $SIG{__DIE__} = $orig_death_handler;
2906
2907 print <<"EOF" if ($disabled{threads} eq "unavailable");
2908
2909 The library could not be configured for supporting multi-threaded
2910 applications as the compiler options required on this system are not known.
2911 See file INSTALL.md for details if you need multi-threading.
2912 EOF
2913
2914 print <<"EOF" if ($no_shared_warn);
2915
2916 The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
2917 platform, so we will pretend you gave the option 'no-pic', which also disables
2918 'shared' and 'dynamic-engine'.  If you know how to implement shared libraries
2919 or position independent code, please let us know (but please first make sure
2920 you have tried with a current version of OpenSSL).
2921 EOF
2922
2923 print $banner;
2924
2925 exit(0);
2926
2927 ######################################################################
2928 #
2929 # Helpers and utility functions
2930 #
2931
2932 # Death handler, to print a helpful message in case of failure #######
2933 #
2934 sub death_handler {
2935     die @_ if $^S;              # To prevent the added message in eval blocks
2936     my $build_file = $config{build_file} // "build file";
2937     my @message = ( <<"_____", @_ );
2938
2939 Failure!  $build_file wasn't produced.
2940 Please read INSTALL.md and associated NOTES-* files.  You may also have to
2941 look over your available compiler tool chain or change your configuration.
2942
2943 _____
2944
2945     # Dying is terminal, so it's ok to reset the signal handler here.
2946     $SIG{__DIE__} = $orig_death_handler;
2947     die @message;
2948 }
2949
2950 # Configuration file reading #########################################
2951
2952 # Note: All of the helper functions are for lazy evaluation.  They all
2953 # return a CODE ref, which will return the intended value when evaluated.
2954 # Thus, whenever there's mention of a returned value, it's about that
2955 # intended value.
2956
2957 # Helper function to implement conditional value variants, with a default
2958 # plus additional values based on the value of $config{build_type}.
2959 # Arguments are given in hash table form:
2960 #
2961 #       picker(default => "Basic string: ",
2962 #              debug   => "debug",
2963 #              release => "release")
2964 #
2965 # When configuring with --debug, the resulting string will be
2966 # "Basic string: debug", and when not, it will be "Basic string: release"
2967 #
2968 # This can be used to create variants of sets of flags according to the
2969 # build type:
2970 #
2971 #       cflags => picker(default => "-Wall",
2972 #                        debug   => "-g -O0",
2973 #                        release => "-O3")
2974 #
2975 sub picker {
2976     my %opts = @_;
2977     return sub { add($opts{default} || (),
2978                      $opts{$config{build_type}} || ())->(); }
2979 }
2980
2981 # Helper function to combine several values of different types into one.
2982 # This is useful if you want to combine a string with the result of a
2983 # lazy function, such as:
2984 #
2985 #       cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
2986 #
2987 sub combine {
2988     my @stuff = @_;
2989     return sub { add(@stuff)->(); }
2990 }
2991
2992 # Helper function to implement conditional values depending on the value
2993 # of $disabled{threads}.  Can be used as follows:
2994 #
2995 #       cflags => combine("-Wall", threads("-pthread"))
2996 #
2997 sub threads {
2998     my @flags = @_;
2999     return sub { add($disabled{threads} ? () : @flags)->(); }
3000 }
3001
3002 sub shared {
3003     my @flags = @_;
3004     return sub { add($disabled{shared} ? () : @flags)->(); }
3005 }
3006
3007 our $add_called = 0;
3008 # Helper function to implement adding values to already existing configuration
3009 # values.  It handles elements that are ARRAYs, CODEs and scalars
3010 sub _add {
3011     my $separator = shift;
3012
3013     # If there's any ARRAY in the collection of values OR the separator
3014     # is undef, we will return an ARRAY of combined values, otherwise a
3015     # string of joined values with $separator as the separator.
3016     my $found_array = !defined($separator);
3017
3018     my @values =
3019         map {
3020             my $res = $_;
3021             while (ref($res) eq "CODE") {
3022                 $res = $res->();
3023             }
3024             if (defined($res)) {
3025                 if (ref($res) eq "ARRAY") {
3026                     $found_array = 1;
3027                     @$res;
3028                 } else {
3029                     $res;
3030                 }
3031             } else {
3032                 ();
3033             }
3034     } (@_);
3035
3036     $add_called = 1;
3037
3038     if ($found_array) {
3039         [ @values ];
3040     } else {
3041         join($separator, grep { defined($_) && $_ ne "" } @values);
3042     }
3043 }
3044 sub add_before {
3045     my $separator = " ";
3046     if (ref($_[$#_]) eq "HASH") {
3047         my $opts = pop;
3048         $separator = $opts->{separator};
3049     }
3050     my @x = @_;
3051     sub { _add($separator, @x, @_) };
3052 }
3053 sub add {
3054     my $separator = " ";
3055     if (ref($_[$#_]) eq "HASH") {
3056         my $opts = pop;
3057         $separator = $opts->{separator};
3058     }
3059     my @x = @_;
3060     sub { _add($separator, @_, @x) };
3061 }
3062
3063 sub read_eval_file {
3064     my $fname = shift;
3065     my $content;
3066     my @result;
3067
3068     open F, "< $fname" or die "Can't open '$fname': $!\n";
3069     {
3070         undef local $/;
3071         $content = <F>;
3072     }
3073     close F;
3074     {
3075         local $@;
3076
3077         @result = ( eval $content );
3078         warn $@ if $@;
3079     }
3080     return wantarray ? @result : $result[0];
3081 }
3082
3083 # configuration reader, evaluates the input file as a perl script and expects
3084 # it to fill %targets with target configurations.  Those are then added to
3085 # %table.
3086 sub read_config {
3087     my $fname = shift;
3088     my %targets;
3089
3090     {
3091         # Protect certain tables from tampering
3092         local %table = ();
3093
3094         %targets = read_eval_file($fname);
3095     }
3096     my %preexisting = ();
3097     foreach (sort keys %targets) {
3098         $preexisting{$_} = 1 if $table{$_};
3099     }
3100     die <<"EOF",
3101 The following config targets from $fname
3102 shadow pre-existing config targets with the same name:
3103 EOF
3104         map { "  $_\n" } sort keys %preexisting
3105         if %preexisting;
3106
3107
3108     # For each target, check that it's configured with a hash table.
3109     foreach (keys %targets) {
3110         if (ref($targets{$_}) ne "HASH") {
3111             if (ref($targets{$_}) eq "") {
3112                 warn "Deprecated target configuration for $_, ignoring...\n";
3113             } else {
3114                 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
3115             }
3116             delete $targets{$_};
3117         } else {
3118             $targets{$_}->{_conf_fname_int} = add([ $fname ]);
3119         }
3120     }
3121
3122     %table = (%table, %targets);
3123
3124 }
3125
3126 # configuration resolver.  Will only resolve all the lazy evaluation
3127 # codeblocks for the chosen target and all those it inherits from,
3128 # recursively
3129 sub resolve_config {
3130     my $target = shift;
3131     my @breadcrumbs = @_;
3132
3133 #    my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
3134
3135     if (grep { $_ eq $target } @breadcrumbs) {
3136         die "inherit_from loop!  target backtrace:\n  "
3137             ,$target,"\n  ",join("\n  ", @breadcrumbs),"\n";
3138     }
3139
3140     if (!defined($table{$target})) {
3141         warn "Warning! target $target doesn't exist!\n";
3142         return ();
3143     }
3144     # Recurse through all inheritances.  They will be resolved on the
3145     # fly, so when this operation is done, they will all just be a
3146     # bunch of attributes with string values.
3147     # What we get here, though, are keys with references to lists of
3148     # the combined values of them all.  We will deal with lists after
3149     # this stage is done.
3150     my %combined_inheritance = ();
3151     if ($table{$target}->{inherit_from}) {
3152         my @inherit_from =
3153             map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
3154         foreach (@inherit_from) {
3155             my %inherited_config = resolve_config($_, $target, @breadcrumbs);
3156
3157             # 'template' is a marker that's considered private to
3158             # the config that had it.
3159             delete $inherited_config{template};
3160
3161             foreach (keys %inherited_config) {
3162                 if (!$combined_inheritance{$_}) {
3163                     $combined_inheritance{$_} = [];
3164                 }
3165                 push @{$combined_inheritance{$_}}, $inherited_config{$_};
3166             }
3167         }
3168     }
3169
3170     # We won't need inherit_from in this target any more, since we've
3171     # resolved all the inheritances that lead to this
3172     delete $table{$target}->{inherit_from};
3173
3174     # Now is the time to deal with those lists.  Here's the place to
3175     # decide what shall be done with those lists, all based on the
3176     # values of the target we're currently dealing with.
3177     # - If a value is a coderef, it will be executed with the list of
3178     #   inherited values as arguments.
3179     # - If the corresponding key doesn't have a value at all or is the
3180     #   empty string, the inherited value list will be run through the
3181     #   default combiner (below), and the result becomes this target's
3182     #   value.
3183     # - Otherwise, this target's value is assumed to be a string that
3184     #   will simply override the inherited list of values.
3185     my $default_combiner = add();
3186
3187     my %all_keys =
3188         map { $_ => 1 } (keys %combined_inheritance,
3189                          keys %{$table{$target}});
3190
3191     sub process_values {
3192         my $object    = shift;
3193         my $inherited = shift;  # Always a [ list ]
3194         my $target    = shift;
3195         my $entry     = shift;
3196
3197         $add_called = 0;
3198
3199         while(ref($object) eq "CODE") {
3200             $object = $object->(@$inherited);
3201         }
3202         if (!defined($object)) {
3203             return ();
3204         }
3205         elsif (ref($object) eq "ARRAY") {
3206             local $add_called;  # To make sure recursive calls don't affect it
3207             return [ map { process_values($_, $inherited, $target, $entry) }
3208                      @$object ];
3209         } elsif (ref($object) eq "") {
3210             return $object;
3211         } else {
3212             die "cannot handle reference type ",ref($object)
3213                 ," found in target ",$target," -> ",$entry,"\n";
3214         }
3215     }
3216
3217     foreach my $key (sort keys %all_keys) {
3218         my $previous = $combined_inheritance{$key};
3219
3220         # Current target doesn't have a value for the current key?
3221         # Assign it the default combiner, the rest of this loop body
3222         # will handle it just like any other coderef.
3223         if (!exists $table{$target}->{$key}) {
3224             $table{$target}->{$key} = $default_combiner;
3225         }
3226
3227         $table{$target}->{$key} = process_values($table{$target}->{$key},
3228                                                $combined_inheritance{$key},
3229                                                $target, $key);
3230         unless(defined($table{$target}->{$key})) {
3231             delete $table{$target}->{$key};
3232         }
3233 #        if ($extra_checks &&
3234 #            $previous && !($add_called ||  $previous ~~ $table{$target}->{$key})) {
3235 #            warn "$key got replaced in $target\n";
3236 #        }
3237     }
3238
3239     # Finally done, return the result.
3240     return %{$table{$target}};
3241 }
3242
3243 sub usage
3244         {
3245         print STDERR $usage;
3246         print STDERR "\npick os/compiler from:\n";
3247         my $j=0;
3248         my $i;
3249         my $k=0;
3250         foreach $i (sort keys %table)
3251                 {
3252                 next if $table{$i}->{template};
3253                 next if $i =~ /^debug/;
3254                 $k += length($i) + 1;
3255                 if ($k > 78)
3256                         {
3257                         print STDERR "\n";
3258                         $k=length($i);
3259                         }
3260                 print STDERR $i . " ";
3261                 }
3262         foreach $i (sort keys %table)
3263                 {
3264                 next if $table{$i}->{template};
3265                 next if $i !~ /^debug/;
3266                 $k += length($i) + 1;
3267                 if ($k > 78)
3268                         {
3269                         print STDERR "\n";
3270                         $k=length($i);
3271                         }
3272                 print STDERR $i . " ";
3273                 }
3274         exit(1);
3275         }
3276
3277 sub compiler_predefined {
3278     state %predefined;
3279     my $cc = shift;
3280
3281     return () if $^O eq 'VMS';
3282
3283     die 'compiler_predefined called without a compiler command'
3284         unless $cc;
3285
3286     if (! $predefined{$cc}) {
3287
3288         $predefined{$cc} = {};
3289
3290         # collect compiler pre-defines from gcc or gcc-alike...
3291         open(PIPE, "$cc -dM -E -x c /dev/null 2>&1 |");
3292         while (my $l = <PIPE>) {
3293             $l =~ m/^#define\s+(\w+(?:\(\w+\))?)(?:\s+(.+))?/ or last;
3294             $predefined{$cc}->{$1} = $2 // '';
3295         }
3296         close(PIPE);
3297     }
3298
3299     return %{$predefined{$cc}};
3300 }
3301
3302 sub which
3303 {
3304     my ($name)=@_;
3305
3306     if (eval { require IPC::Cmd; 1; }) {
3307         IPC::Cmd->import();
3308         return scalar IPC::Cmd::can_run($name);
3309     } else {
3310         # if there is $directories component in splitpath,
3311         # then it's not something to test with $PATH...
3312         return $name if (File::Spec->splitpath($name))[1];
3313
3314         foreach (File::Spec->path()) {
3315             my $fullpath = catfile($_, "$name$target{exe_extension}");
3316             if (-f $fullpath and -x $fullpath) {
3317                 return $fullpath;
3318             }
3319         }
3320     }
3321 }
3322
3323 sub env
3324 {
3325     my $name = shift;
3326     my %opts = @_;
3327
3328     unless ($opts{cacheonly}) {
3329         # Note that if $ENV{$name} doesn't exist or is undefined,
3330         # $config{perlenv}->{$name} will be created with the value
3331         # undef.  This is intentional.
3332
3333         $config{perlenv}->{$name} = $ENV{$name}
3334             if ! exists $config{perlenv}->{$name};
3335     }
3336     return $config{perlenv}->{$name};
3337 }
3338
3339 # Configuration printer ##############################################
3340
3341 sub print_table_entry
3342 {
3343     local $now_printing = shift;
3344     my %target = resolve_config($now_printing);
3345     my $type = shift;
3346
3347     # Don't print the templates
3348     return if $target{template};
3349
3350     my @sequence = (
3351         "sys_id",
3352         "cpp",
3353         "cppflags",
3354         "defines",
3355         "includes",
3356         "cc",
3357         "cflags",
3358         "ld",
3359         "lflags",
3360         "loutflag",
3361         "ex_libs",
3362         "bn_ops",
3363         "enable",
3364         "disable",
3365         "poly1035_asm_src",
3366         "thread_scheme",
3367         "perlasm_scheme",
3368         "dso_scheme",
3369         "shared_target",
3370         "shared_cflag",
3371         "shared_defines",
3372         "shared_ldflag",
3373         "shared_rcflag",
3374         "shared_extension",
3375         "dso_extension",
3376         "obj_extension",
3377         "exe_extension",
3378         "ranlib",
3379         "ar",
3380         "arflags",
3381         "aroutflag",
3382         "rc",
3383         "rcflags",
3384         "rcoutflag",
3385         "mt",
3386         "mtflags",
3387         "mtinflag",
3388         "mtoutflag",
3389         "multilib",
3390         "build_scheme",
3391         );
3392
3393     if ($type eq "TABLE") {
3394         print "\n";
3395         print "*** $now_printing\n";
3396         foreach (@sequence) {
3397             if (ref($target{$_}) eq "ARRAY") {
3398                 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
3399             } else {
3400                 printf "\$%-12s = %s\n", $_, $target{$_};
3401             }
3402         }
3403     } elsif ($type eq "HASH") {
3404         my $largest =
3405             length((sort { length($a) <=> length($b) } @sequence)[-1]);
3406         print "    '$now_printing' => {\n";
3407         foreach (@sequence) {
3408             if ($target{$_}) {
3409                 if (ref($target{$_}) eq "ARRAY") {
3410                     print "      '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
3411                 } else {
3412                     print "      '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
3413                 }
3414             }
3415         }
3416         print "    },\n";
3417     }
3418 }
3419
3420 # Utility routines ###################################################
3421
3422 # On VMS, if the given file is a logical name, File::Spec::Functions
3423 # will consider it an absolute path.  There are cases when we want a
3424 # purely syntactic check without checking the environment.
3425 sub isabsolute {
3426     my $file = shift;
3427
3428     # On non-platforms, we just use file_name_is_absolute().
3429     return file_name_is_absolute($file) unless $^O eq "VMS";
3430
3431     # If the file spec includes a device or a directory spec,
3432     # file_name_is_absolute() is perfectly safe.
3433     return file_name_is_absolute($file) if $file =~ m|[:\[]|;
3434
3435     # Here, we know the given file spec isn't absolute
3436     return 0;
3437 }
3438
3439 # Makes a directory absolute and cleans out /../ in paths like foo/../bar
3440 # On some platforms, this uses rel2abs(), while on others, realpath() is used.
3441 # realpath() requires that at least all path components except the last is an
3442 # existing directory.  On VMS, the last component of the directory spec must
3443 # exist.
3444 sub absolutedir {
3445     my $dir = shift;
3446
3447     # realpath() is quite buggy on VMS.  It uses LIB$FID_TO_NAME, which
3448     # will return the volume name for the device, no matter what.  Also,
3449     # it will return an incorrect directory spec if the argument is a
3450     # directory that doesn't exist.
3451     if ($^O eq "VMS") {
3452         return rel2abs($dir);
3453     }
3454
3455     # We use realpath() on Unix, since no other will properly clean out
3456     # a directory spec.
3457     use Cwd qw/realpath/;
3458
3459     return realpath($dir);
3460 }
3461
3462 # Check if all paths are one and the same, using stat.  They must both exist
3463 # We need this for the cases when File::Spec doesn't detect case insensitivity
3464 # (File::Spec::Unix assumes case sensitivity)
3465 sub samedir {
3466     die "samedir expects two arguments\n" unless scalar @_ == 2;
3467
3468     my @stat0 = stat($_[0]);    # First argument
3469     my @stat1 = stat($_[1]);    # Second argument
3470
3471     die "Couldn't stat $_[0]" unless @stat0;
3472     die "Couldn't stat $_[1]" unless @stat1;
3473
3474     # Compare device number
3475     return 0 unless ($stat0[0] == $stat1[0]);
3476     # Compare "inode".  The perl manual recommends comparing as
3477     # string rather than as number.
3478     return 0 unless ($stat0[1] eq $stat1[1]);
3479
3480     return 1;                   # All the same
3481 }
3482
3483 sub quotify {
3484     my %processors = (
3485         perl    => sub { my $x = shift;
3486                          $x =~ s/([\\\$\@"])/\\$1/g;
3487                          return '"'.$x.'"'; },
3488         maybeshell => sub { my $x = shift;
3489                             (my $y = $x) =~ s/([\\\"])/\\$1/g;
3490                             if ($x ne $y || $x =~ m|\s|) {
3491                                 return '"'.$y.'"';
3492                             } else {
3493                                 return $x;
3494                             }
3495                         },
3496         );
3497     my $for = shift;
3498     my $processor =
3499         defined($processors{$for}) ? $processors{$for} : sub { shift; };
3500
3501     return map { $processor->($_); } @_;
3502 }
3503
3504 # collect_from_file($filename, $line_concat_cond_re, $line_concat)
3505 # $filename is a file name to read from
3506 # $line_concat_cond_re is a regexp detecting a line continuation ending
3507 # $line_concat is a CODEref that takes care of concatenating two lines
3508 sub collect_from_file {
3509     my $filename = shift;
3510     my $line_concat_cond_re = shift;
3511     my $line_concat = shift;
3512
3513     open my $fh, $filename || die "unable to read $filename: $!\n";
3514     return sub {
3515         my $saved_line = "";
3516         $_ = "";
3517         while (<$fh>) {
3518             s|\R$||;
3519             if (defined $line_concat) {
3520                 $_ = $line_concat->($saved_line, $_);
3521                 $saved_line = "";
3522             }
3523             if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
3524                 $saved_line = $_;
3525                 next;
3526             }
3527             return $_;
3528         }
3529         die "$filename ending with continuation line\n" if $_;
3530         close $fh;
3531         return undef;
3532     }
3533 }
3534
3535 # collect_from_array($array, $line_concat_cond_re, $line_concat)
3536 # $array is an ARRAYref of lines
3537 # $line_concat_cond_re is a regexp detecting a line continuation ending
3538 # $line_concat is a CODEref that takes care of concatenating two lines
3539 sub collect_from_array {
3540     my $array = shift;
3541     my $line_concat_cond_re = shift;
3542     my $line_concat = shift;
3543     my @array = (@$array);
3544
3545     return sub {
3546         my $saved_line = "";
3547         $_ = "";
3548         while (defined($_ = shift @array)) {
3549             s|\R$||;
3550             if (defined $line_concat) {
3551                 $_ = $line_concat->($saved_line, $_);
3552                 $saved_line = "";
3553             }
3554             if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
3555                 $saved_line = $_;
3556                 next;
3557             }
3558             return $_;
3559         }
3560         die "input text ending with continuation line\n" if $_;
3561         return undef;
3562     }
3563 }
3564
3565 # collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
3566 # $lineiterator is a CODEref that delivers one line at a time.
3567 # All following arguments are regex/CODEref pairs, where the regexp detects a
3568 # line and the CODEref does something with the result of the regexp.
3569 sub collect_information {
3570     my $lineiterator = shift;
3571     my %collectors = @_;
3572
3573     while(defined($_ = $lineiterator->())) {
3574         s|\R$||;
3575         my $found = 0;
3576         if ($collectors{"BEFORE"}) {
3577             $collectors{"BEFORE"}->($_);
3578         }
3579         foreach my $re (keys %collectors) {
3580             if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
3581                 $collectors{$re}->($lineiterator);
3582                 $found = 1;
3583             };
3584         }
3585         if ($collectors{"OTHERWISE"}) {
3586             $collectors{"OTHERWISE"}->($lineiterator, $_)
3587                 unless $found || !defined $collectors{"OTHERWISE"};
3588         }
3589         if ($collectors{"AFTER"}) {
3590             $collectors{"AFTER"}->($_);
3591         }
3592     }
3593 }
3594
3595 # tokenize($line)
3596 # tokenize($line,$separator)
3597 # $line is a line of text to split up into tokens
3598 # $separator [optional] is a regular expression that separates the tokens,
3599 # the default being spaces.  Do not use quotes of any kind as separators,
3600 # that will give undefined results.
3601 # Returns a list of tokens.
3602 #
3603 # Tokens are divided by separator (spaces by default).  If the tokens include
3604 # the separators, they have to be quoted with single or double quotes.
3605 # Double quotes inside a double quoted token must be escaped.  Escaping is done
3606 # with backslash.
3607 # Basically, the same quoting rules apply for " and ' as in any
3608 # Unix shell.
3609 sub tokenize {
3610     my $line = my $debug_line = shift;
3611     my $separator = shift // qr|\s+|;
3612     my @result = ();
3613
3614     if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
3615         print STDERR "DEBUG[tokenize]: \$separator = $separator\n";
3616     }
3617
3618     while ($line =~ s|^${separator}||, $line ne "") {
3619         my $token = "";
3620     again:
3621         $line =~ m/^(.*?)(${separator}|"|'|$)/;
3622         $token .= $1;
3623         $line = $2.$';
3624
3625         if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
3626             $token .= $1;
3627             $line = $';
3628             goto again;
3629         } elsif ($line =~ m/^'([^']*)'/) {
3630             $token .= $1;
3631             $line = $';
3632             goto again;
3633         }
3634         push @result, $token;
3635     }
3636
3637     if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
3638         print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
3639         print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";
3640     }
3641     return @result;
3642 }