Configure

   1 #! /usr/bin/env perl
   2 # -*- mode: perl; -*-
   3 # Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved.
   4 #
   5 # Licensed under the OpenSSL license (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 FindBin;
  15 use lib "$FindBin::Bin/util/perl";
  16 use File::Basename;
  17 use File::Spec::Functions qw/:DEFAULT abs2rel rel2abs/;
  18 use File::Path qw/mkpath/;
  19 use OpenSSL::Glob;
  20
  21 # see INSTALL for instructions.
  22
  23 my $orig_death_handler = $SIG{__DIE__};
  24 $SIG{__DIE__} = \&death_handler;
  25
  26 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-dso] [no-egd] [sctp] [386] [--prefix=DIR] [--openssldir=OPENSSLDIR] [--with-xxx[=vvv]] [--config=FILE] os/compiler[:flags]\n";
  27
  28 # Options:
  29 #
  30 # --config      add the given configuration file, which will be read after
  31 #               any "Configurations*" files that are found in the same
  32 #               directory as this script.
  33 # --prefix      prefix for the OpenSSL installation, which includes the
  34 #               directories bin, lib, include, share/man, share/doc/openssl
  35 #               This becomes the value of INSTALLTOP in Makefile
  36 #               (Default: /usr/local)
  37 # --openssldir  OpenSSL data area, such as openssl.cnf, certificates and keys.
  38 #               If it's a relative directory, it will be added on the directory
  39 #               given with --prefix.
  40 #               This becomes the value of OPENSSLDIR in Makefile and in C.
  41 #               (Default: PREFIX/ssl)
  42 #
  43 # --cross-compile-prefix Add specified prefix to binutils components.
  44 #
  45 # --api         One of 0.9.8, 1.0.0 or 1.1.0.  Do not compile support for
  46 #               interfaces deprecated as of the specified OpenSSL version.
  47 #
  48 # no-hw-xxx     do not compile support for specific crypto hardware.
  49 #               Generic OpenSSL-style methods relating to this support
  50 #               are always compiled but return NULL if the hardware
  51 #               support isn't compiled.
  52 # no-hw         do not compile support for any crypto hardware.
  53 # [no-]threads  [don't] try to create a library that is suitable for
  54 #               multithreaded applications (default is "threads" if we
  55 #               know how to do it)
  56 # [no-]shared   [don't] try to create shared libraries when supported.
  57 # [no-]pic      [don't] try to build position independent code when supported.
  58 #               If disabled, it also disables shared and dynamic-engine.
  59 # no-asm        do not use assembler
  60 # no-dso        do not compile in any native shared-library methods. This
  61 #               will ensure that all methods just return NULL.
  62 # no-egd        do not compile support for the entropy-gathering daemon APIs
  63 # [no-]zlib     [don't] compile support for zlib compression.
  64 # zlib-dynamic  Like "zlib", but the zlib library is expected to be a shared
  65 #               library and will be loaded in run-time by the OpenSSL library.
  66 # sctp          include SCTP support
  67 # enable-weak-ssl-ciphers
  68 #               Enable weak ciphers that are disabled by default.
  69 # 386           generate 80386 code in assembly modules
  70 # no-sse2       disables IA-32 SSE2 code in assembly modules, the above
  71 #               mentioned '386' option implies this one
  72 # no-<cipher>   build without specified algorithm (rsa, idea, rc5, ...)
  73 # -<xxx> +<xxx> compiler options are passed through
  74 # -static       while -static is also a pass-through compiler option (and
  75 #               as such is limited to environments where it's actually
  76 #               meaningful), it triggers a number configuration options,
  77 #               namely no-dso, no-pic, no-shared and no-threads. It is
  78 #               argued that the only reason to produce statically linked
  79 #               binaries (and in context it means executables linked with
  80 #               -static flag, and not just executables linked with static
  81 #               libcrypto.a) is to eliminate dependency on specific run-time,
  82 #               a.k.a. libc version. The mentioned config options are meant
  83 #               to achieve just that. Unfortunately on Linux it's impossible
  84 #               to eliminate the dependency completely for openssl executable
  85 #               because of getaddrinfo and gethostbyname calls, which can
  86 #               invoke dynamically loadable library facility anyway to meet
  87 #               the lookup requests. For this reason on Linux statically
  88 #               linked openssl executable has rather debugging value than
  89 #               production quality.
  90 #
  91 # DEBUG_SAFESTACK use type-safe stacks to enforce type-safety on stack items
  92 #               provided to stack calls. Generates unique stack functions for
  93 #               each possible stack type.
  94 # BN_LLONG      use the type 'long long' in crypto/bn/bn.h
  95 # RC4_CHAR      use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
  96 # Following are set automatically by this script
  97 #
  98 # MD5_ASM       use some extra md5 assembler,
  99 # SHA1_ASM      use some extra sha1 assembler, must define L_ENDIAN for x86
 100 # RMD160_ASM    use some extra ripemd160 assembler,
 101 # SHA256_ASM    sha256_block is implemented in assembler
 102 # SHA512_ASM    sha512_block is implemented in assembler
 103 # AES_ASM       AES_[en|de]crypt is implemented in assembler
 104
 105 # Minimum warning options... any contributions to OpenSSL should at least get
 106 # past these.
 107
 108 # DEBUG_UNUSED enables __owur (warn unused result) checks.
 109 my $gcc_devteam_warn = "-DDEBUG_UNUSED"
 110         # -DPEDANTIC complements -pedantic and is meant to mask code that
 111         # is not strictly standard-compliant and/or implementation-specific,
 112         # e.g. inline assembly, disregards to alignment requirements, such
 113         # that -pedantic would complain about. Incidentally -DPEDANTIC has
 114         # to be used even in sanitized builds, because sanitizer too is
 115         # supposed to and does take notice of non-standard behaviour. Then
 116         # -pedantic with pre-C9x compiler would also complain about 'long
 117         # long' not being supported. As 64-bit algorithms are common now,
 118         # it grew impossible to resolve this without sizeable additional
 119         # code, so we just tell compiler to be pedantic about everything
 120         # but 'long long' type.
 121         . " -DPEDANTIC -pedantic -Wno-long-long"
 122         . " -Wall"
 123         . " -Wextra"
 124         . " -Wno-unused-parameter"
 125         . " -Wno-missing-field-initializers"
 126         . " -Wsign-compare"
 127         . " -Wmissing-prototypes"
 128         . " -Wshadow"
 129         . " -Wformat"
 130         . " -Wtype-limits"
 131         . " -Wundef"
 132         . " -Werror"
 133         ;
 134
 135 # These are used in addition to $gcc_devteam_warn when the compiler is clang.
 136 # TODO(openssl-team): fix problems and investigate if (at least) the
 137 # following warnings can also be enabled:
 138 #       -Wswitch-enum
 139 #       -Wcast-align
 140 #       -Wunreachable-code
 141 #       -Wlanguage-extension-token -- no, we use asm()
 142 #       -Wunused-macros -- no, too tricky for BN and _XOPEN_SOURCE etc
 143 #       -Wextended-offsetof -- no, needed in CMS ASN1 code
 144 my $clang_devteam_warn = ""
 145         . " -Qunused-arguments"
 146         . " -Wno-language-extension-token"
 147         . " -Wno-extended-offsetof"
 148         . " -Wconditional-uninitialized"
 149         . " -Wincompatible-pointer-types-discards-qualifiers"
 150         . " -Wmissing-variable-declarations"
 151         ;
 152
 153 # This adds backtrace information to the memory leak info.  Is only used
 154 # when crypto-mdebug-backtrace is enabled.
 155 my $memleak_devteam_backtrace = "-rdynamic";
 156
 157 my $strict_warnings = 0;
 158
 159 # As for $BSDthreads. Idea is to maintain "collective" set of flags,
 160 # which would cover all BSD flavors. -pthread applies to them all,
 161 # but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
 162 # -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
 163 # which has to be accompanied by explicit -D_THREAD_SAFE and
 164 # sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
 165 # seems to be sufficient?
 166 our $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
 167
 168 #
 169 # API compatibility name to version number mapping.
 170 #
 171 my $maxapi = "1.1.0";           # API for "no-deprecated" builds
 172 my $apitable = {
 173     "1.1.0" => "0x10100000L",
 174     "1.0.0" => "0x10000000L",
 175     "0.9.8" => "0x00908000L",
 176 };
 177
 178 our %table = ();
 179 our %config = ();
 180 our %withargs = ();
 181
 182 # Forward declarations ###############################################
 183
 184 # read_config(filename)
 185 #
 186 # Reads a configuration file and populates %table with the contents
 187 # (which the configuration file places in %targets).
 188 sub read_config;
 189
 190 # resolve_config(target)
 191 #
 192 # Resolves all the late evaluations, inheritances and so on for the
 193 # chosen target and any target it inherits from.
 194 sub resolve_config;
 195
 196
 197 # Information collection #############################################
 198
 199 # Unified build supports separate build dir
 200 my $srcdir = catdir(absolutedir(dirname($0))); # catdir ensures local syntax
 201 my $blddir = catdir(absolutedir("."));         # catdir ensures local syntax
 202 my $dofile = abs2rel(catfile($srcdir, "util/dofile.pl"));
 203
 204 my $local_config_envname = 'OPENSSL_LOCAL_CONFIG_DIR';
 205
 206 $config{sourcedir} = abs2rel($srcdir);
 207 $config{builddir} = abs2rel($blddir);
 208
 209 # Collect reconfiguration information if needed
 210 my @argvcopy=@ARGV;
 211
 212 if (grep /^reconf(igure)?$/, @argvcopy) {
 213     if (-f "./configdata.pm") {
 214         my $file = "./configdata.pm";
 215         unless (my $return = do $file) {
 216             die "couldn't parse $file: $@" if $@;
 217             die "couldn't do $file: $!"    unless defined $return;
 218             die "couldn't run $file"       unless $return;
 219         }
 220
 221         @argvcopy = defined($configdata::config{perlargv}) ?
 222             @{$configdata::config{perlargv}} : ();
 223         die "Incorrect data to reconfigure, please do a normal configuration\n"
 224             if (grep(/^reconf/,@argvcopy));
 225         $ENV{CROSS_COMPILE} = $configdata::config{cross_compile_prefix}
 226             if defined($configdata::config{cross_compile_prefix});
 227         $ENV{CC} = $configdata::config{cc}
 228             if defined($configdata::config{cc});
 229         $ENV{BUILDFILE} = $configdata::config{build_file}
 230             if defined($configdata::config{build_file});
 231         $ENV{$local_config_envname} = $configdata::config{local_config_dir}
 232             if defined($configdata::config{local_config_dir});
 233
 234         print "Reconfiguring with: ", join(" ",@argvcopy), "\n";
 235         print "    CROSS_COMPILE = ",$ENV{CROSS_COMPILE},"\n"
 236             if $ENV{CROSS_COMPILE};
 237         print "    CC = ",$ENV{CC},"\n" if $ENV{CC};
 238         print "    BUILDFILE = ",$ENV{BUILDFILE},"\n" if $ENV{BUILDFILE};
 239         print "    $local_config_envname = ",$ENV{$local_config_envname},"\n"
 240             if $ENV{$local_config_envname};
 241     } else {
 242         die "Insufficient data to reconfigure, please do a normal configuration\n";
 243     }
 244 }
 245
 246 $config{perlargv} = [ @argvcopy ];
 247
 248 # Collect version numbers
 249 $config{version} = "unknown";
 250 $config{version_num} = "unknown";
 251 $config{shlib_version_number} = "unknown";
 252 $config{shlib_version_history} = "unknown";
 253
 254 collect_information(
 255     collect_from_file(catfile($srcdir,'include/openssl/opensslv.h')),
 256     qr/OPENSSL.VERSION.TEXT.*OpenSSL (\S+) / => sub { $config{version} = $1; },
 257     qr/OPENSSL.VERSION.NUMBER.*(0x\S+)/      => sub { $config{version_num}=$1 },
 258     qr/SHLIB_VERSION_NUMBER *"([^"]+)"/      => sub { $config{shlib_version_number}=$1 },
 259     qr/SHLIB_VERSION_HISTORY *"([^"]*)"/     => sub { $config{shlib_version_history}=$1 }
 260     );
 261 if ($config{shlib_version_history} ne "") { $config{shlib_version_history} .= ":"; }
 262
 263 ($config{major}, $config{minor})
 264     = ($config{version} =~ /^([0-9]+)\.([0-9\.]+)/);
 265 ($config{shlib_major}, $config{shlib_minor})
 266     = ($config{shlib_version_number} =~ /^([0-9]+)\.([0-9\.]+)/);
 267 die "erroneous version information in opensslv.h: ",
 268     "$config{major}, $config{minor}, $config{shlib_major}, $config{shlib_minor}\n"
 269     if ($config{major} eq "" || $config{minor} eq ""
 270         || $config{shlib_major} eq "" ||  $config{shlib_minor} eq "");
 271
 272 # Collect target configurations
 273
 274 my $pattern = catfile(dirname($0), "Configurations", "*.conf");
 275 foreach (sort glob($pattern)) {
 276     &read_config($_);
 277 }
 278
 279 if (defined $ENV{$local_config_envname}) {
 280     if ($^O eq 'VMS') {
 281         # VMS environment variables are logical names,
 282         # which can be used as is
 283         $pattern = $local_config_envname . ':' . '*.conf';
 284     } else {
 285         $pattern = catfile($ENV{$local_config_envname}, '*.conf');
 286     }
 287
 288     foreach (sort glob($pattern)) {
 289         &read_config($_);
 290     }
 291 }
 292
 293
 294 print "Configuring OpenSSL version $config{version} ($config{version_num})\n";
 295
 296 $config{prefix}="";
 297 $config{openssldir}="";
 298 $config{processor}="";
 299 $config{libdir}="";
 300 $config{cross_compile_prefix}="";
 301 $config{fipslibdir}="/usr/local/ssl/fips-2.0/lib/";
 302 my $nofipscanistercheck=0;
 303 $config{baseaddr}="0xFB00000";
 304 my $auto_threads=1;    # enable threads automatically? true by default
 305 my $default_ranlib;
 306 $config{fips}=0;
 307
 308 # Top level directories to build
 309 $config{dirs} = [ "crypto", "ssl", "engines", "apps", "test", "util", "tools", "fuzz" ];
 310 # crypto/ subdirectories to build
 311 $config{sdirs} = [
 312     "objects",
 313     "md2", "md4", "md5", "sha", "mdc2", "hmac", "ripemd", "whrlpool", "poly1305", "blake2",
 314     "des", "aes", "rc2", "rc4", "rc5", "idea", "bf", "cast", "camellia", "seed", "chacha", "modes",
 315     "bn", "ec", "rsa", "dsa", "dh", "dso", "engine",
 316     "buffer", "bio", "stack", "lhash", "rand", "err",
 317     "evp", "asn1", "pem", "x509", "x509v3", "conf", "txt_db", "pkcs7", "pkcs12", "comp", "ocsp", "ui",
 318     "cms", "ts", "srp", "cmac", "ct", "async", "kdf"
 319     ];
 320
 321 # Known TLS and DTLS protocols
 322 my @tls = qw(ssl3 tls1 tls1_1 tls1_2);
 323 my @dtls = qw(dtls1 dtls1_2);
 324
 325 # Explicitly known options that are possible to disable.  They can
 326 # be regexps, and will be used like this: /^no-${option}$/
 327 # For developers: keep it sorted alphabetically
 328
 329 my @disablables = (
 330     "afalgeng",
 331     "asan",
 332     "asm",
 333     "async",
 334     "autoalginit",
 335     "autoerrinit",
 336     "bf",
 337     "blake2",
 338     "camellia",
 339     "capieng",
 340     "cast",
 341     "chacha",
 342     "cmac",
 343     "cms",
 344     "comp",
 345     "crypto-mdebug",
 346     "crypto-mdebug-backtrace",
 347     "ct",
 348     "deprecated",
 349     "des",
 350     "dgram",
 351     "dh",
 352     "dsa",
 353     "dso",
 354     "dtls",
 355     "dynamic-engine",
 356     "ec",
 357     "ec2m",
 358     "ecdh",
 359     "ecdsa",
 360     "ec_nistp_64_gcc_128",
 361     "egd",
 362     "engine",
 363     "err",
 364     "filenames",
 365     "fuzz-libfuzzer",
 366     "fuzz-afl",
 367     "gost",
 368     "heartbeats",
 369     "hw(-.+)?",
 370     "idea",
 371     "makedepend",
 372     "md2",
 373     "md4",
 374     "mdc2",
 375     "msan",
 376     "multiblock",
 377     "nextprotoneg",
 378     "ocb",
 379     "ocsp",
 380     "pic",
 381     "poly1305",
 382     "posix-io",
 383     "psk",
 384     "rc2",
 385     "rc4",
 386     "rc5",
 387     "rdrand",
 388     "rfc3779",
 389     "rmd160",
 390     "scrypt",
 391     "sctp",
 392     "seed",
 393     "shared",
 394     "sock",
 395     "srp",
 396     "srtp",
 397     "sse2",
 398     "ssl",
 399     "ssl-trace",
 400     "static-engine",
 401     "stdio",
 402     "threads",
 403     "tls",
 404     "ts",
 405     "ubsan",
 406     "ui",
 407     "unit-test",
 408     "whirlpool",
 409     "weak-ssl-ciphers",
 410     "zlib",
 411     "zlib-dynamic",
 412     );
 413 foreach my $proto ((@tls, @dtls))
 414         {
 415         push(@disablables, $proto);
 416         push(@disablables, "$proto-method");
 417         }
 418
 419 my %deprecated_disablables = (
 420     "ssl2" => undef,
 421     "buf-freelists" => undef,
 422     "ripemd" => "rmd160"
 423     );
 424
 425 # All of the following is disabled by default (RC5 was enabled before 0.9.8):
 426
 427 our %disabled = ( # "what"         => "comment"
 428                   "asan"                => "default",
 429                   "crypto-mdebug"       => "default",
 430                   "crypto-mdebug-backtrace" => "default",
 431                   "ec_nistp_64_gcc_128" => "default",
 432                   "egd"                 => "default",
 433                   "fuzz-libfuzzer"      => "default",
 434                   "fuzz-afl"            => "default",
 435                   "heartbeats"          => "default",
 436                   "md2"                 => "default",
 437                   "msan"                => "default",
 438                   "rc5"                 => "default",
 439                   "sctp"                => "default",
 440                   "ssl-trace"           => "default",
 441                   "ssl3"                => "default",
 442                   "ssl3-method"         => "default",
 443                   "ubsan"               => "default",
 444                   "unit-test"           => "default",
 445                   "weak-ssl-ciphers"    => "default",
 446                   "zlib"                => "default",
 447                   "zlib-dynamic"        => "default",
 448                 );
 449
 450 # Note: => pair form used for aesthetics, not to truly make a hash table
 451 my @disable_cascades = (
 452     # "what"            => [ "cascade", ... ]
 453     sub { $config{processor} eq "386" }
 454                         => [ "sse2" ],
 455     "ssl"               => [ "ssl3" ],
 456     "ssl3-method"       => [ "ssl3" ],
 457     "zlib"              => [ "zlib-dynamic" ],
 458     "des"               => [ "mdc2" ],
 459     "ec"                => [ "ecdsa", "ecdh" ],
 460
 461     "dgram"             => [ "dtls", "sctp" ],
 462     "sock"              => [ "dgram" ],
 463     "dtls"              => [ @dtls ],
 464     sub { 0 == scalar grep { !$disabled{$_} } @dtls }
 465                         => [ "dtls" ],
 466
 467     "tls"               => [ @tls ],
 468     sub { 0 == scalar grep { !$disabled{$_} } @tls }
 469                         => [ "tls" ],
 470
 471     "crypto-mdebug"     => [ "crypto-mdebug-backtrace" ],
 472
 473     # Without DSO, we can't load dynamic engines, so don't build them dynamic
 474     "dso"               => [ "dynamic-engine" ],
 475
 476     # Without position independent code, there can be no shared libraries or DSOs
 477     "pic"               => [ "shared" ],
 478     "shared"            => [ "dynamic-engine" ],
 479     "engine"            => [ "afalgeng" ],
 480
 481     # no-autoalginit is only useful when building non-shared
 482     "autoalginit"       => [ "shared", "apps" ],
 483
 484     "stdio"             => [ "apps", "capieng", "egd" ],
 485     "apps"              => [ "tests" ],
 486     "comp"              => [ "zlib" ],
 487     sub { !$disabled{"unit-test"} } => [ "heartbeats" ],
 488
 489     sub { !$disabled{"msan"} } => [ "asm" ],
 490     );
 491
 492 # Avoid protocol support holes.  Also disable all versions below N, if version
 493 # N is disabled while N+1 is enabled.
 494 #
 495 my @list = (reverse @tls);
 496 while ((my $first, my $second) = (shift @list, shift @list)) {
 497     last unless @list;
 498     push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
 499                               => [ @list ] );
 500     unshift @list, $second;
 501 }
 502 my @list = (reverse @dtls);
 503 while ((my $first, my $second) = (shift @list, shift @list)) {
 504     last unless @list;
 505     push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
 506                               => [ @list ] );
 507     unshift @list, $second;
 508 }
 509
 510 # Explicit "no-..." options will be collected in %disabled along with the defaults.
 511 # To remove something from %disabled, use "enable-foo".
 512 # For symmetry, "disable-foo" is a synonym for "no-foo".
 513
 514 &usage if ($#ARGV < 0);
 515
 516 my $user_cflags="";
 517 my @user_defines=();
 518 $config{openssl_api_defines}=[];
 519 $config{openssl_algorithm_defines}=[];
 520 $config{openssl_thread_defines}=[];
 521 $config{openssl_sys_defines}=[];
 522 $config{openssl_other_defines}=[];
 523 my $libs="";
 524 my $target="";
 525 $config{options}="";
 526 $config{build_type} = "release";
 527
 528 my %unsupported_options = ();
 529 my %deprecated_options = ();
 530 while (@argvcopy)
 531         {
 532         $_ = shift @argvcopy;
 533         # VMS is a case insensitive environment, and depending on settings
 534         # out of our control, we may receive options uppercased.  Let's
 535         # downcase at least the part before any equal sign.
 536         if ($^O eq "VMS")
 537                 {
 538                 s/^([^=]*)/lc($1)/e;
 539                 }
 540         s /^-no-/no-/; # some people just can't read the instructions
 541
 542         # rewrite some options in "enable-..." form
 543         s /^-?-?shared$/enable-shared/;
 544         s /^sctp$/enable-sctp/;
 545         s /^threads$/enable-threads/;
 546         s /^zlib$/enable-zlib/;
 547         s /^zlib-dynamic$/enable-zlib-dynamic/;
 548
 549         if (/^(no|disable|enable)-(.+)$/)
 550                 {
 551                 my $word = $2;
 552                 if (!exists $deprecated_disablables{$word}
 553                         && !grep { $word =~ /^${_}$/ } @disablables)
 554                         {
 555                         $unsupported_options{$_} = 1;
 556                         next;
 557                         }
 558                 }
 559         if (/^no-(.+)$/ || /^disable-(.+)$/)
 560                 {
 561                 foreach my $proto ((@tls, @dtls))
 562                         {
 563                         if ($1 eq "$proto-method")
 564                                 {
 565                                 $disabled{"$proto"} = "option($proto-method)";
 566                                 last;
 567                                 }
 568                         }
 569                 if ($1 eq "dtls")
 570                         {
 571                         foreach my $proto (@dtls)
 572                                 {
 573                                 $disabled{$proto} = "option(dtls)";
 574                                 }
 575                         $disabled{"dtls"} = "option(dtls)";
 576                         }
 577                 elsif ($1 eq "ssl")
 578                         {
 579                         # Last one of its kind
 580                         $disabled{"ssl3"} = "option(ssl)";
 581                         }
 582                 elsif ($1 eq "tls")
 583                         {
 584                         # XXX: Tests will fail if all SSL/TLS
 585                         # protocols are disabled.
 586                         foreach my $proto (@tls)
 587                                 {
 588                                 $disabled{$proto} = "option(tls)";
 589                                 }
 590                         }
 591                 elsif ($1 eq "static-engine")
 592                         {
 593                         delete $disabled{"dynamic-engine"};
 594                         }
 595                 elsif ($1 eq "dynamic-engine")
 596                         {
 597                         $disabled{"dynamic-engine"} = "option";
 598                         }
 599                 elsif (exists $deprecated_disablables{$1})
 600                         {
 601                         $deprecated_options{$_} = 1;
 602                         if (defined $deprecated_disablables{$1})
 603                                 {
 604                                 $disabled{$deprecated_disablables{$1}} = "option";
 605                                 }
 606                         }
 607                 else
 608                         {
 609                         $disabled{$1} = "option";
 610                         }
 611                 # No longer an automatic choice
 612                 $auto_threads = 0 if ($1 eq "threads");
 613                 }
 614         elsif (/^enable-(.+)$/)
 615                 {
 616                 if ($1 eq "static-engine")
 617                         {
 618                         $disabled{"dynamic-engine"} = "option";
 619                         }
 620                 elsif ($1 eq "dynamic-engine")
 621                         {
 622                         delete $disabled{"dynamic-engine"};
 623                         }
 624                 elsif ($1 eq "zlib-dynamic")
 625                         {
 626                         delete $disabled{"zlib"};
 627                         }
 628                 my $algo = $1;
 629                 delete $disabled{$algo};
 630
 631                 # No longer an automatic choice
 632                 $auto_threads = 0 if ($1 eq "threads");
 633                 }
 634         elsif (/^--strict-warnings$/)
 635                 {
 636                 $strict_warnings = 1;
 637                 }
 638         elsif (/^--debug$/)
 639                 {
 640                 $config{build_type} = "debug";
 641                 }
 642         elsif (/^--release$/)
 643                 {
 644                 $config{build_type} = "release";
 645                 }
 646         elsif (/^386$/)
 647                 { $config{processor}=386; }
 648         elsif (/^fips$/)
 649                 {
 650                 $config{fips}=1;
 651                 }
 652         elsif (/^rsaref$/)
 653                 {
 654                 # No RSAref support any more since it's not needed.
 655                 # The check for the option is there so scripts aren't
 656                 # broken
 657                 }
 658         elsif (/^nofipscanistercheck$/)
 659                 {
 660                 $config{fips} = 1;
 661                 $nofipscanistercheck = 1;
 662                 }
 663         elsif (/^[-+]/)
 664                 {
 665                 if (/^--prefix=(.*)$/)
 666                         {
 667                         $config{prefix}=$1;
 668                         die "Directory given with --prefix MUST be absolute\n"
 669                                 unless file_name_is_absolute($config{prefix});
 670                         }
 671                 elsif (/^--api=(.*)$/)
 672                         {
 673                         $config{api}=$1;
 674                         }
 675                 elsif (/^--libdir=(.*)$/)
 676                         {
 677                         $config{libdir}=$1;
 678                         }
 679                 elsif (/^--openssldir=(.*)$/)
 680                         {
 681                         $config{openssldir}=$1;
 682                         }
 683                 elsif (/^--with-zlib-lib=(.*)$/)
 684                         {
 685                         $withargs{zlib_lib}=$1;
 686                         }
 687                 elsif (/^--with-zlib-include=(.*)$/)
 688                         {
 689                         $withargs{zlib_include}=$1;
 690                         }
 691                 elsif (/^--with-fuzzer-lib=(.*)$/)
 692                         {
 693                         $withargs{fuzzer_lib}=$1;
 694                         }
 695                 elsif (/^--with-fuzzer-include=(.*)$/)
 696                         {
 697                         $withargs{fuzzer_include}=$1;
 698                         }
 699                 elsif (/^--with-fipslibdir=(.*)$/)
 700                         {
 701                         $config{fipslibdir}="$1/";
 702                         }
 703                 elsif (/^--with-baseaddr=(.*)$/)
 704                         {
 705                         $config{baseaddr}="$1";
 706                         }
 707                 elsif (/^--cross-compile-prefix=(.*)$/)
 708                         {
 709                         $config{cross_compile_prefix}=$1;
 710                         }
 711                 elsif (/^--config=(.*)$/)
 712                         {
 713                         read_config $1;
 714                         }
 715                 elsif (/^-[lL](.*)$/ or /^-Wl,/)
 716                         {
 717                         $libs.=$_." ";
 718                         }
 719                 elsif (/^-rpath$/ or /^-R$/)
 720                         # -rpath is the OSF1 rpath flag
 721                         # -R is the old Solaris rpath flag
 722                         {
 723                         my $rpath = shift(@argvcopy) || "";
 724                         $rpath .= " " if $rpath ne "";
 725                         $libs.=$_." ".$rpath;
 726                         }
 727                 elsif (/^-static$/)
 728                         {
 729                         $libs.=$_." ";
 730                         $disabled{"dso"} = "forced";
 731                         $disabled{"pic"} = "forced";
 732                         $disabled{"shared"} = "forced";
 733                         $disabled{"threads"} = "forced";
 734                         }
 735                 elsif (/^-D(.*)$/)
 736                         {
 737                         push @user_defines, $1;
 738                         }
 739                 else    # common if (/^[-+]/), just pass down...
 740                         {
 741                         $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
 742                         $user_cflags.=" ".$_;
 743                         }
 744                 }
 745         else
 746                 {
 747                 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
 748                 $target=$_;
 749                 }
 750         unless ($_ eq $target || /^no-/ || /^disable-/)
 751                 {
 752                 # "no-..." follows later after implied disactivations
 753                 # have been derived.  (Don't take this too seriously,
 754                 # we really only write OPTIONS to the Makefile out of
 755                 # nostalgia.)
 756
 757                 if ($config{options} eq "")
 758                         { $config{options} = $_; }
 759                 else
 760                         { $config{options} .= " ".$_; }
 761                 }
 762         }
 763
 764 if (defined($config{api}) && !exists $apitable->{$config{api}}) {
 765         die "***** Unsupported api compatibility level: $config{api}\n",
 766 }
 767
 768 if (keys %deprecated_options)
 769         {
 770         warn "***** Deprecated options: ",
 771                 join(", ", keys %deprecated_options), "\n";
 772         }
 773 if (keys %unsupported_options)
 774         {
 775         die "***** Unsupported options: ",
 776                 join(", ", keys %unsupported_options), "\n";
 777         }
 778
 779 if ($libs =~ /(^|\s)-Wl,-rpath,/
 780     && !$disabled{shared}
 781     && !($disabled{asan} && $disabled{msan} && $disabled{ubsan})) {
 782     die "***** Cannot simultaneously use -rpath, shared libraries, and\n",
 783         "***** any of asan, msan or ubsan\n";
 784 }
 785
 786 if ($config{fips})
 787         {
 788         delete $disabled{"shared"} if ($disabled{"shared"} =~ /^default/);
 789         }
 790 else
 791         {
 792         @{$config{dirs}} = grep !/^fips$/, @{$config{dirs}};
 793         }
 794
 795 my @tocheckfor = (keys %disabled);
 796 while (@tocheckfor) {
 797     my %new_tocheckfor = ();
 798     my @cascade_copy = (@disable_cascades);
 799     while (@cascade_copy) {
 800         my ($test, $descendents) = (shift @cascade_copy, shift @cascade_copy);
 801         if (ref($test) eq "CODE" ? $test->() : defined($disabled{$test})) {
 802             foreach(grep { !defined($disabled{$_}) } @$descendents) {
 803                 $new_tocheckfor{$_} = 1; $disabled{$_} = "forced";
 804             }
 805         }
 806     }
 807     @tocheckfor = (keys %new_tocheckfor);
 808 }
 809
 810 our $die = sub { die @_; };
 811 if ($target eq "TABLE") {
 812     local $die = sub { warn @_; };
 813     foreach (sort keys %table) {
 814         print_table_entry($_, "TABLE");
 815     }
 816     exit 0;
 817 }
 818
 819 if ($target eq "LIST") {
 820     foreach (sort keys %table) {
 821         print $_,"\n" unless $table{$_}->{template};
 822     }
 823     exit 0;
 824 }
 825
 826 if ($target eq "HASH") {
 827     local $die = sub { warn @_; };
 828     print "%table = (\n";
 829     foreach (sort keys %table) {
 830         print_table_entry($_, "HASH");
 831     }
 832     exit 0;
 833 }
 834
 835 # Backward compatibility?
 836 if ($target =~ m/^CygWin32(-.*)$/) {
 837     $target = "Cygwin".$1;
 838 }
 839
 840 foreach (sort (keys %disabled))
 841         {
 842         $config{options} .= " no-$_";
 843
 844         printf "    no-%-12s %-10s", $_, "[$disabled{$_}]";
 845
 846         if (/^dso$/)
 847                 { }
 848         elsif (/^threads$/)
 849                 { }
 850         elsif (/^shared$/)
 851                 { }
 852         elsif (/^pic$/)
 853                 { }
 854         elsif (/^zlib$/)
 855                 { }
 856         elsif (/^dynamic-engine$/)
 857                 { }
 858         elsif (/^makedepend$/)
 859                 { }
 860         elsif (/^zlib-dynamic$/)
 861                 { }
 862         elsif (/^sse2$/)
 863                 { }
 864         elsif (/^engine$/)
 865                 {
 866                 @{$config{dirs}} = grep !/^engines$/, @{$config{dirs}};
 867                 @{$config{sdirs}} = grep !/^engine$/, @{$config{sdirs}};
 868                 push @{$config{openssl_other_defines}}, "OPENSSL_NO_ENGINE";
 869                 print " OPENSSL_NO_ENGINE (skip engines)";
 870                 }
 871         else
 872                 {
 873                 my ($WHAT, $what);
 874
 875                 ($WHAT = $what = $_) =~ tr/[\-a-z]/[_A-Z]/;
 876
 877                 # Fix up C macro end names
 878                 $WHAT = "RMD160" if $what eq "ripemd";
 879
 880                 # fix-up crypto/directory name(s)
 881                 $what = "ripemd" if $what eq "rmd160";
 882                 $what = "whrlpool" if $what eq "whirlpool";
 883
 884                 if ($what ne "async" && $what ne "err"
 885                     && grep { $_ eq $what } @{$config{sdirs}})
 886                         {
 887                         push @{$config{openssl_algorithm_defines}}, "OPENSSL_NO_$WHAT";
 888                         @{$config{sdirs}} = grep { $_ ne $what} @{$config{sdirs}};
 889
 890                         print " OPENSSL_NO_$WHAT (skip dir)";
 891                         }
 892                 else
 893                         {
 894                         push @{$config{openssl_other_defines}}, "OPENSSL_NO_$WHAT";
 895                         print " OPENSSL_NO_$WHAT";
 896                         }
 897                 }
 898
 899         print "\n";
 900         }
 901
 902 print "Configuring for $target\n";
 903
 904 # Support for legacy targets having a name starting with 'debug-'
 905 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
 906 if ($d) {
 907     $config{build_type} = "debug";
 908
 909     # If we do not find debug-foo in the table, the target is set to foo.
 910     if (!$table{$target}) {
 911         $target = $t;
 912     }
 913 }
 914
 915 &usage if !$table{$target} || $table{$target}->{template};
 916
 917 $config{target} = $target;
 918 my %target = resolve_config($target);
 919
 920 my %conf_files = map { $_ => 1 } (@{$target{_conf_fname_int}});
 921 $config{conf_files} = [ sort keys %conf_files ];
 922 %target = ( %{$table{DEFAULTS}}, %target );
 923
 924 $target{exe_extension}="";
 925 $target{exe_extension}=".exe" if ($config{target} eq "DJGPP"
 926                                   || $config{target} =~ /^(?:Cygwin|mingw)/);
 927 $target{exe_extension}=".pm"  if ($config{target} =~ /vos/);
 928
 929 ($target{shared_extension_simple}=$target{shared_extension})
 930     =~ s|\.\$\(SHLIB_MAJOR\)\.\$\(SHLIB_MINOR\)||;
 931 $target{dso_extension}=$target{shared_extension_simple};
 932 ($target{shared_import_extension}=$target{shared_extension_simple}.".a")
 933     if ($config{target} =~ /^(?:Cygwin|mingw)/);
 934
 935
 936 $config{cross_compile_prefix} = $ENV{'CROSS_COMPILE'}
 937     if $config{cross_compile_prefix} eq "";
 938
 939 # Allow overriding the names of some tools.  USE WITH CARE
 940 # Note: only Unix cares about HASHBANGPERL...  that explains
 941 # the default string.
 942 $config{perl} =    $ENV{'PERL'}    || ($^O ne "VMS" ? $^X : "perl");
 943 $config{hashbangperl} =
 944     $ENV{'HASHBANGPERL'}           || $ENV{'PERL'}     || "/usr/bin/env perl";
 945 $target{cc} =      $ENV{'CC'}      || $target{cc}      || "cc";
 946 $target{ranlib} =  $ENV{'RANLIB'}  || $target{ranlib}  ||
 947                    (which("$config{cross_compile_prefix}ranlib") ?
 948                           "\$(CROSS_COMPILE)ranlib" : "true");
 949 $target{ar} =      $ENV{'AR'}      || $target{ar}      || "ar";
 950 $target{nm} =      $ENV{'NM'}      || $target{nm}      || "nm";
 951 $target{rc} =
 952     $ENV{'RC'}  || $ENV{'WINDRES'} || $target{rc}      || "windres";
 953
 954 # Allow overriding the build file name
 955 $target{build_file} = $ENV{BUILDFILE} || $target{build_file} || "Makefile";
 956
 957 # Cache information necessary for reconfiguration
 958 $config{cc} = $target{cc};
 959 $config{build_file} = $target{build_file};
 960
 961 # For cflags, lflags, plib_lflags, ex_libs and defines, add the debug_
 962 # or release_ attributes.
 963 # Do it in such a way that no spurious space is appended (hence the grep).
 964 $config{defines} = [];
 965 $config{cflags} = "";
 966 $config{ex_libs} = "";
 967 $config{shared_ldflag} = "";
 968
 969 # Make sure build_scheme is consistent.
 970 $target{build_scheme} = [ $target{build_scheme} ]
 971     if ref($target{build_scheme}) ne "ARRAY";
 972
 973 my ($builder, $builder_platform, @builder_opts) =
 974     @{$target{build_scheme}};
 975
 976 foreach my $checker (($builder_platform."-".$target{build_file}."-checker.pm",
 977                       $builder_platform."-checker.pm")) {
 978     my $checker_path = catfile($srcdir, "Configurations", $checker);
 979     if (-f $checker_path) {
 980         my $fn = $ENV{CONFIGURE_CHECKER_WARN}
 981             ? sub { warn $@; } : sub { die $@; };
 982         if (! do $checker_path) {
 983             if ($@) {
 984                 $fn->($@);
 985             } elsif ($!) {
 986                 $fn->($!);
 987             } else {
 988                 $fn->("The detected tools didn't match the platform\n");
 989             }
 990         }
 991         last;
 992     }
 993 }
 994
 995 push @{$config{defines}}, "NDEBUG"    if $config{build_type} eq "release";
 996
 997 if ($target =~ /^mingw/ && `$target{cc} --target-help 2>&1` =~ m/-mno-cygwin/m)
 998         {
 999         $config{cflags} .= " -mno-cygwin";
1000         $config{shared_ldflag} .= " -mno-cygwin";
1001         }
1002
1003 if ($target =~ /linux.*-mips/ && !$disabled{asm} && $user_cflags !~ /-m(ips|arch=)/) {
1004         # minimally required architecture flags for assembly modules
1005         $config{cflags}="-mips2 $config{cflags}" if ($target =~ /mips32/);
1006         $config{cflags}="-mips3 $config{cflags}" if ($target =~ /mips64/);
1007 }
1008
1009 my $no_shared_warn=0;
1010 my $no_user_cflags=0;
1011 my $no_user_defines=0;
1012
1013 # The DSO code currently always implements all functions so that no
1014 # applications will have to worry about that from a compilation point
1015 # of view. However, the "method"s may return zero unless that platform
1016 # has support compiled in for them. Currently each method is enabled
1017 # by a define "DSO_<name>" ... we translate the "dso_scheme" config
1018 # string entry into using the following logic;
1019 if (!$disabled{dso} && $target{dso_scheme} ne "")
1020         {
1021         $target{dso_scheme} =~ tr/[a-z]/[A-Z]/;
1022         if ($target{dso_scheme} eq "DLFCN")
1023                 {
1024                 unshift @{$config{defines}}, "DSO_DLFCN", "HAVE_DLFCN_H";
1025                 }
1026         elsif ($target{dso_scheme} eq "DLFCN_NO_H")
1027                 {
1028                 unshift @{$config{defines}}, "DSO_DLFCN";
1029                 }
1030         else
1031                 {
1032                 unshift @{$config{defines}}, "DSO_$target{dso_scheme}";
1033                 }
1034         }
1035
1036 $config{ex_libs}="$libs$config{ex_libs}" if ($libs ne "");
1037
1038 if ($disabled{asm})
1039         {
1040         if ($config{fips})
1041                 {
1042                 @{$config{defines}} = grep !/^[BL]_ENDIAN$/, @{$config{defines}};
1043                 @{$target{defines}} = grep !/^[BL]_ENDIAN$/, @{$target{defines}};
1044                 }
1045         }
1046
1047 # If threads aren't disabled, check how possible they are
1048 unless ($disabled{threads}) {
1049     if ($auto_threads) {
1050         # Enabled by default, disable it forcibly if unavailable
1051         if ($target{thread_scheme} eq "(unknown)") {
1052             $disabled{threads} = "unavailable";
1053         }
1054     } else {
1055         # The user chose to enable threads explicitly, let's see
1056         # if there's a chance that's possible
1057         if ($target{thread_scheme} eq "(unknown)") {
1058             # If the user asked for "threads" and we don't have internal
1059             # knowledge how to do it, [s]he is expected to provide any
1060             # system-dependent compiler options that are necessary.  We
1061             # can't truly check that the given options are correct, but
1062             # we expect the user to know what [s]He is doing.
1063             if ($no_user_cflags && $no_user_defines) {
1064                 die "You asked for multi-threading support, but didn't\n"
1065                     ,"provide any system-specific compiler options\n";
1066             }
1067         }
1068     }
1069 }
1070
1071 # If threads still aren't disabled, add a C macro to ensure the source
1072 # code knows about it.  Any other flag is taken care of by the configs.
1073 unless($disabled{threads}) {
1074     foreach (("defines", "openssl_thread_defines")) {
1075         push @{$config{$_}}, "OPENSSL_THREADS";
1076     }
1077 }
1078
1079 # With "deprecated" disable all deprecated features.
1080 if (defined($disabled{"deprecated"})) {
1081         $config{api} = $maxapi;
1082 }
1083
1084 if ($target{shared_target} eq "")
1085         {
1086         $no_shared_warn = 1
1087             if ((!$disabled{shared} || !$disabled{"dynamic-engine"})
1088                 && !$config{fips});
1089         $disabled{shared} = "no-shared-target";
1090         $disabled{pic} = $disabled{shared} = $disabled{"dynamic-engine"} =
1091             "no-shared-target";
1092         }
1093
1094 if ($disabled{"dynamic-engine"}) {
1095         push @{$config{defines}}, "OPENSSL_NO_DYNAMIC_ENGINE";
1096         $config{dynamic_engines} = 0;
1097 } else {
1098         push @{$config{defines}}, "OPENSSL_NO_STATIC_ENGINE";
1099         $config{dynamic_engines} = 1;
1100 }
1101
1102 unless ($disabled{"fuzz-libfuzzer"}) {
1103     $config{cflags} .= "-fsanitize-coverage=edge,indirect-calls ";
1104 }
1105
1106 unless ($disabled{asan}) {
1107     $config{cflags} .= "-fsanitize=address ";
1108 }
1109
1110 unless ($disabled{ubsan}) {
1111     # -DPEDANTIC or -fnosanitize=alignment may also be required on some
1112     # platforms.
1113     $config{cflags} .= "-fsanitize=undefined -fno-sanitize-recover=all ";
1114 }
1115
1116 unless ($disabled{msan}) {
1117   $config{cflags} .= "-fsanitize=memory ";
1118 }
1119
1120 unless ($disabled{"fuzz-libfuzzer"} && $disabled{"fuzz-afl"}
1121         && $disabled{asan} && $disabled{ubsan} && $disabled{msan}) {
1122     $config{cflags} .= "-fno-omit-frame-pointer -g ";
1123 }
1124 #
1125 # Platform fix-ups
1126 #
1127
1128 # This saves the build files from having to check
1129 if ($disabled{pic})
1130         {
1131         $target{shared_cflag} = $target{shared_ldflag} =
1132                 $target{shared_rcflag} = "";
1133         }
1134 else
1135         {
1136         push @{$config{defines}}, "OPENSSL_PIC";
1137         }
1138
1139 if ($target{sys_id} ne "")
1140         {
1141         push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
1142         }
1143
1144 unless ($disabled{asm}) {
1145     $target{cpuid_asm_src}=$table{DEFAULTS}->{cpuid_asm_src} if ($config{processor} eq "386");
1146     $target{bn_asm_src} =~ s/\w+-gf2m.c// if (defined($disabled{ec2m}));
1147
1148     # bn-586 is the only one implementing bn_*_part_words
1149     push @{$config{defines}}, "OPENSSL_BN_ASM_PART_WORDS" if ($target{bn_asm_src} =~ /bn-586/);
1150     push @{$config{defines}}, "OPENSSL_IA32_SSE2" if (!$disabled{sse2} && $target{bn_asm_src} =~ /86/);
1151
1152     push @{$config{defines}}, "OPENSSL_BN_ASM_MONT" if ($target{bn_asm_src} =~ /-mont/);
1153     push @{$config{defines}}, "OPENSSL_BN_ASM_MONT5" if ($target{bn_asm_src} =~ /-mont5/);
1154     push @{$config{defines}}, "OPENSSL_BN_ASM_GF2m" if ($target{bn_asm_src} =~ /-gf2m/);
1155
1156     if ($config{fips}) {
1157         push @{$config{openssl_other_defines}}, "OPENSSL_FIPS";
1158     }
1159
1160     if ($target{sha1_asm_src}) {
1161         push @{$config{defines}}, "SHA1_ASM"   if ($target{sha1_asm_src} =~ /sx86/ || $target{sha1_asm_src} =~ /sha1/);
1162         push @{$config{defines}}, "SHA256_ASM" if ($target{sha1_asm_src} =~ /sha256/);
1163         push @{$config{defines}}, "SHA512_ASM" if ($target{sha1_asm_src} =~ /sha512/);
1164     }
1165     if ($target{rc4_asm_src} ne $table{DEFAULTS}->{rc4_asm_src}) {
1166         push @{$config{defines}}, "RC4_ASM";
1167     }
1168     if ($target{md5_asm_src}) {
1169         push @{$config{defines}}, "MD5_ASM";
1170     }
1171     $target{cast_asm_src}=$table{DEFAULTS}->{cast_asm_src} unless $disabled{pic}; # CAST assembler is not PIC
1172     if ($target{rmd160_asm_src}) {
1173         push @{$config{defines}}, "RMD160_ASM";
1174     }
1175     if ($target{aes_asm_src}) {
1176         push @{$config{defines}}, "AES_ASM" if ($target{aes_asm_src} =~ m/\baes-/);;
1177         # aes-ctr.fake is not a real file, only indication that assembler
1178         # module implements AES_ctr32_encrypt...
1179         push @{$config{defines}}, "AES_CTR_ASM" if ($target{aes_asm_src} =~ s/\s*aes-ctr\.fake//);
1180         # aes-xts.fake indicates presence of AES_xts_[en|de]crypt...
1181         push @{$config{defines}}, "AES_XTS_ASM" if ($target{aes_asm_src} =~ s/\s*aes-xts\.fake//);
1182         $target{aes_asm_src} =~ s/\s*(vpaes|aesni)-x86\.s//g if ($disabled{sse2});
1183         push @{$config{defines}}, "VPAES_ASM" if ($target{aes_asm_src} =~ m/vpaes/);
1184         push @{$config{defines}}, "BSAES_ASM" if ($target{aes_asm_src} =~ m/bsaes/);
1185     }
1186     if ($target{wp_asm_src} =~ /mmx/) {
1187         if ($config{processor} eq "386") {
1188             $target{wp_asm_src}=$table{DEFAULTS}->{wp_asm_src};
1189         } elsif (!$disabled{"whirlpool"}) {
1190             push @{$config{defines}}, "WHIRLPOOL_ASM";
1191         }
1192     }
1193     if ($target{modes_asm_src} =~ /ghash-/) {
1194         push @{$config{defines}}, "GHASH_ASM";
1195     }
1196     if ($target{ec_asm_src} =~ /ecp_nistz256/) {
1197         push @{$config{defines}}, "ECP_NISTZ256_ASM";
1198     }
1199     if ($target{padlock_asm_src} ne $table{DEFAULTS}->{padlock_asm_src}) {
1200         push @{$config{defines}}, "PADLOCK_ASM";
1201     }
1202     if ($target{poly1305_asm_src} ne "") {
1203         push @{$config{defines}}, "POLY1305_ASM";
1204     }
1205 }
1206
1207 my %predefined;
1208
1209 if ($^O ne "VMS") {
1210     my $cc = "$config{cross_compile_prefix}$target{cc}";
1211
1212     # collect compiler pre-defines from gcc or gcc-alike...
1213     open(PIPE, "$cc -dM -E -x c /dev/null 2>&1 |");
1214     while (<PIPE>) {
1215         m/^#define\s+(\w+(?:\(\w+\))?)(?:\s+(.+))?/ or last;
1216         $predefined{$1} = $2 // "";
1217     }
1218     close(PIPE);
1219
1220     if (!$disabled{makedepend}) {
1221         # We know that GNU C version 3 and up as well as all clang
1222         # versions support dependency generation, but Xcode did not
1223         # handle $cc -M before clang support (but claims __GNUC__ = 3)
1224         if (($predefined{__GNUC__} // -1) >= 3
1225                 && !($predefined{__APPLE_CC__} && !$predefined{__clang__})) {
1226             $config{makedepprog} = $cc;
1227         } else {
1228             $config{makedepprog} = which('makedepend');
1229             $disabled{makedepend} = "unavailable" unless $config{makedepprog};
1230         }
1231     }
1232 }
1233
1234
1235
1236 # Deal with bn_ops ###################################################
1237
1238 $config{bn_ll}                  =0;
1239 $config{export_var_as_fn}       =0;
1240 my $def_int="unsigned int";
1241 $config{rc4_int}                =$def_int;
1242 ($config{b64l},$config{b64},$config{b32})=(0,0,1);
1243
1244 my $count = 0;
1245 foreach (sort split(/\s+/,$target{bn_ops})) {
1246     $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1247     $config{export_var_as_fn}=1                 if $_ eq 'EXPORT_VAR_AS_FN';
1248     $config{bn_ll}=1                            if $_ eq 'BN_LLONG';
1249     $config{rc4_int}="unsigned char"            if $_ eq 'RC4_CHAR';
1250     ($config{b64l},$config{b64},$config{b32})
1251         =(0,1,0)                                if $_ eq 'SIXTY_FOUR_BIT';
1252     ($config{b64l},$config{b64},$config{b32})
1253         =(1,0,0)                                if $_ eq 'SIXTY_FOUR_BIT_LONG';
1254     ($config{b64l},$config{b64},$config{b32})
1255         =(0,0,1)                                if $_ eq 'THIRTY_TWO_BIT';
1256 }
1257 die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1258     if $count > 1;
1259
1260
1261 # Hack cflags for better warnings (dev option) #######################
1262
1263 # "Stringify" the C flags string.  This permits it to be made part of a string
1264 # and works as well on command lines.
1265 $config{cflags} =~ s/([\\\"])/\\$1/g;
1266
1267 if (defined($config{api})) {
1268     $config{openssl_api_defines} = [ "OPENSSL_MIN_API=".$apitable->{$config{api}} ];
1269     my $apiflag = sprintf("OPENSSL_API_COMPAT=%s", $apitable->{$config{api}});
1270     push @{$config{defines}}, $apiflag;
1271 }
1272
1273 if ($strict_warnings)
1274         {
1275         my $wopt;
1276         die "ERROR --strict-warnings requires gcc or gcc-alike"
1277             unless defined($predefined{__GNUC__});
1278         foreach $wopt (split /\s+/, $gcc_devteam_warn)
1279                 {
1280                 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1281                 }
1282         if (defined($predefined{__clang__}))
1283                 {
1284                 foreach $wopt (split /\s+/, $clang_devteam_warn)
1285                         {
1286                         $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1287                         }
1288                 }
1289         }
1290
1291 unless ($disabled{"crypto-mdebug-backtrace"})
1292         {
1293         foreach my $wopt (split /\s+/, $memleak_devteam_backtrace)
1294                 {
1295                 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1296                 }
1297         if ($target =~ /^BSD-/)
1298                 {
1299                 $config{ex_libs} .= " -lexecinfo";
1300                 }
1301         }
1302
1303 if ($user_cflags ne "") { $config{cflags}="$config{cflags}$user_cflags"; }
1304 else                    { $no_user_cflags=1;  }
1305 if (@user_defines) { $config{defines}=[ @{$config{defines}}, @user_defines ]; }
1306 else               { $no_user_defines=1;    }
1307
1308 # ALL MODIFICATIONS TO %config and %target MUST BE DONE FROM HERE ON
1309
1310 unless ($disabled{afalgeng}) {
1311     $config{afalgeng}="";
1312     if ($target =~ m/^linux/) {
1313         my $minver = 4*10000 + 1*100 + 0;
1314         if ($config{cross_compile_prefix} eq "") {
1315             my $verstr = `uname -r`;
1316             my ($ma, $mi1, $mi2) = split("\\.", $verstr);
1317             ($mi2) = $mi2 =~ /(\d+)/;
1318             my $ver = $ma*10000 + $mi1*100 + $mi2;
1319             if ($ver < $minver) {
1320                 $disabled{afalgeng} = "too-old-kernel";
1321             } else {
1322                 push @{$config{engdirs}}, "afalg";
1323             }
1324         } else {
1325             $disabled{afalgeng} = "cross-compiling";
1326         }
1327     } else {
1328         $disabled{afalgeng}  = "not-linux";
1329     }
1330 }
1331
1332 push @{$config{openssl_other_defines}}, "OPENSSL_NO_AFALGENG" if ($disabled{afalgeng});
1333
1334 # If we use the unified build, collect information from build.info files
1335 my %unified_info = ();
1336
1337 my $buildinfo_debug = defined($ENV{CONFIGURE_DEBUG_BUILDINFO});
1338 if ($builder eq "unified") {
1339     use with_fallback qw(Text::Template);
1340
1341     sub cleandir {
1342         my $base = shift;
1343         my $dir = shift;
1344         my $relativeto = shift || ".";
1345
1346         $dir = catdir($base,$dir) unless isabsolute($dir);
1347
1348         # Make sure the directories we're building in exists
1349         mkpath($dir);
1350
1351         my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
1352         #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1353         return $res;
1354     }
1355
1356     sub cleanfile {
1357         my $base = shift;
1358         my $file = shift;
1359         my $relativeto = shift || ".";
1360
1361         $file = catfile($base,$file) unless isabsolute($file);
1362
1363         my $d = dirname($file);
1364         my $f = basename($file);
1365
1366         # Make sure the directories we're building in exists
1367         mkpath($d);
1368
1369         my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
1370         #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1371         return $res;
1372     }
1373
1374     # Store the name of the template file we will build the build file from
1375     # in %config.  This may be useful for the build file itself.
1376     my @build_file_template_names =
1377         ( $builder_platform."-".$target{build_file}.".tmpl",
1378           $target{build_file}.".tmpl" );
1379     my @build_file_templates = ();
1380
1381     # First, look in the user provided directory, if given
1382     if (defined $ENV{$local_config_envname}) {
1383         @build_file_templates =
1384             map {
1385                 if ($^O eq 'VMS') {
1386                     # VMS environment variables are logical names,
1387                     # which can be used as is
1388                     $local_config_envname . ':' . $_;
1389                 } else {
1390                     catfile($ENV{$local_config_envname}, $_);
1391                 }
1392             }
1393             @build_file_template_names;
1394     }
1395     # Then, look in our standard directory
1396     push @build_file_templates,
1397         ( map { cleanfile($srcdir, catfile("Configurations", $_), $blddir) }
1398           @build_file_template_names );
1399
1400     my $build_file_template;
1401     for $_ (@build_file_templates) {
1402         $build_file_template = $_;
1403         last if -f $build_file_template;
1404
1405         $build_file_template = undef;
1406     }
1407     if (!defined $build_file_template) {
1408         die "*** Couldn't find any of:\n", join("\n", @build_file_templates), "\n";
1409     }
1410     $config{build_file_templates}
1411       = [ $build_file_template,
1412           cleanfile($srcdir, catfile("Configurations", "common.tmpl"),
1413                     $blddir) ];
1414
1415     my @build_infos = ( [ ".", "build.info" ] );
1416     foreach (@{$config{dirs}}) {
1417         push @build_infos, [ $_, "build.info" ]
1418             if (-f catfile($srcdir, $_, "build.info"));
1419     }
1420     foreach (@{$config{sdirs}}) {
1421         push @build_infos, [ catdir("crypto", $_), "build.info" ]
1422             if (-f catfile($srcdir, "crypto", $_, "build.info"));
1423     }
1424     foreach (@{$config{engdirs}}) {
1425         push @build_infos, [ catdir("engines", $_), "build.info" ]
1426             if (-f catfile($srcdir, "engines", $_, "build.info"));
1427     }
1428
1429     $config{build_infos} = [ ];
1430
1431     foreach (@build_infos) {
1432         my $sourced = catdir($srcdir, $_->[0]);
1433         my $buildd = catdir($blddir, $_->[0]);
1434
1435         mkpath($buildd);
1436
1437         my $f = $_->[1];
1438         # The basic things we're trying to build
1439         my @programs = ();
1440         my @programs_install = ();
1441         my @libraries = ();
1442         my @libraries_install = ();
1443         my @engines = ();
1444         my @engines_install = ();
1445         my @scripts = ();
1446         my @scripts_install = ();
1447         my @extra = ();
1448         my @overrides = ();
1449         my @intermediates = ();
1450         my @rawlines = ();
1451
1452         my %ordinals = ();
1453         my %sources = ();
1454         my %shared_sources = ();
1455         my %includes = ();
1456         my %depends = ();
1457         my %renames = ();
1458         my %sharednames = ();
1459         my %generate = ();
1460
1461         # We want to detect configdata.pm in the source tree, so we
1462         # don't use it if the build tree is different.
1463         my $src_configdata = cleanfile($srcdir, "configdata.pm", $blddir);
1464
1465         push @{$config{build_infos}}, catfile(abs2rel($sourced, $blddir), $f);
1466         my $template =
1467             Text::Template->new(TYPE => 'FILE',
1468                                 SOURCE => catfile($sourced, $f),
1469                                 PREPEND => qq{use lib "$FindBin::Bin/util/perl";});
1470         die "Something went wrong with $sourced/$f: $!\n" unless $template;
1471         my @text =
1472             split /^/m,
1473             $template->fill_in(HASH => { config => \%config,
1474                                          target => \%target,
1475                                          disabled => \%disabled,
1476                                          withargs => \%withargs,
1477                                          builddir => abs2rel($buildd, $blddir),
1478                                          sourcedir => abs2rel($sourced, $blddir),
1479                                          buildtop => abs2rel($blddir, $blddir),
1480                                          sourcetop => abs2rel($srcdir, $blddir) },
1481                                DELIMITERS => [ "{-", "-}" ]);
1482
1483         # The top item of this stack has the following values
1484         # -2 positive already run and we found ELSE (following ELSIF should fail)
1485         # -1 positive already run (skip until ENDIF)
1486         # 0 negatives so far (if we're at a condition, check it)
1487         # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
1488         # 2 positive ELSE (following ELSIF should fail)
1489         my @skip = ();
1490         collect_information(
1491             collect_from_array([ @text ],
1492                                qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
1493                                                 $l1 =~ s/\\$//; $l1.$l2 }),
1494             # Info we're looking for
1495             qr/^\s*IF\[((?:\\.|[^\\\]])*)\]\s*$/
1496             => sub {
1497                 if (! @skip || $skip[$#skip] > 0) {
1498                     push @skip, !! $1;
1499                 } else {
1500                     push @skip, -1;
1501                 }
1502             },
1503             qr/^\s*ELSIF\[((?:\\.|[^\\\]])*)\]\s*$/
1504             => sub { die "ELSIF out of scope" if ! @skip;
1505                      die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
1506                      $skip[$#skip] = -1 if $skip[$#skip] != 0;
1507                      $skip[$#skip] = !! $1
1508                          if $skip[$#skip] == 0; },
1509             qr/^\s*ELSE\s*$/
1510             => sub { die "ELSE out of scope" if ! @skip;
1511                      $skip[$#skip] = -2 if $skip[$#skip] != 0;
1512                      $skip[$#skip] = 2 if $skip[$#skip] == 0; },
1513             qr/^\s*ENDIF\s*$/
1514             => sub { die "ENDIF out of scope" if ! @skip;
1515                      pop @skip; },
1516             qr/^\s*PROGRAMS(_NO_INST)?\s*=\s*(.*)\s*$/
1517             => sub {
1518                 if (!@skip || $skip[$#skip] > 0) {
1519                     my $install = $1;
1520                     my @x = tokenize($2);
1521                     push @programs, @x;
1522                     push @programs_install, @x unless $install;
1523                 }
1524             },
1525             qr/^\s*LIBS(_NO_INST)?\s*=\s*(.*)\s*$/
1526             => sub {
1527                 if (!@skip || $skip[$#skip] > 0) {
1528                     my $install = $1;
1529                     my @x = tokenize($2);
1530                     push @libraries, @x;
1531                     push @libraries_install, @x unless $install;
1532                 }
1533             },
1534             qr/^\s*ENGINES(_NO_INST)?\s*=\s*(.*)\s*$/
1535             => sub {
1536                 if (!@skip || $skip[$#skip] > 0) {
1537                     my $install = $1;
1538                     my @x = tokenize($2);
1539                     push @engines, @x;
1540                     push @engines_install, @x unless $install;
1541                 }
1542             },
1543             qr/^\s*SCRIPTS(_NO_INST)?\s*=\s*(.*)\s*$/
1544             => sub {
1545                 if (!@skip || $skip[$#skip] > 0) {
1546                     my $install = $1;
1547                     my @x = tokenize($2);
1548                     push @scripts, @x;
1549                     push @scripts_install, @x unless $install;
1550                 }
1551             },
1552             qr/^\s*EXTRA\s*=\s*(.*)\s*$/
1553             => sub { push @extra, tokenize($1)
1554                          if !@skip || $skip[$#skip] > 0 },
1555             qr/^\s*OVERRIDES\s*=\s*(.*)\s*$/
1556             => sub { push @overrides, tokenize($1)
1557                          if !@skip || $skip[$#skip] > 0 },
1558
1559             qr/^\s*ORDINALS\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/,
1560             => sub { push @{$ordinals{$1}}, tokenize($2)
1561                          if !@skip || $skip[$#skip] > 0 },
1562             qr/^\s*SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1563             => sub { push @{$sources{$1}}, tokenize($2)
1564                          if !@skip || $skip[$#skip] > 0 },
1565             qr/^\s*SHARED_SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1566             => sub { push @{$shared_sources{$1}}, tokenize($2)
1567                          if !@skip || $skip[$#skip] > 0 },
1568             qr/^\s*INCLUDE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1569             => sub { push @{$includes{$1}}, tokenize($2)
1570                          if !@skip || $skip[$#skip] > 0 },
1571             qr/^\s*DEPEND\[((?:\\.|[^\\\]])*)\]\s*=\s*(.*)\s*$/
1572             => sub { push @{$depends{$1}}, tokenize($2)
1573                          if !@skip || $skip[$#skip] > 0 },
1574             qr/^\s*GENERATE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1575             => sub { push @{$generate{$1}}, $2
1576                          if !@skip || $skip[$#skip] > 0 },
1577             qr/^\s*RENAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1578             => sub { push @{$renames{$1}}, tokenize($2)
1579                          if !@skip || $skip[$#skip] > 0 },
1580             qr/^\s*SHARED_NAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1581             => sub { push @{$sharednames{$1}}, tokenize($2)
1582                          if !@skip || $skip[$#skip] > 0 },
1583             qr/^\s*BEGINRAW\[((?:\\.|[^\\\]])+)\]\s*$/
1584             => sub {
1585                 my $lineiterator = shift;
1586                 my $target_kind = $1;
1587                 while (defined $lineiterator->()) {
1588                     s|\R$||;
1589                     if (/^\s*ENDRAW\[((?:\\.|[^\\\]])+)\]\s*$/) {
1590                         die "ENDRAW doesn't match BEGINRAW"
1591                             if $1 ne $target_kind;
1592                         last;
1593                     }
1594                     next if @skip && $skip[$#skip] <= 0;
1595                     push @rawlines,  $_
1596                         if ($target_kind eq $target{build_file}
1597                             || $target_kind eq $target{build_file}."(".$builder_platform.")");
1598                 }
1599             },
1600             qr/^(?:#.*|\s*)$/ => sub { },
1601             "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" },
1602             "BEFORE" => sub {
1603                 if ($buildinfo_debug) {
1604                     print STDERR "DEBUG: Parsing ",join(" ", @_),"\n";
1605                     print STDERR "DEBUG: ... before parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1606                 }
1607             },
1608             "AFTER" => sub {
1609                 if ($buildinfo_debug) {
1610                     print STDERR "DEBUG: .... after parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1611                 }
1612             },
1613             );
1614         die "runaway IF?" if (@skip);
1615
1616         foreach (keys %renames) {
1617             die "$_ renamed to more than one thing: "
1618                 ,join(" ", @{$renames{$_}}),"\n"
1619                 if scalar @{$renames{$_}} > 1;
1620             my $dest = cleanfile($buildd, $_, $blddir);
1621             my $to = cleanfile($buildd, $renames{$_}->[0], $blddir);
1622             die "$dest renamed to more than one thing: "
1623                 ,$unified_info{rename}->{$dest}, $to
1624                 unless !defined($unified_info{rename}->{$dest})
1625                 or $unified_info{rename}->{$dest} eq $to;
1626             $unified_info{rename}->{$dest} = $to;
1627         }
1628
1629         foreach (@programs) {
1630             my $program = cleanfile($buildd, $_, $blddir);
1631             if ($unified_info{rename}->{$program}) {
1632                 $program = $unified_info{rename}->{$program};
1633             }
1634             $unified_info{programs}->{$program} = 1;
1635         }
1636
1637         foreach (@programs_install) {
1638             my $program = cleanfile($buildd, $_, $blddir);
1639             if ($unified_info{rename}->{$program}) {
1640                 $program = $unified_info{rename}->{$program};
1641             }
1642             $unified_info{install}->{programs}->{$program} = 1;
1643         }
1644
1645         foreach (@libraries) {
1646             my $library = cleanfile($buildd, $_, $blddir);
1647             if ($unified_info{rename}->{$library}) {
1648                 $library = $unified_info{rename}->{$library};
1649             }
1650             $unified_info{libraries}->{$library} = 1;
1651         }
1652
1653         foreach (@libraries_install) {
1654             my $library = cleanfile($buildd, $_, $blddir);
1655             if ($unified_info{rename}->{$library}) {
1656                 $library = $unified_info{rename}->{$library};
1657             }
1658             $unified_info{install}->{libraries}->{$library} = 1;
1659         }
1660
1661         die <<"EOF" if scalar @engines and !$config{dynamic_engines};
1662 ENGINES can only be used if configured with 'dynamic-engine'.
1663 This is usually a fault in a build.info file.
1664 EOF
1665         foreach (@engines) {
1666             my $library = cleanfile($buildd, $_, $blddir);
1667             if ($unified_info{rename}->{$library}) {
1668                 $library = $unified_info{rename}->{$library};
1669             }
1670             $unified_info{engines}->{$library} = 1;
1671         }
1672
1673         foreach (@engines_install) {
1674             my $library = cleanfile($buildd, $_, $blddir);
1675             if ($unified_info{rename}->{$library}) {
1676                 $library = $unified_info{rename}->{$library};
1677             }
1678             $unified_info{install}->{engines}->{$library} = 1;
1679         }
1680
1681         foreach (@scripts) {
1682             my $script = cleanfile($buildd, $_, $blddir);
1683             if ($unified_info{rename}->{$script}) {
1684                 $script = $unified_info{rename}->{$script};
1685             }
1686             $unified_info{scripts}->{$script} = 1;
1687         }
1688
1689         foreach (@scripts_install) {
1690             my $script = cleanfile($buildd, $_, $blddir);
1691             if ($unified_info{rename}->{$script}) {
1692                 $script = $unified_info{rename}->{$script};
1693             }
1694             $unified_info{install}->{scripts}->{$script} = 1;
1695         }
1696
1697         foreach (@extra) {
1698             my $extra = cleanfile($buildd, $_, $blddir);
1699             $unified_info{extra}->{$extra} = 1;
1700         }
1701
1702         foreach (@overrides) {
1703             my $override = cleanfile($buildd, $_, $blddir);
1704             $unified_info{overrides}->{$override} = 1;
1705         }
1706
1707         push @{$unified_info{rawlines}}, @rawlines;
1708
1709         unless ($disabled{shared}) {
1710             # Check sharednames.
1711             foreach (keys %sharednames) {
1712                 my $dest = cleanfile($buildd, $_, $blddir);
1713                 if ($unified_info{rename}->{$dest}) {
1714                     $dest = $unified_info{rename}->{$dest};
1715                 }
1716                 die "shared_name for $dest with multiple values: "
1717                     ,join(" ", @{$sharednames{$_}}),"\n"
1718                     if scalar @{$sharednames{$_}} > 1;
1719                 my $to = cleanfile($buildd, $sharednames{$_}->[0], $blddir);
1720                 die "shared_name found for a library $dest that isn't defined\n"
1721                     unless $unified_info{libraries}->{$dest};
1722                 die "shared_name for $dest with multiple values: "
1723                     ,$unified_info{sharednames}->{$dest}, ", ", $to
1724                     unless !defined($unified_info{sharednames}->{$dest})
1725                     or $unified_info{sharednames}->{$dest} eq $to;
1726                 $unified_info{sharednames}->{$dest} = $to;
1727             }
1728
1729             # Additionally, we set up sharednames for libraries that don't
1730             # have any, as themselves.
1731             foreach (keys %{$unified_info{libraries}}) {
1732                 if (!defined $unified_info{sharednames}->{$_}) {
1733                     $unified_info{sharednames}->{$_} = $_
1734                 }
1735             }
1736         }
1737
1738         foreach (keys %ordinals) {
1739             my $dest = $_;
1740             my $ddest = cleanfile($buildd, $_, $blddir);
1741             if ($unified_info{rename}->{$ddest}) {
1742                 $ddest = $unified_info{rename}->{$ddest};
1743             }
1744             foreach (@{$ordinals{$dest}}) {
1745                 my %known_ordinals =
1746                     (
1747                      crypto =>
1748                      cleanfile($sourced, catfile("util", "libcrypto.num"), $blddir),
1749                      ssl =>
1750                      cleanfile($sourced, catfile("util", "libssl.num"), $blddir)
1751                     );
1752                 my $o = $known_ordinals{$_};
1753                 die "Ordinals for $ddest defined more than once\n"
1754                     if $unified_info{ordinals}->{$ddest};
1755                 $unified_info{ordinals}->{$ddest} = [ $_, $o ];
1756             }
1757         }
1758
1759         foreach (keys %sources) {
1760             my $dest = $_;
1761             my $ddest = cleanfile($buildd, $_, $blddir);
1762             if ($unified_info{rename}->{$ddest}) {
1763                 $ddest = $unified_info{rename}->{$ddest};
1764             }
1765             foreach (@{$sources{$dest}}) {
1766                 my $s = cleanfile($sourced, $_, $blddir);
1767
1768                 # If it isn't in the source tree, we assume it's generated
1769                 # in the build tree
1770                 if ($s eq $src_configdata || ! -f $s || $generate{$_}) {
1771                     $s = cleanfile($buildd, $_, $blddir);
1772                 }
1773                 # We recognise C and asm files
1774                 if ($s =~ /\.[csS]\b$/) {
1775                     (my $o = $_) =~ s/\.[csS]\b$/.o/;
1776                     $o = cleanfile($buildd, $o, $blddir);
1777                     $unified_info{sources}->{$ddest}->{$o} = 1;
1778                     $unified_info{sources}->{$o}->{$s} = 1;
1779                 } else {
1780                     $unified_info{sources}->{$ddest}->{$s} = 1;
1781                 }
1782             }
1783         }
1784
1785         foreach (keys %shared_sources) {
1786             my $dest = $_;
1787             my $ddest = cleanfile($buildd, $_, $blddir);
1788             if ($unified_info{rename}->{$ddest}) {
1789                 $ddest = $unified_info{rename}->{$ddest};
1790             }
1791             foreach (@{$shared_sources{$dest}}) {
1792                 my $s = cleanfile($sourced, $_, $blddir);
1793
1794                 # If it isn't in the source tree, we assume it's generated
1795                 # in the build tree
1796                 if ($s eq $src_configdata || ! -f $s || $generate{$_}) {
1797                     $s = cleanfile($buildd, $_, $blddir);
1798                 }
1799                 # We recognise C and asm files
1800                 if ($s =~ /\.[csS]\b$/) {
1801                     (my $o = $_) =~ s/\.[csS]\b$/.o/;
1802                     $o = cleanfile($buildd, $o, $blddir);
1803                     $unified_info{shared_sources}->{$ddest}->{$o} = 1;
1804                     $unified_info{sources}->{$o}->{$s} = 1;
1805                 } else {
1806                     die "unrecognised source file type for shared library: $s\n";
1807                 }
1808             }
1809         }
1810
1811         foreach (keys %generate) {
1812             my $dest = $_;
1813             my $ddest = cleanfile($buildd, $_, $blddir);
1814             if ($unified_info{rename}->{$ddest}) {
1815                 $ddest = $unified_info{rename}->{$ddest};
1816             }
1817             die "more than one generator for $dest: "
1818                     ,join(" ", @{$generate{$_}}),"\n"
1819                     if scalar @{$generate{$_}} > 1;
1820             my @generator = split /\s+/, $generate{$dest}->[0];
1821             $generator[0] = cleanfile($sourced, $generator[0], $blddir),
1822             $unified_info{generate}->{$ddest} = [ @generator ];
1823         }
1824
1825         foreach (keys %depends) {
1826             my $dest = $_;
1827             my $ddest = $dest eq "" ? "" : cleanfile($sourced, $_, $blddir);
1828
1829             # If the destination doesn't exist in source, it can only be
1830             # a generated file in the build tree.
1831             if ($ddest ne "" && ($ddest eq $src_configdata || ! -f $ddest)) {
1832                 $ddest = cleanfile($buildd, $_, $blddir);
1833                 if ($unified_info{rename}->{$ddest}) {
1834                     $ddest = $unified_info{rename}->{$ddest};
1835                 }
1836             }
1837             foreach (@{$depends{$dest}}) {
1838                 my $d = cleanfile($sourced, $_, $blddir);
1839
1840                 # If we know it's generated, or assume it is because we can't
1841                 # find it in the source tree, we set file we depend on to be
1842                 # in the build tree rather than the source tree, and assume
1843                 # and that there are lines to build it in a BEGINRAW..ENDRAW
1844                 # section or in the Makefile template.
1845                 if ($d eq $src_configdata
1846                     || ! -f $d
1847                     || (grep { $d eq $_ }
1848                         map { cleanfile($srcdir, $_, $blddir) }
1849                         grep { /\.h$/ } keys %{$unified_info{generate}})) {
1850                     $d = cleanfile($buildd, $_, $blddir);
1851                 }
1852                 # Take note if the file to depend on is being renamed
1853                 if ($unified_info{rename}->{$d}) {
1854                     $d = $unified_info{rename}->{$d};
1855                 }
1856                 $unified_info{depends}->{$ddest}->{$d} = 1;
1857             }
1858         }
1859
1860         foreach (keys %includes) {
1861             my $dest = $_;
1862             my $ddest = cleanfile($sourced, $_, $blddir);
1863
1864             # If the destination doesn't exist in source, it can only be
1865             # a generated file in the build tree.
1866             if ($ddest eq $src_configdata || ! -f $ddest) {
1867                 $ddest = cleanfile($buildd, $_, $blddir);
1868                 if ($unified_info{rename}->{$ddest}) {
1869                     $ddest = $unified_info{rename}->{$ddest};
1870                 }
1871             }
1872             foreach (@{$includes{$dest}}) {
1873                 my $is = cleandir($sourced, $_, $blddir);
1874                 my $ib = cleandir($buildd, $_, $blddir);
1875                 push @{$unified_info{includes}->{$ddest}->{source}}, $is
1876                     unless grep { $_ eq $is } @{$unified_info{includes}->{$ddest}->{source}};
1877                 push @{$unified_info{includes}->{$ddest}->{build}}, $ib
1878                     unless grep { $_ eq $ib } @{$unified_info{includes}->{$ddest}->{build}};
1879             }
1880         }
1881     }
1882
1883     # Massage the result
1884
1885     # If we depend on a header file or a perl module, add an inclusion of
1886     # its directory to allow smoothe inclusion
1887     foreach my $dest (keys %{$unified_info{depends}}) {
1888         next if $dest eq "";
1889         foreach my $d (keys %{$unified_info{depends}->{$dest}}) {
1890             next unless $d =~ /\.(h|pm)$/;
1891             my $i = dirname($d);
1892             my $spot =
1893                 $d eq "configdata.pm" || defined($unified_info{generate}->{$d})
1894                 ? 'build' : 'source';
1895             push @{$unified_info{includes}->{$dest}->{$spot}}, $i
1896                 unless grep { $_ eq $i } @{$unified_info{includes}->{$dest}->{$spot}};
1897         }
1898     }
1899
1900     # Trickle down includes placed on libraries, engines and programs to
1901     # their sources (i.e. object files)
1902     foreach my $dest (keys %{$unified_info{engines}},
1903                       keys %{$unified_info{libraries}},
1904                       keys %{$unified_info{programs}}) {
1905         foreach my $k (("source", "build")) {
1906             next unless defined($unified_info{includes}->{$dest}->{$k});
1907             my @incs = reverse @{$unified_info{includes}->{$dest}->{$k}};
1908             foreach my $obj (grep /\.o$/,
1909                              (keys %{$unified_info{sources}->{$dest}},
1910                               keys %{$unified_info{shared_sources}->{$dest}})) {
1911                 foreach my $inc (@incs) {
1912                     unshift @{$unified_info{includes}->{$obj}->{$k}}, $inc
1913                         unless grep { $_ eq $inc } @{$unified_info{includes}->{$obj}->{$k}};
1914                 }
1915             }
1916         }
1917         delete $unified_info{includes}->{$dest};
1918     }
1919
1920     ### Make unified_info a bit more efficient
1921     # One level structures
1922     foreach (("programs", "libraries", "engines", "scripts", "extra", "overrides")) {
1923         $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
1924     }
1925     # Two level structures
1926     foreach my $l1 (("install", "sources", "shared_sources", "ldadd", "depends")) {
1927         foreach my $l2 (sort keys %{$unified_info{$l1}}) {
1928             $unified_info{$l1}->{$l2} =
1929                 [ sort keys %{$unified_info{$l1}->{$l2}} ];
1930         }
1931     }
1932     # Includes
1933     foreach my $dest (sort keys %{$unified_info{includes}}) {
1934         if (defined($unified_info{includes}->{$dest}->{build})) {
1935             my @source_includes = ();
1936             @source_includes = ( @{$unified_info{includes}->{$dest}->{source}} )
1937                 if defined($unified_info{includes}->{$dest}->{source});
1938             $unified_info{includes}->{$dest} =
1939                 [ @{$unified_info{includes}->{$dest}->{build}} ];
1940             foreach my $inc (@source_includes) {
1941                 push @{$unified_info{includes}->{$dest}}, $inc
1942                     unless grep { $_ eq $inc } @{$unified_info{includes}->{$dest}};
1943             }
1944         } else {
1945             $unified_info{includes}->{$dest} =
1946                 [ @{$unified_info{includes}->{$dest}->{source}} ];
1947         }
1948     }
1949 }
1950
1951 # For the schemes that need it, we provide the old *_obj configs
1952 # from the *_asm_obj ones
1953 foreach (grep /_(asm|aux)_src$/, keys %target) {
1954     my $src = $_;
1955     (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
1956     ($target{$obj} = $target{$src}) =~ s/\.[csS]\b/.o/g;
1957 }
1958
1959 # Write down our configuration where it fits #########################
1960
1961 open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
1962 print OUT <<"EOF";
1963 package configdata;
1964
1965 use strict;
1966 use warnings;
1967
1968 use Exporter;
1969 #use vars qw(\@ISA \@EXPORT);
1970 our \@ISA = qw(Exporter);
1971 our \@EXPORT = qw(\%config \%target \%disabled \%withargs \%unified_info \@disablables);
1972
1973 EOF
1974 print OUT "our %config = (\n";
1975 foreach (sort keys %config) {
1976     if (ref($config{$_}) eq "ARRAY") {
1977         print OUT "  ", $_, " => [ ", join(", ",
1978                                            map { quotify("perl", $_) }
1979                                            @{$config{$_}}), " ],\n";
1980     } else {
1981         print OUT "  ", $_, " => ", quotify("perl", $config{$_}), ",\n"
1982     }
1983 }
1984 print OUT <<"EOF";
1985 );
1986
1987 EOF
1988 print OUT "our %target = (\n";
1989 foreach (sort keys %target) {
1990     if (ref($target{$_}) eq "ARRAY") {
1991         print OUT "  ", $_, " => [ ", join(", ",
1992                                            map { quotify("perl", $_) }
1993                                            @{$target{$_}}), " ],\n";
1994     } else {
1995         print OUT "  ", $_, " => ", quotify("perl", $target{$_}), ",\n"
1996     }
1997 }
1998 print OUT <<"EOF";
1999 );
2000
2001 EOF
2002 print OUT "our \%available_protocols = (\n";
2003 print OUT "  tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n";
2004 print OUT "  dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n";
2005 print OUT <<"EOF";
2006 );
2007
2008 EOF
2009 print OUT "our \@disablables = (\n";
2010 foreach (@disablables) {
2011     print OUT "  ", quotify("perl", $_), ",\n";
2012 }
2013 print OUT <<"EOF";
2014 );
2015
2016 EOF
2017 print OUT "our \%disabled = (\n";
2018 foreach (sort keys %disabled) {
2019     print OUT "  ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n";
2020 }
2021 print OUT <<"EOF";
2022 );
2023
2024 EOF
2025 print OUT "our %withargs = (\n";
2026 foreach (sort keys %withargs) {
2027     if (ref($withargs{$_}) eq "ARRAY") {
2028         print OUT "  ", $_, " => [ ", join(", ",
2029                                            map { quotify("perl", $_) }
2030                                            @{$withargs{$_}}), " ],\n";
2031     } else {
2032         print OUT "  ", $_, " => ", quotify("perl", $withargs{$_}), ",\n"
2033     }
2034 }
2035 print OUT <<"EOF";
2036 );
2037
2038 EOF
2039 if ($builder eq "unified") {
2040     my $recurse;
2041     $recurse = sub {
2042         my $indent = shift;
2043         foreach (@_) {
2044             if (ref $_ eq "ARRAY") {
2045                 print OUT " "x$indent, "[\n";
2046                 foreach (@$_) {
2047                     $recurse->($indent + 4, $_);
2048                 }
2049                 print OUT " "x$indent, "],\n";
2050             } elsif (ref $_ eq "HASH") {
2051                 my %h = %$_;
2052                 print OUT " "x$indent, "{\n";
2053                 foreach (sort keys %h) {
2054                     if (ref $h{$_} eq "") {
2055                         print OUT " "x($indent + 4), quotify("perl", $_), " => ", quotify("perl", $h{$_}), ",\n";
2056                     } else {
2057                         print OUT " "x($indent + 4), quotify("perl", $_), " =>\n";
2058                         $recurse->($indent + 8, $h{$_});
2059                     }
2060                 }
2061                 print OUT " "x$indent, "},\n";
2062             } else {
2063                 print OUT " "x$indent, quotify("perl", $_), ",\n";
2064             }
2065         }
2066     };
2067     print OUT "our %unified_info = (\n";
2068     foreach (sort keys %unified_info) {
2069         if (ref $unified_info{$_} eq "") {
2070             print OUT " "x4, quotify("perl", $_), " => ", quotify("perl", $unified_info{$_}), ",\n";
2071         } else {
2072             print OUT " "x4, quotify("perl", $_), " =>\n";
2073             $recurse->(8, $unified_info{$_});
2074         }
2075     }
2076     print OUT <<"EOF";
2077 );
2078
2079 EOF
2080 }
2081 print OUT "1;\n";
2082 close(OUT);
2083
2084
2085 print "CC            =$config{cross_compile_prefix}$target{cc}\n";
2086 print "CFLAG         =$target{cflags} $config{cflags}\n";
2087 print "SHARED_CFLAG  =$target{shared_cflag}\n";
2088 print "DEFINES       =",join(" ", @{$target{defines}}, @{$config{defines}}),"\n";
2089 print "LFLAG         =$target{lflags}\n";
2090 print "PLIB_LFLAG    =$target{plib_lflags}\n";
2091 print "EX_LIBS       =$target{ex_libs} $config{ex_libs}\n";
2092 print "APPS_OBJ      =$target{apps_obj}\n";
2093 print "CPUID_OBJ     =$target{cpuid_obj}\n";
2094 print "UPLINK_OBJ    =$target{uplink_obj}\n";
2095 print "BN_ASM        =$target{bn_obj}\n";
2096 print "EC_ASM        =$target{ec_obj}\n";
2097 print "DES_ENC       =$target{des_obj}\n";
2098 print "AES_ENC       =$target{aes_obj}\n";
2099 print "BF_ENC        =$target{bf_obj}\n";
2100 print "CAST_ENC      =$target{cast_obj}\n";
2101 print "RC4_ENC       =$target{rc4_obj}\n";
2102 print "RC5_ENC       =$target{rc5_obj}\n";
2103 print "MD5_OBJ_ASM   =$target{md5_obj}\n";
2104 print "SHA1_OBJ_ASM  =$target{sha1_obj}\n";
2105 print "RMD160_OBJ_ASM=$target{rmd160_obj}\n";
2106 print "CMLL_ENC      =$target{cmll_obj}\n";
2107 print "MODES_OBJ     =$target{modes_obj}\n";
2108 print "PADLOCK_OBJ   =$target{padlock_obj}\n";
2109 print "CHACHA_ENC    =$target{chacha_obj}\n";
2110 print "POLY1305_OBJ  =$target{poly1305_obj}\n";
2111 print "BLAKE2_OBJ    =$target{blake2_obj}\n";
2112 print "PROCESSOR     =$config{processor}\n";
2113 print "RANLIB        =", $target{ranlib} eq '$(CROSS_COMPILE)ranlib' ?
2114                              "$config{cross_compile_prefix}ranlib" :
2115                              "$target{ranlib}", "\n";
2116 print "ARFLAGS       =$target{arflags}\n";
2117 print "PERL          =$config{perl}\n";
2118 print "\n";
2119 print "SIXTY_FOUR_BIT_LONG mode\n" if $config{b64l};
2120 print "SIXTY_FOUR_BIT mode\n" if $config{b64};
2121 print "THIRTY_TWO_BIT mode\n" if $config{b32};
2122 print "BN_LLONG mode\n" if $config{bn_ll};
2123 print "RC4 uses $config{rc4_int}\n" if $config{rc4_int} ne $def_int;
2124
2125 my %builders = (
2126     unified => sub {
2127         run_dofile(catfile($blddir, $target{build_file}),
2128                    @{$config{build_file_templates}});
2129     },
2130     );
2131
2132 $builders{$builder}->($builder_platform, @builder_opts);
2133
2134 $SIG{__DIE__} = $orig_death_handler;
2135
2136 print <<"EOF";
2137
2138 Configured for $target.
2139 EOF
2140
2141 print <<"EOF" if ($disabled{threads} eq "unavailable");
2142
2143 The library could not be configured for supporting multi-threaded
2144 applications as the compiler options required on this system are not known.
2145 See file INSTALL for details if you need multi-threading.
2146 EOF
2147
2148 print <<"EOF" if ($no_shared_warn);
2149
2150 The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
2151 platform, so we will pretend you gave the option 'no-pic', which also disables
2152 'shared' and 'dynamic-engine'.  If you know how to implement shared libraries
2153 or position independent code, please let us know (but please first make sure
2154 you have tried with a current version of OpenSSL).
2155 EOF
2156
2157 exit(0);
2158
2159 ######################################################################
2160 #
2161 # Helpers and utility functions
2162 #
2163
2164 # Death handler, to print a helpful message in case of failure #######
2165 #
2166 sub death_handler {
2167     die @_ if $^S;              # To prevent the added message in eval blocks
2168     my $build_file = $target{build_file} // "build file";
2169     my @message = ( <<"_____", @_ );
2170
2171 Failure!  $build_file wasn't produced.
2172 Please read INSTALL and associated NOTES files.  You may also have to look over
2173 your available compiler tool chain or change your configuration.
2174
2175 _____
2176
2177     # Dying is terminal, so it's ok to reset the signal handler here.
2178     $SIG{__DIE__} = $orig_death_handler;
2179     die @message;
2180 }
2181
2182 # Configuration file reading #########################################
2183
2184 # Note: All of the helper functions are for lazy evaluation.  They all
2185 # return a CODE ref, which will return the intended value when evaluated.
2186 # Thus, whenever there's mention of a returned value, it's about that
2187 # intended value.
2188
2189 # Helper function to implement conditional inheritance depending on the
2190 # value of $disabled{asm}.  Used in inherit_from values as follows:
2191 #
2192 #      inherit_from => [ "template", asm("asm_tmpl") ]
2193 #
2194 sub asm {
2195     my @x = @_;
2196     sub {
2197         $disabled{asm} ? () : @x;
2198     }
2199 }
2200
2201 # Helper function to implement conditional value variants, with a default
2202 # plus additional values based on the value of $config{build_type}.
2203 # Arguments are given in hash table form:
2204 #
2205 #       picker(default => "Basic string: ",
2206 #              debug   => "debug",
2207 #              release => "release")
2208 #
2209 # When configuring with --debug, the resulting string will be
2210 # "Basic string: debug", and when not, it will be "Basic string: release"
2211 #
2212 # This can be used to create variants of sets of flags according to the
2213 # build type:
2214 #
2215 #       cflags => picker(default => "-Wall",
2216 #                        debug   => "-g -O0",
2217 #                        release => "-O3")
2218 #
2219 sub picker {
2220     my %opts = @_;
2221     return sub { add($opts{default} || (),
2222                      $opts{$config{build_type}} || ())->(); }
2223 }
2224
2225 # Helper function to combine several values of different types into one.
2226 # This is useful if you want to combine a string with the result of a
2227 # lazy function, such as:
2228 #
2229 #       cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
2230 #
2231 sub combine {
2232     my @stuff = @_;
2233     return sub { add(@stuff)->(); }
2234 }
2235
2236 # Helper function to implement conditional values depending on the value
2237 # of $disabled{threads}.  Can be used as follows:
2238 #
2239 #       cflags => combine("-Wall", threads("-pthread"))
2240 #
2241 sub threads {
2242     my @flags = @_;
2243     return sub { add($disabled{threads} ? () : @flags)->(); }
2244 }
2245
2246
2247
2248 our $add_called = 0;
2249 # Helper function to implement adding values to already existing configuration
2250 # values.  It handles elements that are ARRAYs, CODEs and scalars
2251 sub _add {
2252     my $separator = shift;
2253
2254     # If there's any ARRAY in the collection of values OR the separator
2255     # is undef, we will return an ARRAY of combined values, otherwise a
2256     # string of joined values with $separator as the separator.
2257     my $found_array = !defined($separator);
2258
2259     my @values =
2260         map {
2261             my $res = $_;
2262             while (ref($res) eq "CODE") {
2263                 $res = $res->();
2264             }
2265             if (defined($res)) {
2266                 if (ref($res) eq "ARRAY") {
2267                     $found_array = 1;
2268                     @$res;
2269                 } else {
2270                     $res;
2271                 }
2272             } else {
2273                 ();
2274             }
2275     } (@_);
2276
2277     $add_called = 1;
2278
2279     if ($found_array) {
2280         [ @values ];
2281     } else {
2282         join($separator, grep { defined($_) && $_ ne "" } @values);
2283     }
2284 }
2285 sub add_before {
2286     my $separator = " ";
2287     if (ref($_[$#_]) eq "HASH") {
2288         my $opts = pop;
2289         $separator = $opts->{separator};
2290     }
2291     my @x = @_;
2292     sub { _add($separator, @x, @_) };
2293 }
2294 sub add {
2295     my $separator = " ";
2296     if (ref($_[$#_]) eq "HASH") {
2297         my $opts = pop;
2298         $separator = $opts->{separator};
2299     }
2300     my @x = @_;
2301     sub { _add($separator, @_, @x) };
2302 }
2303
2304 # configuration reader, evaluates the input file as a perl script and expects
2305 # it to fill %targets with target configurations.  Those are then added to
2306 # %table.
2307 sub read_config {
2308     my $fname = shift;
2309     open(CONFFILE, "< $fname")
2310         or die "Can't open configuration file '$fname'!\n";
2311     my $x = $/;
2312     undef $/;
2313     my $content = <CONFFILE>;
2314     $/ = $x;
2315     close(CONFFILE);
2316     my %targets = ();
2317     {
2318         # Protect certain tables from tampering
2319         local %table = %::table;
2320
2321         eval $content;
2322         warn $@ if $@;
2323     }
2324     my %preexisting = ();
2325     foreach (sort keys %targets) {
2326         $preexisting{$_} = 1 if $table{$_};
2327     }
2328     die <<"EOF",
2329 The following config targets from $fname
2330 shadow pre-existing config targets with the same name:
2331 EOF
2332         map { "  $_\n" } sort keys %preexisting
2333         if %preexisting;
2334
2335
2336     # For each target, check that it's configured with a hash table.
2337     foreach (keys %targets) {
2338         if (ref($targets{$_}) ne "HASH") {
2339             if (ref($targets{$_}) eq "") {
2340                 warn "Deprecated target configuration for $_, ignoring...\n";
2341             } else {
2342                 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
2343             }
2344             delete $targets{$_};
2345         } else {
2346             $targets{$_}->{_conf_fname_int} = add([ $fname ]);
2347         }
2348     }
2349
2350     %table = (%table, %targets);
2351
2352 }
2353
2354 # configuration resolver.  Will only resolve all the lazy evaluation
2355 # codeblocks for the chosen target and all those it inherits from,
2356 # recursively
2357 sub resolve_config {
2358     my $target = shift;
2359     my @breadcrumbs = @_;
2360
2361 #    my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
2362
2363     if (grep { $_ eq $target } @breadcrumbs) {
2364         die "inherit_from loop!  target backtrace:\n  "
2365             ,$target,"\n  ",join("\n  ", @breadcrumbs),"\n";
2366     }
2367
2368     if (!defined($table{$target})) {
2369         warn "Warning! target $target doesn't exist!\n";
2370         return ();
2371     }
2372     # Recurse through all inheritances.  They will be resolved on the
2373     # fly, so when this operation is done, they will all just be a
2374     # bunch of attributes with string values.
2375     # What we get here, though, are keys with references to lists of
2376     # the combined values of them all.  We will deal with lists after
2377     # this stage is done.
2378     my %combined_inheritance = ();
2379     if ($table{$target}->{inherit_from}) {
2380         my @inherit_from =
2381             map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
2382         foreach (@inherit_from) {
2383             my %inherited_config = resolve_config($_, $target, @breadcrumbs);
2384
2385             # 'template' is a marker that's considered private to
2386             # the config that had it.
2387             delete $inherited_config{template};
2388
2389             foreach (keys %inherited_config) {
2390                 if (!$combined_inheritance{$_}) {
2391                     $combined_inheritance{$_} = [];
2392                 }
2393                 push @{$combined_inheritance{$_}}, $inherited_config{$_};
2394             }
2395         }
2396     }
2397
2398     # We won't need inherit_from in this target any more, since we've
2399     # resolved all the inheritances that lead to this
2400     delete $table{$target}->{inherit_from};
2401
2402     # Now is the time to deal with those lists.  Here's the place to
2403     # decide what shall be done with those lists, all based on the
2404     # values of the target we're currently dealing with.
2405     # - If a value is a coderef, it will be executed with the list of
2406     #   inherited values as arguments.
2407     # - If the corresponding key doesn't have a value at all or is the
2408     #   empty string, the inherited value list will be run through the
2409     #   default combiner (below), and the result becomes this target's
2410     #   value.
2411     # - Otherwise, this target's value is assumed to be a string that
2412     #   will simply override the inherited list of values.
2413     my $default_combiner = add();
2414
2415     my %all_keys =
2416         map { $_ => 1 } (keys %combined_inheritance,
2417                          keys %{$table{$target}});
2418
2419     sub process_values {
2420         my $object    = shift;
2421         my $inherited = shift;  # Always a [ list ]
2422         my $target    = shift;
2423         my $entry     = shift;
2424
2425         $add_called = 0;
2426
2427         while(ref($object) eq "CODE") {
2428             $object = $object->(@$inherited);
2429         }
2430         if (!defined($object)) {
2431             return ();
2432         }
2433         elsif (ref($object) eq "ARRAY") {
2434             local $add_called;  # To make sure recursive calls don't affect it
2435             return [ map { process_values($_, $inherited, $target, $entry) }
2436                      @$object ];
2437         } elsif (ref($object) eq "") {
2438             return $object;
2439         } else {
2440             die "cannot handle reference type ",ref($object)
2441                 ," found in target ",$target," -> ",$entry,"\n";
2442         }
2443     }
2444
2445     foreach (sort keys %all_keys) {
2446         my $previous = $combined_inheritance{$_};
2447
2448         # Current target doesn't have a value for the current key?
2449         # Assign it the default combiner, the rest of this loop body
2450         # will handle it just like any other coderef.
2451         if (!exists $table{$target}->{$_}) {
2452             $table{$target}->{$_} = $default_combiner;
2453         }
2454
2455         $table{$target}->{$_} = process_values($table{$target}->{$_},
2456                                                $combined_inheritance{$_},
2457                                                $target, $_);
2458         unless(defined($table{$target}->{$_})) {
2459             delete $table{$target}->{$_};
2460         }
2461 #        if ($extra_checks &&
2462 #            $previous && !($add_called ||  $previous ~~ $table{$target}->{$_})) {
2463 #            warn "$_ got replaced in $target\n";
2464 #        }
2465     }
2466
2467     # Finally done, return the result.
2468     return %{$table{$target}};
2469 }
2470
2471 sub usage
2472         {
2473         print STDERR $usage;
2474         print STDERR "\npick os/compiler from:\n";
2475         my $j=0;
2476         my $i;
2477         my $k=0;
2478         foreach $i (sort keys %table)
2479                 {
2480                 next if $table{$i}->{template};
2481                 next if $i =~ /^debug/;
2482                 $k += length($i) + 1;
2483                 if ($k > 78)
2484                         {
2485                         print STDERR "\n";
2486                         $k=length($i);
2487                         }
2488                 print STDERR $i . " ";
2489                 }
2490         foreach $i (sort keys %table)
2491                 {
2492                 next if $table{$i}->{template};
2493                 next if $i !~ /^debug/;
2494                 $k += length($i) + 1;
2495                 if ($k > 78)
2496                         {
2497                         print STDERR "\n";
2498                         $k=length($i);
2499                         }
2500                 print STDERR $i . " ";
2501                 }
2502         print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
2503         exit(1);
2504         }
2505
2506 sub run_dofile
2507 {
2508     my $out = shift;
2509     my @templates = @_;
2510
2511     unlink $out || warn "Can't remove $out, $!"
2512         if -f $out;
2513     foreach (@templates) {
2514         die "Can't open $_, $!" unless -f $_;
2515     }
2516     my $perlcmd = (quotify("maybeshell", $config{perl}))[0];
2517     my $cmd = "$perlcmd \"-I.\" \"-Mconfigdata\" \"$dofile\" -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\"";
2518     #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
2519     system($cmd);
2520     exit 1 if $? != 0;
2521     rename("$out.new", $out) || die "Can't rename $out.new, $!";
2522 }
2523
2524 sub which
2525 {
2526     my ($name)=@_;
2527
2528     if (eval { require IPC::Cmd; 1; }) {
2529         IPC::Cmd->import();
2530         return scalar IPC::Cmd::can_run($name);
2531     } else {
2532         # if there is $directories component in splitpath,
2533         # then it's not something to test with $PATH...
2534         return $name if (File::Spec->splitpath($name))[1];
2535
2536         foreach (File::Spec->path()) {
2537             my $fullpath = catfile($_, "$name$target{exe_extension}");
2538             if (-f $fullpath and -x $fullpath) {
2539                 return $fullpath;
2540             }
2541         }
2542     }
2543 }
2544
2545 # Configuration printer ##############################################
2546
2547 sub print_table_entry
2548 {
2549     my $target = shift;
2550     my %target = resolve_config($target);
2551     my $type = shift;
2552
2553     # Don't print the templates
2554     return if $target{template};
2555
2556     my @sequence = (
2557         "sys_id",
2558         "cc",
2559         "cflags",
2560         "defines",
2561         "unistd",
2562         "ld",
2563         "lflags",
2564         "loutflag",
2565         "plib_lflags",
2566         "ex_libs",
2567         "bn_ops",
2568         "apps_aux_src",
2569         "cpuid_asm_src",
2570         "uplink_aux_src",
2571         "bn_asm_src",
2572         "ec_asm_src",
2573         "des_asm_src",
2574         "aes_asm_src",
2575         "bf_asm_src",
2576         "md5_asm_src",
2577         "cast_asm_src",
2578         "sha1_asm_src",
2579         "rc4_asm_src",
2580         "rmd160_asm_src",
2581         "rc5_asm_src",
2582         "wp_asm_src",
2583         "cmll_asm_src",
2584         "modes_asm_src",
2585         "padlock_asm_src",
2586         "chacha_asm_src",
2587         "poly1035_asm_src",
2588         "thread_scheme",
2589         "perlasm_scheme",
2590         "dso_scheme",
2591         "shared_target",
2592         "shared_cflag",
2593         "shared_defines",
2594         "shared_ldflag",
2595         "shared_rcflag",
2596         "shared_extension",
2597         "dso_extension",
2598         "obj_extension",
2599         "exe_extension",
2600         "ranlib",
2601         "ar",
2602         "arflags",
2603         "aroutflag",
2604         "rc",
2605         "rcflags",
2606         "rcoutflag",
2607         "mt",
2608         "mtflags",
2609         "mtinflag",
2610         "mtoutflag",
2611         "multilib",
2612         "build_scheme",
2613         );
2614
2615     if ($type eq "TABLE") {
2616         print "\n";
2617         print "*** $target\n";
2618         foreach (@sequence) {
2619             if (ref($target{$_}) eq "ARRAY") {
2620                 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
2621             } else {
2622                 printf "\$%-12s = %s\n", $_, $target{$_};
2623             }
2624         }
2625     } elsif ($type eq "HASH") {
2626         my $largest =
2627             length((sort { length($a) <=> length($b) } @sequence)[-1]);
2628         print "    '$target' => {\n";
2629         foreach (@sequence) {
2630             if ($target{$_}) {
2631                 if (ref($target{$_}) eq "ARRAY") {
2632                     print "      '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
2633                 } else {
2634                     print "      '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
2635                 }
2636             }
2637         }
2638         print "    },\n";
2639     }
2640 }
2641
2642 # Utility routines ###################################################
2643
2644 # On VMS, if the given file is a logical name, File::Spec::Functions
2645 # will consider it an absolute path.  There are cases when we want a
2646 # purely syntactic check without checking the environment.
2647 sub isabsolute {
2648     my $file = shift;
2649
2650     # On non-platforms, we just use file_name_is_absolute().
2651     return file_name_is_absolute($file) unless $^O eq "VMS";
2652
2653     # If the file spec includes a device or a directory spec,
2654     # file_name_is_absolute() is perfectly safe.
2655     return file_name_is_absolute($file) if $file =~ m|[:\[]|;
2656
2657     # Here, we know the given file spec isn't absolute
2658     return 0;
2659 }
2660
2661 # Makes a directory absolute and cleans out /../ in paths like foo/../bar
2662 # On some platforms, this uses rel2abs(), while on others, realpath() is used.
2663 # realpath() requires that at least all path components except the last is an
2664 # existing directory.  On VMS, the last component of the directory spec must
2665 # exist.
2666 sub absolutedir {
2667     my $dir = shift;
2668
2669     # realpath() is quite buggy on VMS.  It uses LIB$FID_TO_NAME, which
2670     # will return the volume name for the device, no matter what.  Also,
2671     # it will return an incorrect directory spec if the argument is a
2672     # directory that doesn't exist.
2673     if ($^O eq "VMS") {
2674         return rel2abs($dir);
2675     }
2676
2677     # We use realpath() on Unix, since no other will properly clean out
2678     # a directory spec.
2679     use Cwd qw/realpath/;
2680
2681     return realpath($dir);
2682 }
2683
2684 sub quotify {
2685     my %processors = (
2686         perl    => sub { my $x = shift;
2687                          $x =~ s/([\\\$\@"])/\\$1/g;
2688                          return '"'.$x.'"'; },
2689         maybeshell => sub { my $x = shift;
2690                             (my $y = $x) =~ s/([\\\"])/\\$1/g;
2691                             if ($x ne $y || $x =~ m|\s|) {
2692                                 return '"'.$y.'"';
2693                             } else {
2694                                 return $x;
2695                             }
2696                         },
2697         );
2698     my $for = shift;
2699     my $processor =
2700         defined($processors{$for}) ? $processors{$for} : sub { shift; };
2701
2702     return map { $processor->($_); } @_;
2703 }
2704
2705 # collect_from_file($filename, $line_concat_cond_re, $line_concat)
2706 # $filename is a file name to read from
2707 # $line_concat_cond_re is a regexp detecting a line continuation ending
2708 # $line_concat is a CODEref that takes care of concatenating two lines
2709 sub collect_from_file {
2710     my $filename = shift;
2711     my $line_concat_cond_re = shift;
2712     my $line_concat = shift;
2713
2714     open my $fh, $filename || die "unable to read $filename: $!\n";
2715     return sub {
2716         my $saved_line = "";
2717         $_ = "";
2718         while (<$fh>) {
2719             s|\R$||;
2720             if (defined $line_concat) {
2721                 $_ = $line_concat->($saved_line, $_);
2722                 $saved_line = "";
2723             }
2724             if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2725                 $saved_line = $_;
2726                 next;
2727             }
2728             return $_;
2729         }
2730         die "$filename ending with continuation line\n" if $_;
2731         close $fh;
2732         return undef;
2733     }
2734 }
2735
2736 # collect_from_array($array, $line_concat_cond_re, $line_concat)
2737 # $array is an ARRAYref of lines
2738 # $line_concat_cond_re is a regexp detecting a line continuation ending
2739 # $line_concat is a CODEref that takes care of concatenating two lines
2740 sub collect_from_array {
2741     my $array = shift;
2742     my $line_concat_cond_re = shift;
2743     my $line_concat = shift;
2744     my @array = (@$array);
2745
2746     return sub {
2747         my $saved_line = "";
2748         $_ = "";
2749         while (defined($_ = shift @array)) {
2750             s|\R$||;
2751             if (defined $line_concat) {
2752                 $_ = $line_concat->($saved_line, $_);
2753                 $saved_line = "";
2754             }
2755             if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2756                 $saved_line = $_;
2757                 next;
2758             }
2759             return $_;
2760         }
2761         die "input text ending with continuation line\n" if $_;
2762         return undef;
2763     }
2764 }
2765
2766 # collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
2767 # $lineiterator is a CODEref that delivers one line at a time.
2768 # All following arguments are regex/CODEref pairs, where the regexp detects a
2769 # line and the CODEref does something with the result of the regexp.
2770 sub collect_information {
2771     my $lineiterator = shift;
2772     my %collectors = @_;
2773
2774     while(defined($_ = $lineiterator->())) {
2775         s|\R$||;
2776         my $found = 0;
2777         if ($collectors{"BEFORE"}) {
2778             $collectors{"BEFORE"}->($_);
2779         }
2780         foreach my $re (keys %collectors) {
2781             if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
2782                 $collectors{$re}->($lineiterator);
2783                 $found = 1;
2784             };
2785         }
2786         if ($collectors{"OTHERWISE"}) {
2787             $collectors{"OTHERWISE"}->($lineiterator, $_)
2788                 unless $found || !defined $collectors{"OTHERWISE"};
2789         }
2790         if ($collectors{"AFTER"}) {
2791             $collectors{"AFTER"}->($_);
2792         }
2793     }
2794 }
2795
2796 # tokenize($line)
2797 # $line is a line of text to split up into tokens
2798 # returns a list of tokens
2799 #
2800 # Tokens are divided by spaces.  If the tokens include spaces, they
2801 # have to be quoted with single or double quotes.  Double quotes
2802 # inside a double quoted token must be escaped.  Escaping is done
2803 # with backslash.
2804 # Basically, the same quoting rules apply for " and ' as in any
2805 # Unix shell.
2806 sub tokenize {
2807     my $line = my $debug_line = shift;
2808     my @result = ();
2809
2810     while ($line =~ s|^\s+||, $line ne "") {
2811         my $token = "";
2812         while ($line ne "" && $line !~ m|^\s|) {
2813             if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
2814                 $token .= $1;
2815                 $line = $';
2816             } elsif ($line =~ m/^'([^']*)'/) {
2817                 $token .= $1;
2818                 $line = $';
2819             } elsif ($line =~ m/^(\S+)/) {
2820                 $token .= $1;
2821                 $line = $';
2822             }
2823         }
2824         push @result, $token;
2825     }
2826
2827     if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
2828         print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
2829         print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";
2830     }
2831     return @result;
2832 }