Configure

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