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