Enable the ability to use an external PSK for sending early_data
[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         . " -Qunused-arguments"
145         . " -Wswitch-default"
146         . " -Wno-parentheses-equality"
147         . " -Wno-language-extension-token"
148         . " -Wno-extended-offsetof"
149         . " -Wconditional-uninitialized"
150         . " -Wincompatible-pointer-types-discards-qualifiers"
151         . " -Wmissing-variable-declarations"
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" ],
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 ($strict_warnings)
1325         {
1326         my $wopt;
1327         die "ERROR --strict-warnings requires gcc or gcc-alike"
1328             unless defined($predefined{__GNUC__});
1329         foreach $wopt (split /\s+/, $gcc_devteam_warn)
1330                 {
1331                 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1332                 }
1333         if (defined($predefined{__clang__}))
1334                 {
1335                 foreach $wopt (split /\s+/, $clang_devteam_warn)
1336                         {
1337                         $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1338                         }
1339                 }
1340         }
1341
1342 unless ($disabled{"crypto-mdebug-backtrace"})
1343         {
1344         foreach my $wopt (split /\s+/, $memleak_devteam_backtrace)
1345                 {
1346                 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1347                 }
1348         if ($target =~ /^BSD-/)
1349                 {
1350                 $config{ex_libs} .= " -lexecinfo";
1351                 }
1352         }
1353
1354 if ($user_cflags ne "") { $config{cflags}="$config{cflags}$user_cflags"; $config{cxxflags}="$config{cxxflags}$user_cflags";}
1355 else                    { $no_user_cflags=1;  }
1356 if (@user_defines) { $config{defines}=[ @{$config{defines}}, @user_defines ]; }
1357 else               { $no_user_defines=1;    }
1358
1359 # ALL MODIFICATIONS TO %config and %target MUST BE DONE FROM HERE ON
1360
1361 unless ($disabled{afalgeng}) {
1362     $config{afalgeng}="";
1363     if ($target =~ m/^linux/) {
1364         my $minver = 4*10000 + 1*100 + 0;
1365         if ($config{cross_compile_prefix} eq "") {
1366             my $verstr = `uname -r`;
1367             my ($ma, $mi1, $mi2) = split("\\.", $verstr);
1368             ($mi2) = $mi2 =~ /(\d+)/;
1369             my $ver = $ma*10000 + $mi1*100 + $mi2;
1370             if ($ver < $minver) {
1371                 $disabled{afalgeng} = "too-old-kernel";
1372             } else {
1373                 push @{$config{engdirs}}, "afalg";
1374             }
1375         } else {
1376             $disabled{afalgeng} = "cross-compiling";
1377         }
1378     } else {
1379         $disabled{afalgeng}  = "not-linux";
1380     }
1381 }
1382
1383 push @{$config{openssl_other_defines}}, "OPENSSL_NO_AFALGENG" if ($disabled{afalgeng});
1384
1385 # If we use the unified build, collect information from build.info files
1386 my %unified_info = ();
1387
1388 my $buildinfo_debug = defined($ENV{CONFIGURE_DEBUG_BUILDINFO});
1389 if ($builder eq "unified") {
1390     use with_fallback qw(Text::Template);
1391
1392     sub cleandir {
1393         my $base = shift;
1394         my $dir = shift;
1395         my $relativeto = shift || ".";
1396
1397         $dir = catdir($base,$dir) unless isabsolute($dir);
1398
1399         # Make sure the directories we're building in exists
1400         mkpath($dir);
1401
1402         my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
1403         #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1404         return $res;
1405     }
1406
1407     sub cleanfile {
1408         my $base = shift;
1409         my $file = shift;
1410         my $relativeto = shift || ".";
1411
1412         $file = catfile($base,$file) unless isabsolute($file);
1413
1414         my $d = dirname($file);
1415         my $f = basename($file);
1416
1417         # Make sure the directories we're building in exists
1418         mkpath($d);
1419
1420         my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
1421         #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1422         return $res;
1423     }
1424
1425     # Store the name of the template file we will build the build file from
1426     # in %config.  This may be useful for the build file itself.
1427     my @build_file_template_names =
1428         ( $builder_platform."-".$target{build_file}.".tmpl",
1429           $target{build_file}.".tmpl" );
1430     my @build_file_templates = ();
1431
1432     # First, look in the user provided directory, if given
1433     if (defined $ENV{$local_config_envname}) {
1434         @build_file_templates =
1435             map {
1436                 if ($^O eq 'VMS') {
1437                     # VMS environment variables are logical names,
1438                     # which can be used as is
1439                     $local_config_envname . ':' . $_;
1440                 } else {
1441                     catfile($ENV{$local_config_envname}, $_);
1442                 }
1443             }
1444             @build_file_template_names;
1445     }
1446     # Then, look in our standard directory
1447     push @build_file_templates,
1448         ( map { cleanfile($srcdir, catfile("Configurations", $_), $blddir) }
1449           @build_file_template_names );
1450
1451     my $build_file_template;
1452     for $_ (@build_file_templates) {
1453         $build_file_template = $_;
1454         last if -f $build_file_template;
1455
1456         $build_file_template = undef;
1457     }
1458     if (!defined $build_file_template) {
1459         die "*** Couldn't find any of:\n", join("\n", @build_file_templates), "\n";
1460     }
1461     $config{build_file_templates}
1462       = [ $build_file_template,
1463           cleanfile($srcdir, catfile("Configurations", "common.tmpl"),
1464                     $blddir) ];
1465
1466     my @build_infos = ( [ ".", "build.info" ] );
1467     foreach (@{$config{dirs}}) {
1468         push @build_infos, [ $_, "build.info" ]
1469             if (-f catfile($srcdir, $_, "build.info"));
1470     }
1471     foreach (@{$config{sdirs}}) {
1472         push @build_infos, [ catdir("crypto", $_), "build.info" ]
1473             if (-f catfile($srcdir, "crypto", $_, "build.info"));
1474     }
1475     foreach (@{$config{engdirs}}) {
1476         push @build_infos, [ catdir("engines", $_), "build.info" ]
1477             if (-f catfile($srcdir, "engines", $_, "build.info"));
1478     }
1479     foreach (@{$config{tdirs}}) {
1480         push @build_infos, [ catdir("test", $_), "build.info" ]
1481             if (-f catfile($srcdir, "test", $_, "build.info"));
1482     }
1483
1484     $config{build_infos} = [ ];
1485
1486     foreach (@build_infos) {
1487         my $sourced = catdir($srcdir, $_->[0]);
1488         my $buildd = catdir($blddir, $_->[0]);
1489
1490         mkpath($buildd);
1491
1492         my $f = $_->[1];
1493         # The basic things we're trying to build
1494         my @programs = ();
1495         my @programs_install = ();
1496         my @libraries = ();
1497         my @libraries_install = ();
1498         my @engines = ();
1499         my @engines_install = ();
1500         my @scripts = ();
1501         my @scripts_install = ();
1502         my @extra = ();
1503         my @overrides = ();
1504         my @intermediates = ();
1505         my @rawlines = ();
1506
1507         my %ordinals = ();
1508         my %sources = ();
1509         my %shared_sources = ();
1510         my %includes = ();
1511         my %depends = ();
1512         my %renames = ();
1513         my %sharednames = ();
1514         my %generate = ();
1515
1516         push @{$config{build_infos}}, catfile(abs2rel($sourced, $blddir), $f);
1517         my $template =
1518             Text::Template->new(TYPE => 'FILE',
1519                                 SOURCE => catfile($sourced, $f),
1520                                 PREPEND => qq{use lib "$FindBin::Bin/util/perl";});
1521         die "Something went wrong with $sourced/$f: $!\n" unless $template;
1522         my @text =
1523             split /^/m,
1524             $template->fill_in(HASH => { config => \%config,
1525                                          target => \%target,
1526                                          disabled => \%disabled,
1527                                          withargs => \%withargs,
1528                                          builddir => abs2rel($buildd, $blddir),
1529                                          sourcedir => abs2rel($sourced, $blddir),
1530                                          buildtop => abs2rel($blddir, $blddir),
1531                                          sourcetop => abs2rel($srcdir, $blddir) },
1532                                DELIMITERS => [ "{-", "-}" ]);
1533
1534         # The top item of this stack has the following values
1535         # -2 positive already run and we found ELSE (following ELSIF should fail)
1536         # -1 positive already run (skip until ENDIF)
1537         # 0 negatives so far (if we're at a condition, check it)
1538         # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
1539         # 2 positive ELSE (following ELSIF should fail)
1540         my @skip = ();
1541         collect_information(
1542             collect_from_array([ @text ],
1543                                qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
1544                                                 $l1 =~ s/\\$//; $l1.$l2 }),
1545             # Info we're looking for
1546             qr/^\s*IF\[((?:\\.|[^\\\]])*)\]\s*$/
1547             => sub {
1548                 if (! @skip || $skip[$#skip] > 0) {
1549                     push @skip, !! $1;
1550                 } else {
1551                     push @skip, -1;
1552                 }
1553             },
1554             qr/^\s*ELSIF\[((?:\\.|[^\\\]])*)\]\s*$/
1555             => sub { die "ELSIF out of scope" if ! @skip;
1556                      die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
1557                      $skip[$#skip] = -1 if $skip[$#skip] != 0;
1558                      $skip[$#skip] = !! $1
1559                          if $skip[$#skip] == 0; },
1560             qr/^\s*ELSE\s*$/
1561             => sub { die "ELSE out of scope" if ! @skip;
1562                      $skip[$#skip] = -2 if $skip[$#skip] != 0;
1563                      $skip[$#skip] = 2 if $skip[$#skip] == 0; },
1564             qr/^\s*ENDIF\s*$/
1565             => sub { die "ENDIF out of scope" if ! @skip;
1566                      pop @skip; },
1567             qr/^\s*PROGRAMS(_NO_INST)?\s*=\s*(.*)\s*$/
1568             => sub {
1569                 if (!@skip || $skip[$#skip] > 0) {
1570                     my $install = $1;
1571                     my @x = tokenize($2);
1572                     push @programs, @x;
1573                     push @programs_install, @x unless $install;
1574                 }
1575             },
1576             qr/^\s*LIBS(_NO_INST)?\s*=\s*(.*)\s*$/
1577             => sub {
1578                 if (!@skip || $skip[$#skip] > 0) {
1579                     my $install = $1;
1580                     my @x = tokenize($2);
1581                     push @libraries, @x;
1582                     push @libraries_install, @x unless $install;
1583                 }
1584             },
1585             qr/^\s*ENGINES(_NO_INST)?\s*=\s*(.*)\s*$/
1586             => sub {
1587                 if (!@skip || $skip[$#skip] > 0) {
1588                     my $install = $1;
1589                     my @x = tokenize($2);
1590                     push @engines, @x;
1591                     push @engines_install, @x unless $install;
1592                 }
1593             },
1594             qr/^\s*SCRIPTS(_NO_INST)?\s*=\s*(.*)\s*$/
1595             => sub {
1596                 if (!@skip || $skip[$#skip] > 0) {
1597                     my $install = $1;
1598                     my @x = tokenize($2);
1599                     push @scripts, @x;
1600                     push @scripts_install, @x unless $install;
1601                 }
1602             },
1603             qr/^\s*EXTRA\s*=\s*(.*)\s*$/
1604             => sub { push @extra, tokenize($1)
1605                          if !@skip || $skip[$#skip] > 0 },
1606             qr/^\s*OVERRIDES\s*=\s*(.*)\s*$/
1607             => sub { push @overrides, tokenize($1)
1608                          if !@skip || $skip[$#skip] > 0 },
1609
1610             qr/^\s*ORDINALS\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/,
1611             => sub { push @{$ordinals{$1}}, tokenize($2)
1612                          if !@skip || $skip[$#skip] > 0 },
1613             qr/^\s*SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1614             => sub { push @{$sources{$1}}, tokenize($2)
1615                          if !@skip || $skip[$#skip] > 0 },
1616             qr/^\s*SHARED_SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1617             => sub { push @{$shared_sources{$1}}, tokenize($2)
1618                          if !@skip || $skip[$#skip] > 0 },
1619             qr/^\s*INCLUDE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1620             => sub { push @{$includes{$1}}, tokenize($2)
1621                          if !@skip || $skip[$#skip] > 0 },
1622             qr/^\s*DEPEND\[((?:\\.|[^\\\]])*)\]\s*=\s*(.*)\s*$/
1623             => sub { push @{$depends{$1}}, tokenize($2)
1624                          if !@skip || $skip[$#skip] > 0 },
1625             qr/^\s*GENERATE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1626             => sub { push @{$generate{$1}}, $2
1627                          if !@skip || $skip[$#skip] > 0 },
1628             qr/^\s*RENAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1629             => sub { push @{$renames{$1}}, tokenize($2)
1630                          if !@skip || $skip[$#skip] > 0 },
1631             qr/^\s*SHARED_NAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1632             => sub { push @{$sharednames{$1}}, tokenize($2)
1633                          if !@skip || $skip[$#skip] > 0 },
1634             qr/^\s*BEGINRAW\[((?:\\.|[^\\\]])+)\]\s*$/
1635             => sub {
1636                 my $lineiterator = shift;
1637                 my $target_kind = $1;
1638                 while (defined $lineiterator->()) {
1639                     s|\R$||;
1640                     if (/^\s*ENDRAW\[((?:\\.|[^\\\]])+)\]\s*$/) {
1641                         die "ENDRAW doesn't match BEGINRAW"
1642                             if $1 ne $target_kind;
1643                         last;
1644                     }
1645                     next if @skip && $skip[$#skip] <= 0;
1646                     push @rawlines,  $_
1647                         if ($target_kind eq $target{build_file}
1648                             || $target_kind eq $target{build_file}."(".$builder_platform.")");
1649                 }
1650             },
1651             qr/^\s*(?:#.*)?$/ => sub { },
1652             "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" },
1653             "BEFORE" => sub {
1654                 if ($buildinfo_debug) {
1655                     print STDERR "DEBUG: Parsing ",join(" ", @_),"\n";
1656                     print STDERR "DEBUG: ... before parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1657                 }
1658             },
1659             "AFTER" => sub {
1660                 if ($buildinfo_debug) {
1661                     print STDERR "DEBUG: .... after parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1662                 }
1663             },
1664             );
1665         die "runaway IF?" if (@skip);
1666
1667         foreach (keys %renames) {
1668             die "$_ renamed to more than one thing: "
1669                 ,join(" ", @{$renames{$_}}),"\n"
1670                 if scalar @{$renames{$_}} > 1;
1671             my $dest = cleanfile($buildd, $_, $blddir);
1672             my $to = cleanfile($buildd, $renames{$_}->[0], $blddir);
1673             die "$dest renamed to more than one thing: "
1674                 ,$unified_info{rename}->{$dest}, $to
1675                 unless !defined($unified_info{rename}->{$dest})
1676                 or $unified_info{rename}->{$dest} eq $to;
1677             $unified_info{rename}->{$dest} = $to;
1678         }
1679
1680         foreach (@programs) {
1681             my $program = cleanfile($buildd, $_, $blddir);
1682             if ($unified_info{rename}->{$program}) {
1683                 $program = $unified_info{rename}->{$program};
1684             }
1685             $unified_info{programs}->{$program} = 1;
1686         }
1687
1688         foreach (@programs_install) {
1689             my $program = cleanfile($buildd, $_, $blddir);
1690             if ($unified_info{rename}->{$program}) {
1691                 $program = $unified_info{rename}->{$program};
1692             }
1693             $unified_info{install}->{programs}->{$program} = 1;
1694         }
1695
1696         foreach (@libraries) {
1697             my $library = cleanfile($buildd, $_, $blddir);
1698             if ($unified_info{rename}->{$library}) {
1699                 $library = $unified_info{rename}->{$library};
1700             }
1701             $unified_info{libraries}->{$library} = 1;
1702         }
1703
1704         foreach (@libraries_install) {
1705             my $library = cleanfile($buildd, $_, $blddir);
1706             if ($unified_info{rename}->{$library}) {
1707                 $library = $unified_info{rename}->{$library};
1708             }
1709             $unified_info{install}->{libraries}->{$library} = 1;
1710         }
1711
1712         die <<"EOF" if scalar @engines and !$config{dynamic_engines};
1713 ENGINES can only be used if configured with 'dynamic-engine'.
1714 This is usually a fault in a build.info file.
1715 EOF
1716         foreach (@engines) {
1717             my $library = cleanfile($buildd, $_, $blddir);
1718             if ($unified_info{rename}->{$library}) {
1719                 $library = $unified_info{rename}->{$library};
1720             }
1721             $unified_info{engines}->{$library} = 1;
1722         }
1723
1724         foreach (@engines_install) {
1725             my $library = cleanfile($buildd, $_, $blddir);
1726             if ($unified_info{rename}->{$library}) {
1727                 $library = $unified_info{rename}->{$library};
1728             }
1729             $unified_info{install}->{engines}->{$library} = 1;
1730         }
1731
1732         foreach (@scripts) {
1733             my $script = cleanfile($buildd, $_, $blddir);
1734             if ($unified_info{rename}->{$script}) {
1735                 $script = $unified_info{rename}->{$script};
1736             }
1737             $unified_info{scripts}->{$script} = 1;
1738         }
1739
1740         foreach (@scripts_install) {
1741             my $script = cleanfile($buildd, $_, $blddir);
1742             if ($unified_info{rename}->{$script}) {
1743                 $script = $unified_info{rename}->{$script};
1744             }
1745             $unified_info{install}->{scripts}->{$script} = 1;
1746         }
1747
1748         foreach (@extra) {
1749             my $extra = cleanfile($buildd, $_, $blddir);
1750             $unified_info{extra}->{$extra} = 1;
1751         }
1752
1753         foreach (@overrides) {
1754             my $override = cleanfile($buildd, $_, $blddir);
1755             $unified_info{overrides}->{$override} = 1;
1756         }
1757
1758         push @{$unified_info{rawlines}}, @rawlines;
1759
1760         unless ($disabled{shared}) {
1761             # Check sharednames.
1762             foreach (keys %sharednames) {
1763                 my $dest = cleanfile($buildd, $_, $blddir);
1764                 if ($unified_info{rename}->{$dest}) {
1765                     $dest = $unified_info{rename}->{$dest};
1766                 }
1767                 die "shared_name for $dest with multiple values: "
1768                     ,join(" ", @{$sharednames{$_}}),"\n"
1769                     if scalar @{$sharednames{$_}} > 1;
1770                 my $to = cleanfile($buildd, $sharednames{$_}->[0], $blddir);
1771                 die "shared_name found for a library $dest that isn't defined\n"
1772                     unless $unified_info{libraries}->{$dest};
1773                 die "shared_name for $dest with multiple values: "
1774                     ,$unified_info{sharednames}->{$dest}, ", ", $to
1775                     unless !defined($unified_info{sharednames}->{$dest})
1776                     or $unified_info{sharednames}->{$dest} eq $to;
1777                 $unified_info{sharednames}->{$dest} = $to;
1778             }
1779
1780             # Additionally, we set up sharednames for libraries that don't
1781             # have any, as themselves.  Only for libraries that aren't
1782             # explicitely static.
1783             foreach (grep !/\.a$/, keys %{$unified_info{libraries}}) {
1784                 if (!defined $unified_info{sharednames}->{$_}) {
1785                     $unified_info{sharednames}->{$_} = $_
1786                 }
1787             }
1788
1789             # Check that we haven't defined any library as both shared and
1790             # explicitely static.  That is forbidden.
1791             my @doubles = ();
1792             foreach (grep /\.a$/, keys %{$unified_info{libraries}}) {
1793                 (my $l = $_) =~ s/\.a$//;
1794                 push @doubles, $l if defined $unified_info{sharednames}->{$l};
1795             }
1796             die "these libraries are both explicitely static and shared:\n  ",
1797                 join(" ", @doubles), "\n"
1798                 if @doubles;
1799         }
1800
1801         foreach (keys %ordinals) {
1802             my $dest = $_;
1803             my $ddest = cleanfile($buildd, $_, $blddir);
1804             if ($unified_info{rename}->{$ddest}) {
1805                 $ddest = $unified_info{rename}->{$ddest};
1806             }
1807             foreach (@{$ordinals{$dest}}) {
1808                 my %known_ordinals =
1809                     (
1810                      crypto =>
1811                      cleanfile($sourced, catfile("util", "libcrypto.num"), $blddir),
1812                      ssl =>
1813                      cleanfile($sourced, catfile("util", "libssl.num"), $blddir)
1814                     );
1815                 my $o = $known_ordinals{$_};
1816                 die "Ordinals for $ddest defined more than once\n"
1817                     if $unified_info{ordinals}->{$ddest};
1818                 $unified_info{ordinals}->{$ddest} = [ $_, $o ];
1819             }
1820         }
1821
1822         foreach (keys %sources) {
1823             my $dest = $_;
1824             my $ddest = cleanfile($buildd, $_, $blddir);
1825             if ($unified_info{rename}->{$ddest}) {
1826                 $ddest = $unified_info{rename}->{$ddest};
1827             }
1828             foreach (@{$sources{$dest}}) {
1829                 my $s = cleanfile($sourced, $_, $blddir);
1830
1831                 # If it isn't in the source tree, we assume it's generated
1832                 # in the build tree
1833                 if (! -f $s) {
1834                     $s = cleanfile($buildd, $_, $blddir);
1835                 }
1836                 # We recognise C++, C and asm files
1837                 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
1838                     my $o = $_;
1839                     $o =~ s/\.[csS]$/.o/; # C and assembler
1840                     $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
1841                     $o = cleanfile($buildd, $o, $blddir);
1842                     $unified_info{sources}->{$ddest}->{$o} = 1;
1843                     $unified_info{sources}->{$o}->{$s} = 1;
1844                 } else {
1845                     $unified_info{sources}->{$ddest}->{$s} = 1;
1846                 }
1847             }
1848         }
1849
1850         foreach (keys %shared_sources) {
1851             my $dest = $_;
1852             my $ddest = cleanfile($buildd, $_, $blddir);
1853             if ($unified_info{rename}->{$ddest}) {
1854                 $ddest = $unified_info{rename}->{$ddest};
1855             }
1856             foreach (@{$shared_sources{$dest}}) {
1857                 my $s = cleanfile($sourced, $_, $blddir);
1858
1859                 # If it isn't in the source tree, we assume it's generated
1860                 # in the build tree
1861                 if (! -f $s) {
1862                     $s = cleanfile($buildd, $_, $blddir);
1863                 }
1864                 # We recognise C++, C and asm files
1865                 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
1866                     my $o = $_;
1867                     $o =~ s/\.[csS]$/.o/; # C and assembler
1868                     $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
1869                     $o = cleanfile($buildd, $o, $blddir);
1870                     $unified_info{shared_sources}->{$ddest}->{$o} = 1;
1871                     $unified_info{sources}->{$o}->{$s} = 1;
1872                 } else {
1873                     die "unrecognised source file type for shared library: $s\n";
1874                 }
1875             }
1876         }
1877
1878         foreach (keys %generate) {
1879             my $dest = $_;
1880             my $ddest = cleanfile($buildd, $_, $blddir);
1881             if ($unified_info{rename}->{$ddest}) {
1882                 $ddest = $unified_info{rename}->{$ddest};
1883             }
1884             die "more than one generator for $dest: "
1885                     ,join(" ", @{$generate{$_}}),"\n"
1886                     if scalar @{$generate{$_}} > 1;
1887             my @generator = split /\s+/, $generate{$dest}->[0];
1888             $generator[0] = cleanfile($sourced, $generator[0], $blddir),
1889             $unified_info{generate}->{$ddest} = [ @generator ];
1890         }
1891
1892         foreach (keys %depends) {
1893             my $dest = $_;
1894             my $ddest = $dest eq "" ? "" : cleanfile($sourced, $_, $blddir);
1895
1896             # If the destination doesn't exist in source, it can only be
1897             # a generated file in the build tree.
1898             if ($ddest ne "" && ! -f $ddest) {
1899                 $ddest = cleanfile($buildd, $_, $blddir);
1900                 if ($unified_info{rename}->{$ddest}) {
1901                     $ddest = $unified_info{rename}->{$ddest};
1902                 }
1903             }
1904             foreach (@{$depends{$dest}}) {
1905                 my $d = cleanfile($sourced, $_, $blddir);
1906
1907                 # If we know it's generated, or assume it is because we can't
1908                 # find it in the source tree, we set file we depend on to be
1909                 # in the build tree rather than the source tree, and assume
1910                 # and that there are lines to build it in a BEGINRAW..ENDRAW
1911                 # section or in the Makefile template.
1912                 if (! -f $d
1913                     || (grep { $d eq $_ }
1914                         map { cleanfile($srcdir, $_, $blddir) }
1915                         grep { /\.h$/ } keys %{$unified_info{generate}})) {
1916                     $d = cleanfile($buildd, $_, $blddir);
1917                 }
1918                 # Take note if the file to depend on is being renamed
1919                 # Take extra care with files ending with .a, they should
1920                 # be treated without that extension, and the extension
1921                 # should be added back after treatment.
1922                 $d =~ /(\.a)?$/;
1923                 my $e = $1 // "";
1924                 $d = $`;
1925                 if ($unified_info{rename}->{$d}) {
1926                     $d = $unified_info{rename}->{$d};
1927                 }
1928                 $d .= $e;
1929                 $unified_info{depends}->{$ddest}->{$d} = 1;
1930                 # If we depend on a header file or a perl module, let's make
1931                 # sure it can get included
1932                 if ($dest ne "" && $d =~ /\.(h|pm)$/) {
1933                     my $i = dirname($d);
1934                     push @{$unified_info{includes}->{$ddest}->{source}}, $i
1935                         unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}->{source}};
1936                 }
1937             }
1938         }
1939
1940         foreach (keys %includes) {
1941             my $dest = $_;
1942             my $ddest = cleanfile($sourced, $_, $blddir);
1943
1944             # If the destination doesn't exist in source, it can only be
1945             # a generated file in the build tree.
1946             if (! -f $ddest) {
1947                 $ddest = cleanfile($buildd, $_, $blddir);
1948                 if ($unified_info{rename}->{$ddest}) {
1949                     $ddest = $unified_info{rename}->{$ddest};
1950                 }
1951             }
1952             foreach (@{$includes{$dest}}) {
1953                 my $is = cleandir($sourced, $_, $blddir);
1954                 my $ib = cleandir($buildd, $_, $blddir);
1955                 push @{$unified_info{includes}->{$ddest}->{source}}, $is
1956                     unless grep { $_ eq $is } @{$unified_info{includes}->{$ddest}->{source}};
1957                 push @{$unified_info{includes}->{$ddest}->{build}}, $ib
1958                     unless grep { $_ eq $ib } @{$unified_info{includes}->{$ddest}->{build}};
1959             }
1960         }
1961     }
1962
1963     ### Make unified_info a bit more efficient
1964     # One level structures
1965     foreach (("programs", "libraries", "engines", "scripts", "extra", "overrides")) {
1966         $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
1967     }
1968     # Two level structures
1969     foreach my $l1 (("install", "sources", "shared_sources", "ldadd", "depends")) {
1970         foreach my $l2 (sort keys %{$unified_info{$l1}}) {
1971             $unified_info{$l1}->{$l2} =
1972                 [ sort keys %{$unified_info{$l1}->{$l2}} ];
1973         }
1974     }
1975     # Includes
1976     foreach my $dest (sort keys %{$unified_info{includes}}) {
1977         if (defined($unified_info{includes}->{$dest}->{build})) {
1978             my @source_includes =
1979                 ( @{$unified_info{includes}->{$dest}->{source}} );
1980             $unified_info{includes}->{$dest} =
1981                 [ @{$unified_info{includes}->{$dest}->{build}} ];
1982             foreach my $inc (@source_includes) {
1983                 push @{$unified_info{includes}->{$dest}}, $inc
1984                     unless grep { $_ eq $inc } @{$unified_info{includes}->{$dest}};
1985             }
1986         } else {
1987             $unified_info{includes}->{$dest} =
1988                 [ @{$unified_info{includes}->{$dest}->{source}} ];
1989         }
1990     }
1991 }
1992
1993 # For the schemes that need it, we provide the old *_obj configs
1994 # from the *_asm_obj ones
1995 foreach (grep /_(asm|aux)_src$/, keys %target) {
1996     my $src = $_;
1997     (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
1998     $target{$obj} = $target{$src};
1999     $target{$obj} =~ s/\.[csS]\b/.o/g; # C and assembler
2000     $target{$obj} =~ s/\.(cc|cpp)\b/_cc.o/g; # C++
2001 }
2002
2003 # Write down our configuration where it fits #########################
2004
2005 open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
2006 print OUT <<"EOF";
2007 package configdata;
2008
2009 use strict;
2010 use warnings;
2011
2012 use Exporter;
2013 #use vars qw(\@ISA \@EXPORT);
2014 our \@ISA = qw(Exporter);
2015 our \@EXPORT = qw(\%config \%target \%disabled \%withargs \%unified_info \@disablables);
2016
2017 EOF
2018 print OUT "our %config = (\n";
2019 foreach (sort keys %config) {
2020     if (ref($config{$_}) eq "ARRAY") {
2021         print OUT "  ", $_, " => [ ", join(", ",
2022                                            map { quotify("perl", $_) }
2023                                            @{$config{$_}}), " ],\n";
2024     } else {
2025         print OUT "  ", $_, " => ", quotify("perl", $config{$_}), ",\n"
2026     }
2027 }
2028 print OUT <<"EOF";
2029 );
2030
2031 EOF
2032 print OUT "our %target = (\n";
2033 foreach (sort keys %target) {
2034     if (ref($target{$_}) eq "ARRAY") {
2035         print OUT "  ", $_, " => [ ", join(", ",
2036                                            map { quotify("perl", $_) }
2037                                            @{$target{$_}}), " ],\n";
2038     } else {
2039         print OUT "  ", $_, " => ", quotify("perl", $target{$_}), ",\n"
2040     }
2041 }
2042 print OUT <<"EOF";
2043 );
2044
2045 EOF
2046 print OUT "our \%available_protocols = (\n";
2047 print OUT "  tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n";
2048 print OUT "  dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n";
2049 print OUT <<"EOF";
2050 );
2051
2052 EOF
2053 print OUT "our \@disablables = (\n";
2054 foreach (@disablables) {
2055     print OUT "  ", quotify("perl", $_), ",\n";
2056 }
2057 print OUT <<"EOF";
2058 );
2059
2060 EOF
2061 print OUT "our \%disabled = (\n";
2062 foreach (sort keys %disabled) {
2063     print OUT "  ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n";
2064 }
2065 print OUT <<"EOF";
2066 );
2067
2068 EOF
2069 print OUT "our %withargs = (\n";
2070 foreach (sort keys %withargs) {
2071     if (ref($withargs{$_}) eq "ARRAY") {
2072         print OUT "  ", $_, " => [ ", join(", ",
2073                                            map { quotify("perl", $_) }
2074                                            @{$withargs{$_}}), " ],\n";
2075     } else {
2076         print OUT "  ", $_, " => ", quotify("perl", $withargs{$_}), ",\n"
2077     }
2078 }
2079 print OUT <<"EOF";
2080 );
2081
2082 EOF
2083 if ($builder eq "unified") {
2084     my $recurse;
2085     $recurse = sub {
2086         my $indent = shift;
2087         foreach (@_) {
2088             if (ref $_ eq "ARRAY") {
2089                 print OUT " "x$indent, "[\n";
2090                 foreach (@$_) {
2091                     $recurse->($indent + 4, $_);
2092                 }
2093                 print OUT " "x$indent, "],\n";
2094             } elsif (ref $_ eq "HASH") {
2095                 my %h = %$_;
2096                 print OUT " "x$indent, "{\n";
2097                 foreach (sort keys %h) {
2098                     if (ref $h{$_} eq "") {
2099                         print OUT " "x($indent + 4), quotify("perl", $_), " => ", quotify("perl", $h{$_}), ",\n";
2100                     } else {
2101                         print OUT " "x($indent + 4), quotify("perl", $_), " =>\n";
2102                         $recurse->($indent + 8, $h{$_});
2103                     }
2104                 }
2105                 print OUT " "x$indent, "},\n";
2106             } else {
2107                 print OUT " "x$indent, quotify("perl", $_), ",\n";
2108             }
2109         }
2110     };
2111     print OUT "our %unified_info = (\n";
2112     foreach (sort keys %unified_info) {
2113         if (ref $unified_info{$_} eq "") {
2114             print OUT " "x4, quotify("perl", $_), " => ", quotify("perl", $unified_info{$_}), ",\n";
2115         } else {
2116             print OUT " "x4, quotify("perl", $_), " =>\n";
2117             $recurse->(8, $unified_info{$_});
2118         }
2119     }
2120     print OUT <<"EOF";
2121 );
2122
2123 EOF
2124 }
2125 print OUT "1;\n";
2126 close(OUT);
2127
2128 print "\n";
2129 print "PROCESSOR     =$config{processor}\n" if $config{processor};
2130 print "PERL          =$config{perl}\n";
2131 print "PERLVERSION   =$Config{version} for $Config{archname}\n";
2132 print "HASHBANGPERL  =$config{hashbangperl}\n";
2133 print "CC            =$config{cross_compile_prefix}$target{cc}\n";
2134 print "CFLAG         =$target{cflags} $config{cflags}\n";
2135 print "CXX           =$config{cross_compile_prefix}$target{cxx}\n"
2136     if defined $target{cxx};
2137 print "CXXFLAG       =$target{cxxflags} $config{cxxflags}\n"
2138     if defined $target{cxx};
2139 print "DEFINES       =",join(" ", @{$target{defines}}, @{$config{defines}}),"\n";
2140 #print "RANLIB        =", $target{ranlib} eq '$(CROSS_COMPILE)ranlib' ?
2141 #                             "$config{cross_compile_prefix}ranlib" :
2142 #                             "$target{ranlib}", "\n";
2143 print "EX_LIBS       =$target{ex_libs} $config{ex_libs}\n";
2144
2145 my %builders = (
2146     unified => sub {
2147         run_dofile(catfile($blddir, $target{build_file}),
2148                    @{$config{build_file_templates}});
2149     },
2150     );
2151
2152 $builders{$builder}->($builder_platform, @builder_opts);
2153
2154 print <<"EOF" if ($disabled{threads} eq "unavailable");
2155
2156 The library could not be configured for supporting multi-threaded
2157 applications as the compiler options required on this system are not known.
2158 See file INSTALL for details if you need multi-threading.
2159 EOF
2160
2161 print <<"EOF" if ($no_shared_warn);
2162
2163 The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
2164 platform, so we will pretend you gave the option 'no-pic', which also disables
2165 'shared' and 'dynamic-engine'.  If you know how to implement shared libraries
2166 or position independent code, please let us know (but please first make sure
2167 you have tried with a current version of OpenSSL).
2168 EOF
2169
2170 print <<"EOF" if (-f catfile($srcdir, "configdata.pm") && $srcdir ne $blddir);
2171
2172 WARNING: there are indications that another build was made in the source
2173 directory.  This build may have picked up artifacts from that build, the
2174 safest course of action is to clean the source directory and redo this
2175 configuration.
2176 EOF
2177
2178 exit(0);
2179
2180 ######################################################################
2181 #
2182 # Helpers and utility functions
2183 #
2184
2185 # Configuration file reading #########################################
2186
2187 # Note: All of the helper functions are for lazy evaluation.  They all
2188 # return a CODE ref, which will return the intended value when evaluated.
2189 # Thus, whenever there's mention of a returned value, it's about that
2190 # intended value.
2191
2192 # Helper function to implement conditional inheritance depending on the
2193 # value of $disabled{asm}.  Used in inherit_from values as follows:
2194 #
2195 #      inherit_from => [ "template", asm("asm_tmpl") ]
2196 #
2197 sub asm {
2198     my @x = @_;
2199     sub {
2200         $disabled{asm} ? () : @x;
2201     }
2202 }
2203
2204 # Helper function to implement conditional value variants, with a default
2205 # plus additional values based on the value of $config{build_type}.
2206 # Arguments are given in hash table form:
2207 #
2208 #       picker(default => "Basic string: ",
2209 #              debug   => "debug",
2210 #              release => "release")
2211 #
2212 # When configuring with --debug, the resulting string will be
2213 # "Basic string: debug", and when not, it will be "Basic string: release"
2214 #
2215 # This can be used to create variants of sets of flags according to the
2216 # build type:
2217 #
2218 #       cflags => picker(default => "-Wall",
2219 #                        debug   => "-g -O0",
2220 #                        release => "-O3")
2221 #
2222 sub picker {
2223     my %opts = @_;
2224     return sub { add($opts{default} || (),
2225                      $opts{$config{build_type}} || ())->(); }
2226 }
2227
2228 # Helper function to combine several values of different types into one.
2229 # This is useful if you want to combine a string with the result of a
2230 # lazy function, such as:
2231 #
2232 #       cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
2233 #
2234 sub combine {
2235     my @stuff = @_;
2236     return sub { add(@stuff)->(); }
2237 }
2238
2239 # Helper function to implement conditional values depending on the value
2240 # of $disabled{threads}.  Can be used as follows:
2241 #
2242 #       cflags => combine("-Wall", threads("-pthread"))
2243 #
2244 sub threads {
2245     my @flags = @_;
2246     return sub { add($disabled{threads} ? () : @flags)->(); }
2247 }
2248
2249
2250
2251 our $add_called = 0;
2252 # Helper function to implement adding values to already existing configuration
2253 # values.  It handles elements that are ARRAYs, CODEs and scalars
2254 sub _add {
2255     my $separator = shift;
2256
2257     # If there's any ARRAY in the collection of values OR the separator
2258     # is undef, we will return an ARRAY of combined values, otherwise a
2259     # string of joined values with $separator as the separator.
2260     my $found_array = !defined($separator);
2261
2262     my @values =
2263         map {
2264             my $res = $_;
2265             while (ref($res) eq "CODE") {
2266                 $res = $res->();
2267             }
2268             if (defined($res)) {
2269                 if (ref($res) eq "ARRAY") {
2270                     $found_array = 1;
2271                     @$res;
2272                 } else {
2273                     $res;
2274                 }
2275             } else {
2276                 ();
2277             }
2278     } (@_);
2279
2280     $add_called = 1;
2281
2282     if ($found_array) {
2283         [ @values ];
2284     } else {
2285         join($separator, grep { defined($_) && $_ ne "" } @values);
2286     }
2287 }
2288 sub add_before {
2289     my $separator = " ";
2290     if (ref($_[$#_]) eq "HASH") {
2291         my $opts = pop;
2292         $separator = $opts->{separator};
2293     }
2294     my @x = @_;
2295     sub { _add($separator, @x, @_) };
2296 }
2297 sub add {
2298     my $separator = " ";
2299     if (ref($_[$#_]) eq "HASH") {
2300         my $opts = pop;
2301         $separator = $opts->{separator};
2302     }
2303     my @x = @_;
2304     sub { _add($separator, @_, @x) };
2305 }
2306
2307 # configuration reader, evaluates the input file as a perl script and expects
2308 # it to fill %targets with target configurations.  Those are then added to
2309 # %table.
2310 sub read_config {
2311     my $fname = shift;
2312     open(CONFFILE, "< $fname")
2313         or die "Can't open configuration file '$fname'!\n";
2314     my $x = $/;
2315     undef $/;
2316     my $content = <CONFFILE>;
2317     $/ = $x;
2318     close(CONFFILE);
2319     my %targets = ();
2320     {
2321         # Protect certain tables from tampering
2322         local %table = %::table;
2323
2324         eval $content;
2325         warn $@ if $@;
2326     }
2327
2328     # For each target, check that it's configured with a hash table.
2329     foreach (keys %targets) {
2330         if (ref($targets{$_}) ne "HASH") {
2331             if (ref($targets{$_}) eq "") {
2332                 warn "Deprecated target configuration for $_, ignoring...\n";
2333             } else {
2334                 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
2335             }
2336             delete $targets{$_};
2337         } else {
2338             $targets{$_}->{_conf_fname_int} = add([ $fname ]);
2339         }
2340     }
2341
2342     %table = (%table, %targets);
2343
2344 }
2345
2346 # configuration resolver.  Will only resolve all the lazy evaluation
2347 # codeblocks for the chosen target and all those it inherits from,
2348 # recursively
2349 sub resolve_config {
2350     my $target = shift;
2351     my @breadcrumbs = @_;
2352
2353 #    my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
2354
2355     if (grep { $_ eq $target } @breadcrumbs) {
2356         die "inherit_from loop!  target backtrace:\n  "
2357             ,$target,"\n  ",join("\n  ", @breadcrumbs),"\n";
2358     }
2359
2360     if (!defined($table{$target})) {
2361         warn "Warning! target $target doesn't exist!\n";
2362         return ();
2363     }
2364     # Recurse through all inheritances.  They will be resolved on the
2365     # fly, so when this operation is done, they will all just be a
2366     # bunch of attributes with string values.
2367     # What we get here, though, are keys with references to lists of
2368     # the combined values of them all.  We will deal with lists after
2369     # this stage is done.
2370     my %combined_inheritance = ();
2371     if ($table{$target}->{inherit_from}) {
2372         my @inherit_from =
2373             map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
2374         foreach (@inherit_from) {
2375             my %inherited_config = resolve_config($_, $target, @breadcrumbs);
2376
2377             # 'template' is a marker that's considered private to
2378             # the config that had it.
2379             delete $inherited_config{template};
2380
2381             foreach (keys %inherited_config) {
2382                 if (!$combined_inheritance{$_}) {
2383                     $combined_inheritance{$_} = [];
2384                 }
2385                 push @{$combined_inheritance{$_}}, $inherited_config{$_};
2386             }
2387         }
2388     }
2389
2390     # We won't need inherit_from in this target any more, since we've
2391     # resolved all the inheritances that lead to this
2392     delete $table{$target}->{inherit_from};
2393
2394     # Now is the time to deal with those lists.  Here's the place to
2395     # decide what shall be done with those lists, all based on the
2396     # values of the target we're currently dealing with.
2397     # - If a value is a coderef, it will be executed with the list of
2398     #   inherited values as arguments.
2399     # - If the corresponding key doesn't have a value at all or is the
2400     #   empty string, the inherited value list will be run through the
2401     #   default combiner (below), and the result becomes this target's
2402     #   value.
2403     # - Otherwise, this target's value is assumed to be a string that
2404     #   will simply override the inherited list of values.
2405     my $default_combiner = add();
2406
2407     my %all_keys =
2408         map { $_ => 1 } (keys %combined_inheritance,
2409                          keys %{$table{$target}});
2410
2411     sub process_values {
2412         my $object    = shift;
2413         my $inherited = shift;  # Always a [ list ]
2414         my $target    = shift;
2415         my $entry     = shift;
2416
2417         $add_called = 0;
2418
2419         while(ref($object) eq "CODE") {
2420             $object = $object->(@$inherited);
2421         }
2422         if (!defined($object)) {
2423             return ();
2424         }
2425         elsif (ref($object) eq "ARRAY") {
2426             local $add_called;  # To make sure recursive calls don't affect it
2427             return [ map { process_values($_, $inherited, $target, $entry) }
2428                      @$object ];
2429         } elsif (ref($object) eq "") {
2430             return $object;
2431         } else {
2432             die "cannot handle reference type ",ref($object)
2433                 ," found in target ",$target," -> ",$entry,"\n";
2434         }
2435     }
2436
2437     foreach (sort keys %all_keys) {
2438         my $previous = $combined_inheritance{$_};
2439
2440         # Current target doesn't have a value for the current key?
2441         # Assign it the default combiner, the rest of this loop body
2442         # will handle it just like any other coderef.
2443         if (!exists $table{$target}->{$_}) {
2444             $table{$target}->{$_} = $default_combiner;
2445         }
2446
2447         $table{$target}->{$_} = process_values($table{$target}->{$_},
2448                                                $combined_inheritance{$_},
2449                                                $target, $_);
2450         unless(defined($table{$target}->{$_})) {
2451             delete $table{$target}->{$_};
2452         }
2453 #        if ($extra_checks &&
2454 #            $previous && !($add_called ||  $previous ~~ $table{$target}->{$_})) {
2455 #            warn "$_ got replaced in $target\n";
2456 #        }
2457     }
2458
2459     # Finally done, return the result.
2460     return %{$table{$target}};
2461 }
2462
2463 sub usage
2464         {
2465         print STDERR $usage;
2466         print STDERR "\npick os/compiler from:\n";
2467         my $j=0;
2468         my $i;
2469         my $k=0;
2470         foreach $i (sort keys %table)
2471                 {
2472                 next if $table{$i}->{template};
2473                 next if $i =~ /^debug/;
2474                 $k += length($i) + 1;
2475                 if ($k > 78)
2476                         {
2477                         print STDERR "\n";
2478                         $k=length($i);
2479                         }
2480                 print STDERR $i . " ";
2481                 }
2482         foreach $i (sort keys %table)
2483                 {
2484                 next if $table{$i}->{template};
2485                 next if $i !~ /^debug/;
2486                 $k += length($i) + 1;
2487                 if ($k > 78)
2488                         {
2489                         print STDERR "\n";
2490                         $k=length($i);
2491                         }
2492                 print STDERR $i . " ";
2493                 }
2494         print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
2495         exit(1);
2496         }
2497
2498 sub run_dofile
2499 {
2500     my $out = shift;
2501     my @templates = @_;
2502
2503     unlink $out || warn "Can't remove $out, $!"
2504         if -f $out;
2505     foreach (@templates) {
2506         die "Can't open $_, $!" unless -f $_;
2507     }
2508     my $perlcmd = (quotify("maybeshell", $config{perl}))[0];
2509     my $cmd = "$perlcmd \"-I.\" \"-Mconfigdata\" \"$dofile\" -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\"";
2510     #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
2511     system($cmd);
2512     exit 1 if $? != 0;
2513     rename("$out.new", $out) || die "Can't rename $out.new, $!";
2514 }
2515
2516 sub which
2517 {
2518     my ($name)=@_;
2519
2520     if (eval { require IPC::Cmd; 1; }) {
2521         IPC::Cmd->import();
2522         return scalar IPC::Cmd::can_run($name);
2523     } else {
2524         # if there is $directories component in splitpath,
2525         # then it's not something to test with $PATH...
2526         return $name if (File::Spec->splitpath($name))[1];
2527
2528         foreach (File::Spec->path()) {
2529             my $fullpath = catfile($_, "$name$target{exe_extension}");
2530             if (-f $fullpath and -x $fullpath) {
2531                 return $fullpath;
2532             }
2533         }
2534     }
2535 }
2536
2537 # Configuration printer ##############################################
2538
2539 sub print_table_entry
2540 {
2541     my $target = shift;
2542     my %target = resolve_config($target);
2543     my $type = shift;
2544
2545     # Don't print the templates
2546     return if $target{template};
2547
2548     my @sequence = (
2549         "sys_id",
2550         "cc",
2551         "cflags",
2552         "defines",
2553         "unistd",
2554         "ld",
2555         "lflags",
2556         "loutflag",
2557         "plib_lflags",
2558         "ex_libs",
2559         "bn_ops",
2560         "apps_aux_src",
2561         "cpuid_asm_src",
2562         "uplink_aux_src",
2563         "bn_asm_src",
2564         "ec_asm_src",
2565         "des_asm_src",
2566         "aes_asm_src",
2567         "bf_asm_src",
2568         "md5_asm_src",
2569         "cast_asm_src",
2570         "sha1_asm_src",
2571         "rc4_asm_src",
2572         "rmd160_asm_src",
2573         "rc5_asm_src",
2574         "wp_asm_src",
2575         "cmll_asm_src",
2576         "modes_asm_src",
2577         "padlock_asm_src",
2578         "chacha_asm_src",
2579         "poly1035_asm_src",
2580         "thread_scheme",
2581         "perlasm_scheme",
2582         "dso_scheme",
2583         "shared_target",
2584         "shared_cflag",
2585         "shared_defines",
2586         "shared_ldflag",
2587         "shared_rcflag",
2588         "shared_extension",
2589         "dso_extension",
2590         "obj_extension",
2591         "exe_extension",
2592         "ranlib",
2593         "ar",
2594         "arflags",
2595         "aroutflag",
2596         "rc",
2597         "rcflags",
2598         "rcoutflag",
2599         "mt",
2600         "mtflags",
2601         "mtinflag",
2602         "mtoutflag",
2603         "multilib",
2604         "build_scheme",
2605         );
2606
2607     if ($type eq "TABLE") {
2608         print "\n";
2609         print "*** $target\n";
2610         foreach (@sequence) {
2611             if (ref($target{$_}) eq "ARRAY") {
2612                 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
2613             } else {
2614                 printf "\$%-12s = %s\n", $_, $target{$_};
2615             }
2616         }
2617     } elsif ($type eq "HASH") {
2618         my $largest =
2619             length((sort { length($a) <=> length($b) } @sequence)[-1]);
2620         print "    '$target' => {\n";
2621         foreach (@sequence) {
2622             if ($target{$_}) {
2623                 if (ref($target{$_}) eq "ARRAY") {
2624                     print "      '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
2625                 } else {
2626                     print "      '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
2627                 }
2628             }
2629         }
2630         print "    },\n";
2631     }
2632 }
2633
2634 # Utility routines ###################################################
2635
2636 # On VMS, if the given file is a logical name, File::Spec::Functions
2637 # will consider it an absolute path.  There are cases when we want a
2638 # purely syntactic check without checking the environment.
2639 sub isabsolute {
2640     my $file = shift;
2641
2642     # On non-platforms, we just use file_name_is_absolute().
2643     return file_name_is_absolute($file) unless $^O eq "VMS";
2644
2645     # If the file spec includes a device or a directory spec,
2646     # file_name_is_absolute() is perfectly safe.
2647     return file_name_is_absolute($file) if $file =~ m|[:\[]|;
2648
2649     # Here, we know the given file spec isn't absolute
2650     return 0;
2651 }
2652
2653 # Makes a directory absolute and cleans out /../ in paths like foo/../bar
2654 # On some platforms, this uses rel2abs(), while on others, realpath() is used.
2655 # realpath() requires that at least all path components except the last is an
2656 # existing directory.  On VMS, the last component of the directory spec must
2657 # exist.
2658 sub absolutedir {
2659     my $dir = shift;
2660
2661     # realpath() is quite buggy on VMS.  It uses LIB$FID_TO_NAME, which
2662     # will return the volume name for the device, no matter what.  Also,
2663     # it will return an incorrect directory spec if the argument is a
2664     # directory that doesn't exist.
2665     if ($^O eq "VMS") {
2666         return rel2abs($dir);
2667     }
2668
2669     # We use realpath() on Unix, since no other will properly clean out
2670     # a directory spec.
2671     use Cwd qw/realpath/;
2672
2673     return realpath($dir);
2674 }
2675
2676 sub quotify {
2677     my %processors = (
2678         perl    => sub { my $x = shift;
2679                          $x =~ s/([\\\$\@"])/\\$1/g;
2680                          return '"'.$x.'"'; },
2681         maybeshell => sub { my $x = shift;
2682                             (my $y = $x) =~ s/([\\\"])/\\$1/g;
2683                             if ($x ne $y || $x =~ m|\s|) {
2684                                 return '"'.$y.'"';
2685                             } else {
2686                                 return $x;
2687                             }
2688                         },
2689         );
2690     my $for = shift;
2691     my $processor =
2692         defined($processors{$for}) ? $processors{$for} : sub { shift; };
2693
2694     return map { $processor->($_); } @_;
2695 }
2696
2697 # collect_from_file($filename, $line_concat_cond_re, $line_concat)
2698 # $filename is a file name to read from
2699 # $line_concat_cond_re is a regexp detecting a line continuation ending
2700 # $line_concat is a CODEref that takes care of concatenating two lines
2701 sub collect_from_file {
2702     my $filename = shift;
2703     my $line_concat_cond_re = shift;
2704     my $line_concat = shift;
2705
2706     open my $fh, $filename || die "unable to read $filename: $!\n";
2707     return sub {
2708         my $saved_line = "";
2709         $_ = "";
2710         while (<$fh>) {
2711             s|\R$||;
2712             if (defined $line_concat) {
2713                 $_ = $line_concat->($saved_line, $_);
2714                 $saved_line = "";
2715             }
2716             if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2717                 $saved_line = $_;
2718                 next;
2719             }
2720             return $_;
2721         }
2722         die "$filename ending with continuation line\n" if $_;
2723         close $fh;
2724         return undef;
2725     }
2726 }
2727
2728 # collect_from_array($array, $line_concat_cond_re, $line_concat)
2729 # $array is an ARRAYref of lines
2730 # $line_concat_cond_re is a regexp detecting a line continuation ending
2731 # $line_concat is a CODEref that takes care of concatenating two lines
2732 sub collect_from_array {
2733     my $array = shift;
2734     my $line_concat_cond_re = shift;
2735     my $line_concat = shift;
2736     my @array = (@$array);
2737
2738     return sub {
2739         my $saved_line = "";
2740         $_ = "";
2741         while (defined($_ = shift @array)) {
2742             s|\R$||;
2743             if (defined $line_concat) {
2744                 $_ = $line_concat->($saved_line, $_);
2745                 $saved_line = "";
2746             }
2747             if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2748                 $saved_line = $_;
2749                 next;
2750             }
2751             return $_;
2752         }
2753         die "input text ending with continuation line\n" if $_;
2754         return undef;
2755     }
2756 }
2757
2758 # collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
2759 # $lineiterator is a CODEref that delivers one line at a time.
2760 # All following arguments are regex/CODEref pairs, where the regexp detects a
2761 # line and the CODEref does something with the result of the regexp.
2762 sub collect_information {
2763     my $lineiterator = shift;
2764     my %collectors = @_;
2765
2766     while(defined($_ = $lineiterator->())) {
2767         s|\R$||;
2768         my $found = 0;
2769         if ($collectors{"BEFORE"}) {
2770             $collectors{"BEFORE"}->($_);
2771         }
2772         foreach my $re (keys %collectors) {
2773             if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
2774                 $collectors{$re}->($lineiterator);
2775                 $found = 1;
2776             };
2777         }
2778         if ($collectors{"OTHERWISE"}) {
2779             $collectors{"OTHERWISE"}->($lineiterator, $_)
2780                 unless $found || !defined $collectors{"OTHERWISE"};
2781         }
2782         if ($collectors{"AFTER"}) {
2783             $collectors{"AFTER"}->($_);
2784         }
2785     }
2786 }
2787
2788 # tokenize($line)
2789 # $line is a line of text to split up into tokens
2790 # returns a list of tokens
2791 #
2792 # Tokens are divided by spaces.  If the tokens include spaces, they
2793 # have to be quoted with single or double quotes.  Double quotes
2794 # inside a double quoted token must be escaped.  Escaping is done
2795 # with backslash.
2796 # Basically, the same quoting rules apply for " and ' as in any
2797 # Unix shell.
2798 sub tokenize {
2799     my $line = my $debug_line = shift;
2800     my @result = ();
2801
2802     while ($line =~ s|^\s+||, $line ne "") {
2803         my $token = "";
2804         while ($line ne "" && $line !~ m|^\s|) {
2805             if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
2806                 $token .= $1;
2807                 $line = $';
2808             } elsif ($line =~ m/^'([^']*)'/) {
2809                 $token .= $1;
2810                 $line = $';
2811             } elsif ($line =~ m/^(\S+)/) {
2812                 $token .= $1;
2813                 $line = $';
2814             }
2815         }
2816         push @result, $token;
2817     }
2818
2819     if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
2820         print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
2821         print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";
2822     }
2823     return @result;
2824 }