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