Configure

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