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