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