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