Configure

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