Configure

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