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