]> 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
Fix building with enable-trace
[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
51583cb8
RL		 2212
2213 # Go through the sources of all libraries and check that the same basename
2214 # doesn't appear more than once. Some static library archivers depend on
2215 # them being unique.
2216 {
2217 my $err = 0;
2218 foreach my $prod (keys %{$unified_info{libraries}}) {
2219 my @prod_sources =
2220 map { keys %{$unified_info{sources}->{$_}} }
2221 keys %{$unified_info{sources}->{$prod}};
2222 my %srccnt = ();
2223
2224 # Count how many times a given each source basename
2225 # appears for each product.
2226 foreach my $src (@prod_sources) {
2227 $srccnt{basename $src}++;
2228 }
2229
2230 foreach my $src (keys %srccnt) {
2231 if ((my $cnt = $srccnt{$src}) > 1) {
2232 print STDERR "$src appears $cnt times for the product $prod\n";
2233 $err++
2234 }
2235 }
2236 }
2237 die if $err > 0;
2238 }
2239
1b5ad51f
RL		 2240 # Massage the result
2241
e431bcfa
RL		 2242 # If we depend on a header file or a perl module, add an inclusion of
2243 # its directory to allow smoothe inclusion
2244 foreach my $dest (keys %{$unified_info{depends}}) {
2245 next if $dest eq "";
2246 foreach my $d (keys %{$unified_info{depends}->{$dest}}) {
2247 next unless $d =~ /\.(h|pm)$/;
906032d5
RL		 2248 my $i = dirname($d);
2249 my $spot =
2250 $d eq "configdata.pm" || defined($unified_info{generate}->{$d})
2251 ? 'build' : 'source';
2252 push @{$unified_info{includes}->{$dest}->{$spot}}, $i
2253 unless grep { $_ eq $i } @{$unified_info{includes}->{$dest}->{$spot}};
e431bcfa
RL		 2254 }
2255 }
2256
ef2dfc99 2257 # Go through all intermediary files and change their names to something that
bec2db18
RL		 2258 # reflects what they will be built for. Note that for some source files,
2259 # this leads to duplicate object files because they are used multiple times.
2260 # the goal is to rename all object files according to this scheme:
2261 # {productname}-{midfix}-{origobjname}.[o|res]
2262 # the {midfix} is a keyword indicating the type of product, which is mostly
2263 # valuable for libraries since they come in two forms.
2264 #
2265 # This also reorganises the {sources} and {shared_sources} so that the
2266 # former only contains ALL object files that are supposed to end up in
2267 # static libraries and programs, while the latter contains ALL object files
2268 # that are supposed to end up in shared libraries and DSOs.
2269 # The main reason for having two different source structures is to allow
2270 # the same name to be used for the static and the shared variants of a
2271 # library.
2272 {
2273 # Take copies so we don't get interference from added stuff
2274 my %unified_copy = ();
2275 foreach (('sources', 'shared_sources')) {
2276 $unified_copy{$_} = { %{$unified_info{$_}} }
2277 if defined($unified_info{$_});
2278 delete $unified_info{$_};
2279 }
1842f369 2280 foreach my $prodtype (('programs', 'libraries', 'modules', 'scripts')) {
bec2db18
RL		 2281 # $intent serves multi purposes:
2282 # - give a prefix for the new object files names
2283 # - in the case of libraries, rearrange the object files so static
2284 # libraries use the 'sources' structure exclusively, while shared
2285 # libraries use the 'shared_sources' structure exclusively.
2286 my $intent = {
2287 programs => { bin => { src => [ 'sources' ],
2288 dst => 'sources' } },
2289 libraries => { lib => { src => [ 'sources' ],
2290 dst => 'sources' },
2291 shlib => { prodselect =>
2292 sub { grep !/\.a$/, @_ },
2293 src => [ 'sources',
2294 'shared_sources' ],
2295 dst => 'shared_sources' } },
22b41467
RL		 2296 modules => { dso => { src => [ 'sources' ],
2297 dst => 'sources' } },
bec2db18
RL		 2298 scripts => { script => { src => [ 'sources' ],
2299 dst => 'sources' } }
2300 } -> {$prodtype};
2301 foreach my $kind (keys %$intent) {
856b1b65
RL		 2302 next if ($intent->{$kind}->{dst} eq 'shared_sources'
2303 && $disabled{shared});
2304
bec2db18
RL		 2305 my @src = @{$intent->{$kind}->{src}};
2306 my $dst = $intent->{$kind}->{dst};
2307 my $prodselect = $intent->{$kind}->{prodselect} // sub { @_ };
2308 foreach my $prod ($prodselect->(keys %{$unified_info{$prodtype}})) {
2309 # %prod_sources has all applicable objects as keys, and
2310 # their corresponding sources as values
2311 my %prod_sources =
2312 map { $_ => [ keys %{$unified_copy{sources}->{$_}} ] }
2313 map { keys %{$unified_copy{$_}->{$prod}} }
2314 @src;
2315 foreach (keys %prod_sources) {
ef2dfc99
RL		 2316 # Only affect object files and resource files,
2317 # the others simply get a new value
2318 # (+1 instead of -1)
bec2db18
RL		 2319 if ($_ =~ /\.(o|res)$/) {
2320 (my $prodname = $prod) =~ s|\.a$||;
2321 my $newobj =
2322 catfile(dirname($_),
2323 basename($prodname)
2324 . '-' . $kind
2325 . '-' . basename($_));
2326 $unified_info{$dst}->{$prod}->{$newobj} = 1;
2327 foreach my $src (@{$prod_sources{$_}}) {
2328 $unified_info{sources}->{$newobj}->{$src} = 1;
2329 }
2330 # Adjust dependencies
2331 foreach my $deps (keys %{$unified_info{depends}->{$_}}) {
2332 $unified_info{depends}->{$_}->{$deps} = -1;
2333 $unified_info{depends}->{$newobj}->{$deps} = 1;
2334 }
2335 # Adjust includes
2336 foreach my $k (('source', 'build')) {
2337 next unless
2338 defined($unified_info{includes}->{$_}->{$k});
2339 my @incs = @{$unified_info{includes}->{$_}->{$k}};
2340 $unified_info{includes}->{$newobj}->{$k} = [ @incs ];
2341 }
2342 } else {
2343 $unified_info{$dst}->{$prod}->{$_} = 1;
2344 }
2345 }
2346 }
2347 }
2348 }
2349 }
51583cb8 2350
bec2db18
RL		 2351 # At this point, we have a number of sources with the value -1. They
2352 # aren't part of the local build and are probably meant for a different
2353 # platform, and can therefore be cleaned away. That happens when making
2354 # %unified_info more efficient below.
2355
9fe2bb77
RL		 2356 ### Make unified_info a bit more efficient
2357 # One level structures
1842f369 2358 foreach (("programs", "libraries", "modules", "scripts")) {
9fe2bb77
RL		 2359 $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
2360 }
2361 # Two level structures
c91f24d4 2362 foreach my $l1 (("sources", "shared_sources", "ldadd", "depends")) {
9fe2bb77 2363 foreach my $l2 (sort keys %{$unified_info{$l1}}) {
bec2db18
RL		 2364 my @items =
2365 sort
2366 grep { $unified_info{$l1}->{$l2}->{$_} > 0 }
2367 keys %{$unified_info{$l1}->{$l2}};
2368 if (@items) {
2369 $unified_info{$l1}->{$l2} = [ @items ];
2370 } else {
2371 delete $unified_info{$l1}->{$l2};
2372 }
9fe2bb77
RL		 2373 }
2374 }
b96ab5e6
RL		 2375 # Defines
2376 foreach my $dest (sort keys %{$unified_info{defines}}) {
2377 $unified_info{defines}->{$dest}
2378 = [ map { $_.$unified_info{defines}->{$dest}->{$_} }
2379 sort keys %{$unified_info{defines}->{$dest}} ];
2380 }
4748f890
RL		 2381 # Includes
2382 foreach my $dest (sort keys %{$unified_info{includes}}) {
2383 if (defined($unified_info{includes}->{$dest}->{build})) {
e431bcfa
RL		 2384 my @source_includes = ();
2385 @source_includes = ( @{$unified_info{includes}->{$dest}->{source}} )
2386 if defined($unified_info{includes}->{$dest}->{source});
4748f890
RL		 2387 $unified_info{includes}->{$dest} =
2388 [ @{$unified_info{includes}->{$dest}->{build}} ];
2389 foreach my $inc (@source_includes) {
2390 push @{$unified_info{includes}->{$dest}}, $inc
2391 unless grep { $_ eq $inc } @{$unified_info{includes}->{$dest}};
2392 }
609e4be8 2393 } elsif (defined($unified_info{includes}->{$dest}->{source})) {
4748f890
RL		 2394 $unified_info{includes}->{$dest} =
2395 [ @{$unified_info{includes}->{$dest}->{source}} ];
609e4be8
RL		 2396 } else {
2397 delete $unified_info{includes}->{$dest};
4748f890
RL		 2398 }
2399 }
b6e66075
RL		 2400
2401 # For convenience collect information regarding directories where
2402 # files are generated, those generated files and the end product
2403 # they end up in where applicable. Then, add build rules for those
2404 # directories
2405 my %loopinfo = ( "lib" => [ @{$unified_info{libraries}} ],
1842f369 2406 "dso" => [ @{$unified_info{modules}} ],
b6e66075
RL		 2407 "bin" => [ @{$unified_info{programs}} ],
2408 "script" => [ @{$unified_info{scripts}} ] );
2409 foreach my $type (keys %loopinfo) {
2410 foreach my $product (@{$loopinfo{$type}}) {
2411 my %dirs = ();
2412 my $pd = dirname($product);
2413
3bed01a0 2414 foreach (@{$unified_info{sources}->{$product} // []},
b6e66075
RL		 2415 @{$unified_info{shared_sources}->{$product} // []}) {
2416 my $d = dirname($_);
2417
2418 # We don't want to create targets for source directories
2419 # when building out of source
2420 next if ($config{sourcedir} ne $config{builddir}
2421 && $d =~ m|^\Q$config{sourcedir}\E|);
2422 # We already have a "test" target, and the current directory
2423 # is just silly to make a target for
2424 next if $d eq "test" || $d eq ".";
2425
2426 $dirs{$d} = 1;
2427 push @{$unified_info{dirinfo}->{$d}->{deps}}, $_
2428 if $d ne $pd;
2429 }
2430 foreach (keys %dirs) {
2431 push @{$unified_info{dirinfo}->{$_}->{products}->{$type}},
2432 $product;
2433 }
2434 }
2435 }
9fe2bb77
RL		 2436}
2437
2438# For the schemes that need it, we provide the old *_obj configs
2439# from the *_asm_obj ones
3a55c92b 2440foreach (grep /_(asm|aux)_src$/, keys %target) {
9fe2bb77 2441 my $src = $_;
3a55c92b 2442 (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
ea241958
RL		 2443 $target{$obj} = $target{$src};
2444 $target{$obj} =~ s/\.[csS]\b/.o/g; # C and assembler
2445 $target{$obj} =~ s/\.(cc|cpp)\b/_cc.o/g; # C++
9fe2bb77
RL		 2446}
2447
291e94df
RL		 2448# Write down our configuration where it fits #########################
2449
b1fafff6 2450print "Creating configdata.pm\n";
291e94df
RL		 2451open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
2452print OUT <<"EOF";
abe256e7 2453#! $config{HASHBANGPERL}
b1fafff6 2454
291e94df
RL		 2455package configdata;
2456
2457use strict;
2458use warnings;
2459
2460use Exporter;
2461#use vars qw(\@ISA \@EXPORT);
2462our \@ISA = qw(Exporter);
538f38db 2463our \@EXPORT = qw(\%config \%target \%disabled \%withargs \%unified_info \@disablables \@disablables_int);
291e94df
RL		 2464
2465EOF
2466print OUT "our %config = (\n";
2467foreach (sort keys %config) {
2468 if (ref($config{$_}) eq "ARRAY") {
84f32c84
DMSP		 2469 print OUT " ", $_, " => [ ", join(", ",
2470 map { quotify("perl", $_) }
2471 @{$config{$_}}), " ],\n";
7ecdf18d 2472 } elsif (ref($config{$_}) eq "HASH") {
84f32c84 2473 print OUT " ", $_, " => {";
7ecdf18d
RL		 2474 if (scalar keys %{$config{$_}} > 0) {
2475 print OUT "\n";
2476 foreach my $key (sort keys %{$config{$_}}) {
2477 print OUT " ",
2478 join(" => ",
2479 quotify("perl", $key),
2480 defined $config{$_}->{$key}
2481 ? quotify("perl", $config{$_}->{$key})
2482 : "undef");
2483 print OUT ",\n";
2484 }
2485 print OUT " ";
2486 }
2487 print OUT "},\n";
291e94df 2488 } else {
84f32c84 2489 print OUT " ", $_, " => ", quotify("perl", $config{$_}), ",\n"
291e94df
RL		 2490 }
2491}
2492print OUT <<"EOF";
2493);
2494
2495EOF
2496print OUT "our %target = (\n";
2497foreach (sort keys %target) {
2498 if (ref($target{$_}) eq "ARRAY") {
84f32c84
DMSP		 2499 print OUT " ", $_, " => [ ", join(", ",
2500 map { quotify("perl", $_) }
2501 @{$target{$_}}), " ],\n";
291e94df 2502 } else {
84f32c84 2503 print OUT " ", $_, " => ", quotify("perl", $target{$_}), ",\n"
291e94df
RL		 2504 }
2505}
2506print OUT <<"EOF";
2507);
2508
96d2d7bc
RL		 2509EOF
2510print OUT "our \%available_protocols = (\n";
2511print OUT " tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n";
2512print OUT " dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n";
2513print OUT <<"EOF";
2514);
2515
3850f8cb
RL		 2516EOF
2517print OUT "our \@disablables = (\n";
2518foreach (@disablables) {
2519 print OUT " ", quotify("perl", $_), ",\n";
2520}
2521print OUT <<"EOF";
2522);
2523
538f38db
RL		 2524EOF
2525print OUT "# The following come from Configure's @disablables_int\n";
2526print OUT "our \@disablables_int = (\n";
2527foreach (@disablables_int) {
2528 print OUT " ", quotify("perl", $_), ",\n";
2529}
2530print OUT <<"EOF";
2531);
2532
96d2d7bc
RL		 2533EOF
2534print OUT "our \%disabled = (\n";
2535foreach (sort keys %disabled) {
2536 print OUT " ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n";
2537}
2538print OUT <<"EOF";
2539);
2540
291e94df 2541EOF
107b5792
RL		 2542print OUT "our %withargs = (\n";
2543foreach (sort keys %withargs) {
2544 if (ref($withargs{$_}) eq "ARRAY") {
84f32c84
DMSP		 2545 print OUT " ", $_, " => [ ", join(", ",
2546 map { quotify("perl", $_) }
2547 @{$withargs{$_}}), " ],\n";
107b5792 2548 } else {
84f32c84 2549 print OUT " ", $_, " => ", quotify("perl", $withargs{$_}), ",\n"
107b5792
RL		 2550 }
2551}
2552print OUT <<"EOF";
2553);
edd4d402 2554
107b5792 2555EOF
ddf1847d 2556if ($builder eq "unified") {
9fe2bb77
RL		 2557 my $recurse;
2558 $recurse = sub {
2559 my $indent = shift;
2560 foreach (@_) {
2561 if (ref $_ eq "ARRAY") {
2562 print OUT " "x$indent, "[\n";
2563 foreach (@$_) {
2564 $recurse->($indent + 4, $_);
2565 }
2566 print OUT " "x$indent, "],\n";
2567 } elsif (ref $_ eq "HASH") {
2568 my %h = %$_;
2569 print OUT " "x$indent, "{\n";
2570 foreach (sort keys %h) {
2571 if (ref $h{$_} eq "") {
2572 print OUT " "x($indent + 4), quotify("perl", $_), " => ", quotify("perl", $h{$_}), ",\n";
2573 } else {
2574 print OUT " "x($indent + 4), quotify("perl", $_), " =>\n";
2575 $recurse->($indent + 8, $h{$_});
2576 }
2577 }
2578 print OUT " "x$indent, "},\n";
2579 } else {
2580 print OUT " "x$indent, quotify("perl", $_), ",\n";
2581 }
2582 }
2583 };
2584 print OUT "our %unified_info = (\n";
2585 foreach (sort keys %unified_info) {
2586 if (ref $unified_info{$_} eq "") {
2587 print OUT " "x4, quotify("perl", $_), " => ", quotify("perl", $unified_info{$_}), ",\n";
2588 } else {
2589 print OUT " "x4, quotify("perl", $_), " =>\n";
2590 $recurse->(8, $unified_info{$_});
2591 }
2592 }
2593 print OUT <<"EOF";
2594);
2595
2596EOF
2597}
047f0292
RL		 2598print OUT
2599 "# The following data is only used when this files is use as a script\n";
abe256e7 2600print OUT "my \@makevars = (\n";
b1fafff6 2601foreach (sort keys %user) {
abe256e7 2602 print OUT " '",$_,"',\n";
b1fafff6
RL		 2603}
2604print OUT ");\n";
ca372414
RL		 2605print OUT "my \%disabled_info = (\n";
2606foreach my $what (sort keys %disabled_info) {
2607 print OUT " '$what' => {\n";
2608 foreach my $info (sort keys %{$disabled_info{$what}}) {
2609 if (ref $disabled_info{$what}->{$info} eq 'ARRAY') {
2610 print OUT " $info => [ ",
2611 join(', ', map { "'$_'" } @{$disabled_info{$what}->{$info}}),
2612 " ],\n";
2613 } else {
2614 print OUT " $info => '", $disabled_info{$what}->{$info},
2615 "',\n";
2616 }
2617 }
2618 print OUT " },\n";
2619}
2620print OUT ");\n";
f729ba55 2621print OUT 'my @user_crossable = qw( ', join (' ', @user_crossable), " );\n";
b1fafff6 2622print OUT << 'EOF';
b1fafff6
RL		 2623# If run directly, we can give some answers, and even reconfigure
2624unless (caller) {
2625 use Getopt::Long;
2626 use File::Spec::Functions;
2627 use File::Basename;
2628 use Pod::Usage;
2629
2630 my $here = dirname($0);
2631
2632 my $dump = undef;
2633 my $cmdline = undef;
ca372414 2634 my $options = undef;
50ea9d2b 2635 my $target = undef;
b1fafff6
RL		 2636 my $envvars = undef;
2637 my $makevars = undef;
2638 my $buildparams = undef;
2639 my $reconf = undef;
2640 my $verbose = undef;
2641 my $help = undef;
2642 my $man = undef;
2643 GetOptions('dump|d' => \$dump,
2644 'command-line|c' => \$cmdline,
ca372414 2645 'options|o' => \$options,
50ea9d2b 2646 'target|t' => \$target,
b1fafff6
RL		 2647 'environment|e' => \$envvars,
2648 'make-variables|m' => \$makevars,
2649 'build-parameters|b' => \$buildparams,
2650 'reconfigure|reconf|r' => \$reconf,
2651 'verbose|v' => \$verbose,
2652 'help' => \$help,
2653 'man' => \$man)
2654 or die "Errors in command line arguments\n";
2655
50ea9d2b 2656 unless ($dump || $cmdline || $options || $target || $envvars || $makevars
ca372414 2657 || $buildparams || $reconf || $verbose || $help || $man) {
b1fafff6
RL		 2658 print STDERR <<"_____";
2659You must give at least one option.
2660For more information, do '$0 --help'
2661_____
2662 exit(2);
2663 }
2664
2665 if ($help) {
2666 pod2usage(-exitval => 0,
2667 -verbose => 1);
2668 }
2669 if ($man) {
2670 pod2usage(-exitval => 0,
2671 -verbose => 2);
2672 }
2673 if ($dump || $cmdline) {
d5fa7035 2674 print "\nCommand line (with current working directory = $here):\n\n";
b1fafff6 2675 print ' ',join(' ',
9e265322 2676 $config{PERL},
b1fafff6
RL		 2677 catfile($config{sourcedir}, 'Configure'),
2678 @{$config{perlargv}}), "\n";
d5fa7035
RL		 2679 print "\nPerl information:\n\n";
2680 print ' ',$config{perl_cmd},"\n";
2681 print ' ',$config{perl_version},' for ',$config{perl_archname},"\n";
b1fafff6 2682 }
ca372414
RL		 2683 if ($dump || $options) {
2684 my $longest = 0;
0b80103b 2685 my $longest2 = 0;
ca372414
RL		 2686 foreach my $what (@disablables) {
2687 $longest = length($what) if $longest < length($what);
1d2c6b7d
RL		 2688 $longest2 = length($disabled{$what})
2689 if $disabled{$what} && $longest2 < length($disabled{$what});
ca372414
RL		 2690 }
2691 print "\nEnabled features:\n\n";
2692 foreach my $what (@disablables) {
2693 print " $what\n" unless $disabled{$what};
2694 }
2695 print "\nDisabled features:\n\n";
2696 foreach my $what (@disablables) {
2697 if ($disabled{$what}) {
2698 print " $what", ' ' x ($longest - length($what) + 1),
0b80103b 2699 "[$disabled{$what}]", ' ' x ($longest2 - length($disabled{$what}) + 1);
ca372414
RL		 2700 print $disabled_info{$what}->{macro}
2701 if $disabled_info{$what}->{macro};
2702 print ' (skip ',
2703 join(', ', @{$disabled_info{$what}->{skipped}}),
2704 ')'
2705 if $disabled_info{$what}->{skipped};
2706 print "\n";
2707 }
2708 }
2709 }
50ea9d2b
RL		 2710 if ($dump || $target) {
2711 print "\nConfig target attributes:\n\n";
2712 foreach (sort keys %target) {
2713 next if $_ =~ m|^_| || $_ eq 'template';
2714 my $quotify = sub {
2715 map { (my $x = $_) =~ s|([\\\$\@"])|\\$1|g; "\"$x\""} @_;
2716 };
2717 print ' ', $_, ' => ';
2718 if (ref($target{$_}) eq "ARRAY") {
2719 print '[ ', join(', ', $quotify->(@{$target{$_}})), " ],\n";
2720 } else {
2721 print $quotify->($target{$_}), ",\n"
2722 }
2723 }
2724 }
b1fafff6
RL		 2725 if ($dump || $envvars) {
2726 print "\nRecorded environment:\n\n";
2727 foreach (sort keys %{$config{perlenv}}) {
2728 print ' ',$_,' = ',($config{perlenv}->{$_} || ''),"\n";
2729 }
2730 }
2731 if ($dump || $makevars) {
2732 print "\nMakevars:\n\n";
abe256e7 2733 foreach my $var (@makevars) {
f729ba55 2734 my $prefix = '';
abe256e7 2735 $prefix = $config{CROSS_COMPILE}
f729ba55 2736 if grep { $var eq $_ } @user_crossable;
b700bc59 2737 $prefix //= '';
f729ba55 2738 print ' ',$var,' ' x (16 - length $var),'= ',
abe256e7
RL		 2739 (ref $config{$var} eq 'ARRAY'
2740 ? join(' ', @{$config{$var}})
2741 : $prefix.$config{$var}),
b1fafff6 2742 "\n"
abe256e7 2743 if defined $config{$var};
b1fafff6
RL		 2744 }
2745
2746 my @buildfile = ($config{builddir}, $config{build_file});
2747 unshift @buildfile, $here
2748 unless file_name_is_absolute($config{builddir});
2749 my $buildfile = canonpath(catdir(@buildfile));
2750 print <<"_____";
2751
2752NOTE: These variables only represent the configuration view. The build file
2753template may have processed these variables further, please have a look at the
2754build file for more exact data:
2755 $buildfile
2756_____
2757 }
2758 if ($dump || $buildparams) {
2759 my @buildfile = ($config{builddir}, $config{build_file});
2760 unshift @buildfile, $here
2761 unless file_name_is_absolute($config{builddir});
2762 print "\nbuild file:\n\n";
2763 print " ", canonpath(catfile(@buildfile)),"\n";
2764
2765 print "\nbuild file templates:\n\n";
2766 foreach (@{$config{build_file_templates}}) {
2767 my @tmpl = ($_);
2768 unshift @tmpl, $here
2769 unless file_name_is_absolute($config{sourcedir});
2770 print ' ',canonpath(catfile(@tmpl)),"\n";
2771 }
2772 }
2773 if ($reconf) {
2774 if ($verbose) {
2775 print 'Reconfiguring with: ', join(' ',@{$config{perlargv}}), "\n";
84f32c84
DMSP		 2776 foreach (sort keys %{$config{perlenv}}) {
2777 print ' ',$_,' = ',($config{perlenv}->{$_} || ""),"\n";
2778 }
b1fafff6
RL		 2779 }
2780
2781 chdir $here;
2782 exec $^X,catfile($config{sourcedir}, 'Configure'),'reconf';
2783 }
2784}
2785
27861;
2787
2788__END__
2789
2790=head1 NAME
2791
2792configdata.pm - configuration data for OpenSSL builds
2793
2794=head1 SYNOPSIS
2795
2796Interactive:
2797
2798 perl configdata.pm [options]
2799
2800As data bank module:
2801
2802 use configdata;
f2d4be3b 2803
b1fafff6
RL		 2804=head1 DESCRIPTION
2805
2806This module can be used in two modes, interactively and as a module containing
2807all the data recorded by OpenSSL's Configure script.
2808
2809When used interactively, simply run it as any perl script, with at least one
2810option, and you will get the information you ask for. See L</OPTIONS> below.
2811
2812When loaded as a module, you get a few databanks with useful information to
2813perform build related tasks. The databanks are:
2814
2815 %config Configured things.
2816 %target The OpenSSL config target with all inheritances
2817 resolved.
2818 %disabled The features that are disabled.
2819 @disablables The list of features that can be disabled.
2820 %withargs All data given through --with-THING options.
2821 %unified_info All information that was computed from the build.info
2822 files.
2823
2824=head1 OPTIONS
2825
2826=over 4
2827
2828=item B<--help>
2829
2830Print a brief help message and exit.
2831
2832=item B<--man>
2833
2834Print the manual page and exit.
2835
85d6ad34 2836=item B<--dump> | B<-d>
b1fafff6
RL		 2837
2838Print all relevant configuration data. This is equivalent to B<--command-line>
50ea9d2b
RL		 2839B<--options> B<--target> B<--environment> B<--make-variables>
2840B<--build-parameters>.
b1fafff6
RL		 2841
2842=item B<--command-line> | B<-c>
2843
2844Print the current configuration command line.
2845
ca372414
RL		 2846=item B<--options> | B<-o>
2847
2848Print the features, both enabled and disabled, and display defined macro and
2849skipped directories where applicable.
2850
50ea9d2b
RL		 2851=item B<--target> | B<-t>
2852
2853Print the config attributes for this config target.
2854
b1fafff6
RL		 2855=item B<--environment> | B<-e>
2856
2857Print the environment variables and their values at the time of configuration.
2858
2859=item B<--make-variables> | B<-m>
2860
2861Print the main make variables generated in the current configuration
2862
2863=item B<--build-parameters> | B<-b>
2864
2865Print the build parameters, i.e. build file and build file templates.
2866
2867=item B<--reconfigure> | B<--reconf> | B<-r>
2868
2869Redo the configuration.
2870
2871=item B<--verbose> | B<-v>
2872
2873Verbose output.
2874
2875=back
2876
2877=cut
2878
2879EOF
2880close(OUT);
2881if ($builder_platform eq 'unix') {
2882 my $mode = (0755 & ~umask);
2883 chmod $mode, 'configdata.pm'
2884 or warn sprintf("WARNING: Couldn't change mode for 'configdata.pm' to 0%03o: %s\n",$mode,$!);
2885}
cba5068d 2886
88087414 2887my %builders = (
9fe2bb77 2888 unified => sub {
b1fafff6 2889 print 'Creating ',$target{build_file},"\n";
ddf1847d 2890 run_dofile(catfile($blddir, $target{build_file}),
1967a42e 2891 @{$config{build_file_templates}});
9fe2bb77 2892 },
88087414
RL		 2893 );
2894
ddf1847d 2895$builders{$builder}->($builder_platform, @builder_opts);
fce0ba5f 2896
8937a4ed
RL		 2897$SIG{__DIE__} = $orig_death_handler;
2898
9c62a279 2899print <<"EOF" if ($disabled{threads} eq "unavailable");
5f8d5c96
BM		 2900
2901The library could not be configured for supporting multi-threaded
2902applications as the compiler options required on this system are not known.
ff1b7e09 2903See file INSTALL for details if you need multi-threading.
ec577822
BM		 2904EOF
2905
76ffb43d 2906print <<"EOF" if ($no_shared_warn);
2964ba8c 2907
ae48242c
RL		 2908The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
2909platform, so we will pretend you gave the option 'no-pic', which also disables
2910'shared' and 'dynamic-engine'. If you know how to implement shared libraries
2911or position independent code, please let us know (but please first make sure
2912you have tried with a current version of OpenSSL).
2e31ef03
RS		 2913EOF
2914
820e414d
RL		 2915print <<"EOF";
2916
2917**********************************************************************
2918*** ***
41349b5e 2919*** OpenSSL has been successfully configured ***
820e414d 2920*** ***
41349b5e
DMSP		 2921*** If you encounter a problem while building, please open an ***
2922*** issue on GitHub <https://github.com/openssl/openssl/issues> ***
2923*** and include the output from the following command: ***
2924*** ***
2925*** perl configdata.pm --dump ***
2926*** ***
2927*** (If you are new to OpenSSL, you might want to consult the ***
2928*** 'Troubleshooting' section in the INSTALL file first) ***
820e414d
RL		 2929*** ***
2930**********************************************************************
2931EOF
2932
d02b48c6
RE		 2933exit(0);
2934
bd5192b1
RL		 2935######################################################################
2936#
2937# Helpers and utility functions
2938#
2939
8937a4ed
RL		 2940# Death handler, to print a helpful message in case of failure #######
2941#
2942sub death_handler {
eb807d53 2943 die @_ if $^S; # To prevent the added message in eval blocks
8937a4ed 2944 my $build_file = $target{build_file} // "build file";
eb807d53 2945 my @message = ( <<"_____", @_ );
8937a4ed
RL		 2946
2947Failure! $build_file wasn't produced.
2948Please read INSTALL and associated NOTES files. You may also have to look over
2949your available compiler tool chain or change your configuration.
2950
2951_____
eb807d53
RL		 2952
2953 # Dying is terminal, so it's ok to reset the signal handler here.
2954 $SIG{__DIE__} = $orig_death_handler;
2955 die @message;
8937a4ed
RL		 2956}
2957
bd5192b1
RL		 2958# Configuration file reading #########################################
2959
1f2e1cd5
RL		 2960# Note: All of the helper functions are for lazy evaluation. They all
2961# return a CODE ref, which will return the intended value when evaluated.
2962# Thus, whenever there's mention of a returned value, it's about that
2963# intended value.
2964
bd5192b1 2965# Helper function to implement conditional inheritance depending on the
00b0d663 2966# value of $disabled{asm}. Used in inherit_from values as follows:
bd5192b1
RL		 2967#
2968# inherit_from => [ "template", asm("asm_tmpl") ]
2969#
2970sub asm {
2971 my @x = @_;
2972 sub {
84f32c84 2973 $disabled{asm} ? () : @x;
bd5192b1
RL		 2974 }
2975}
2976
1f2e1cd5
RL		 2977# Helper function to implement conditional value variants, with a default
2978# plus additional values based on the value of $config{build_type}.
2979# Arguments are given in hash table form:
2980#
2981# picker(default => "Basic string: ",
2982# debug => "debug",
2983# release => "release")
2984#
2985# When configuring with --debug, the resulting string will be
2986# "Basic string: debug", and when not, it will be "Basic string: release"
2987#
2988# This can be used to create variants of sets of flags according to the
2989# build type:
2990#
2991# cflags => picker(default => "-Wall",
2992# debug => "-g -O0",
2993# release => "-O3")
2994#
2995sub picker {
2996 my %opts = @_;
2997 return sub { add($opts{default} || (),
2998 $opts{$config{build_type}} || ())->(); }
2999}
3000
3001# Helper function to combine several values of different types into one.
3002# This is useful if you want to combine a string with the result of a
3003# lazy function, such as:
3004#
3005# cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
3006#
3007sub combine {
3008 my @stuff = @_;
3009 return sub { add(@stuff)->(); }
3010}
3011
3012# Helper function to implement conditional values depending on the value
3013# of $disabled{threads}. Can be used as follows:
3014#
3015# cflags => combine("-Wall", threads("-pthread"))
3016#
3017sub threads {
3018 my @flags = @_;
3019 return sub { add($disabled{threads} ? () : @flags)->(); }
3020}
3021
60aa6c1a
AP		 3022sub shared {
3023 my @flags = @_;
3024 return sub { add($disabled{shared} ? () : @flags)->(); }
3025}
1f2e1cd5 3026
9c62a279 3027our $add_called = 0;
88087414
RL		 3028# Helper function to implement adding values to already existing configuration
3029# values. It handles elements that are ARRAYs, CODEs and scalars
3030sub _add {
3031 my $separator = shift;
3032
bcb1977b
RL		 3033 # If there's any ARRAY in the collection of values OR the separator
3034 # is undef, we will return an ARRAY of combined values, otherwise a
3035 # string of joined values with $separator as the separator.
3036 my $found_array = !defined($separator);
88087414
RL		 3037
3038 my @values =
84f32c84
DMSP		 3039 map {
3040 my $res = $_;
3041 while (ref($res) eq "CODE") {
3042 $res = $res->();
3043 }
3044 if (defined($res)) {
3045 if (ref($res) eq "ARRAY") {
3046 $found_array = 1;
3047 @$res;
3048 } else {
3049 $res;
3050 }
3051 } else {
3052 ();
3053 }
88087414
RL		 3054 } (@_);
3055
9c62a279
RL		 3056 $add_called = 1;
3057
88087414 3058 if ($found_array) {
84f32c84 3059 [ @values ];
88087414 3060 } else {
84f32c84 3061 join($separator, grep { defined($_) && $_ ne "" } @values);
88087414
RL		 3062 }
3063}
3064sub add_before {
bdcd83e1
RL		 3065 my $separator = " ";
3066 if (ref($_[$#_]) eq "HASH") {
3067 my $opts = pop;
3068 $separator = $opts->{separator};
3069 }
88087414
RL		 3070 my @x = @_;
3071 sub { _add($separator, @x, @_) };
3072}
3073sub add {
bdcd83e1
RL		 3074 my $separator = " ";
3075 if (ref($_[$#_]) eq "HASH") {
3076 my $opts = pop;
3077 $separator = $opts->{separator};
3078 }
88087414
RL		 3079 my @x = @_;
3080 sub { _add($separator, @_, @x) };
3081}
3082
3b6c4b07
RL		 3083sub read_eval_file {
3084 my $fname = shift;
3085 my $content;
3086 my @result;
3087
3088 open F, "< $fname" or die "Can't open '$fname': $!\n";
3089 {
3090 undef local $/;
3091 $content = <F>;
3092 }
3093 close F;
3094 {
3095 local $@;
3096
3097 @result = ( eval $content );
3098 warn $@ if $@;
3099 }
3100 return wantarray ? @result : $result[0];
3101}
3102
bd5192b1
RL		 3103# configuration reader, evaluates the input file as a perl script and expects
3104# it to fill %targets with target configurations. Those are then added to
3105# %table.
3106sub read_config {
3107 my $fname = shift;
3b6c4b07
RL		 3108 my %targets;
3109
bd5192b1 3110 {
84f32c84
DMSP		 3111 # Protect certain tables from tampering
3112 local %table = ();
bd5192b1 3113
84f32c84 3114 %targets = read_eval_file($fname);
bd5192b1 3115 }
225f980d
RL		 3116 my %preexisting = ();
3117 foreach (sort keys %targets) {
3118 $preexisting{$_} = 1 if $table{$_};
3119 }
3120 die <<"EOF",
3121The following config targets from $fname
3122shadow pre-existing config targets with the same name:
3123EOF
3124 map { " $_\n" } sort keys %preexisting
3125 if %preexisting;
3126
bd5192b1
RL		 3127
3128 # For each target, check that it's configured with a hash table.
3129 foreach (keys %targets) {
84f32c84
DMSP		 3130 if (ref($targets{$_}) ne "HASH") {
3131 if (ref($targets{$_}) eq "") {
3132 warn "Deprecated target configuration for $_, ignoring...\n";
3133 } else {
3134 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
3135 }
3136 delete $targets{$_};
3137 } else {
ee9b0bbb
RL		 3138 $targets{$_}->{_conf_fname_int} = add([ $fname ]);
3139 }
bd5192b1
RL		 3140 }
3141
3142 %table = (%table, %targets);
3143
3144}
3145
8483a003
F		 3146# configuration resolver. Will only resolve all the lazy evaluation
3147# codeblocks for the chosen target and all those it inherits from,
bd5192b1
RL		 3148# recursively
3149sub resolve_config {
3150 my $target = shift;
3151 my @breadcrumbs = @_;
3152
c4718849 3153# my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
9c62a279 3154
bd5192b1 3155 if (grep { $_ eq $target } @breadcrumbs) {
84f32c84
DMSP		 3156 die "inherit_from loop! target backtrace:\n "
3157 ,$target,"\n ",join("\n ", @breadcrumbs),"\n";
bd5192b1
RL		 3158 }
3159
3160 if (!defined($table{$target})) {
84f32c84
DMSP		 3161 warn "Warning! target $target doesn't exist!\n";
3162 return ();
bd5192b1
RL		 3163 }
3164 # Recurse through all inheritances. They will be resolved on the
3165 # fly, so when this operation is done, they will all just be a
3166 # bunch of attributes with string values.
3167 # What we get here, though, are keys with references to lists of
3168 # the combined values of them all. We will deal with lists after
3169 # this stage is done.
3170 my %combined_inheritance = ();
3171 if ($table{$target}->{inherit_from}) {
84f32c84
DMSP		 3172 my @inherit_from =
3173 map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
3174 foreach (@inherit_from) {
3175 my %inherited_config = resolve_config($_, $target, @breadcrumbs);
3176
3177 # 'template' is a marker that's considered private to
3178 # the config that had it.
3179 delete $inherited_config{template};
3180
3181 foreach (keys %inherited_config) {
3182 if (!$combined_inheritance{$_}) {
3183 $combined_inheritance{$_} = [];
3184 }
3185 push @{$combined_inheritance{$_}}, $inherited_config{$_};
3186 }
3187 }
bd5192b1
RL		 3188 }
3189
3190 # We won't need inherit_from in this target any more, since we've
3191 # resolved all the inheritances that lead to this
3192 delete $table{$target}->{inherit_from};
3193
3194 # Now is the time to deal with those lists. Here's the place to
3195 # decide what shall be done with those lists, all based on the
3196 # values of the target we're currently dealing with.
3197 # - If a value is a coderef, it will be executed with the list of
3198 # inherited values as arguments.
3199 # - If the corresponding key doesn't have a value at all or is the
8483a003 3200 # empty string, the inherited value list will be run through the
bd5192b1
RL		 3201 # default combiner (below), and the result becomes this target's
3202 # value.
3203 # - Otherwise, this target's value is assumed to be a string that
3204 # will simply override the inherited list of values.
a26d8be9 3205 my $default_combiner = add();
bd5192b1
RL		 3206
3207 my %all_keys =
84f32c84
DMSP		 3208 map { $_ => 1 } (keys %combined_inheritance,
3209 keys %{$table{$target}});
b0b92a5b
RL		 3210
3211 sub process_values {
84f32c84
DMSP		 3212 my $object = shift;
3213 my $inherited = shift; # Always a [ list ]
3214 my $target = shift;
3215 my $entry = shift;
b0b92a5b 3216
9c62a279
RL		 3217 $add_called = 0;
3218
b0b92a5b
RL		 3219 while(ref($object) eq "CODE") {
3220 $object = $object->(@$inherited);
3221 }
3222 if (!defined($object)) {
3223 return ();
3224 }
3225 elsif (ref($object) eq "ARRAY") {
9c62a279 3226 local $add_called; # To make sure recursive calls don't affect it
b0b92a5b
RL		 3227 return [ map { process_values($_, $inherited, $target, $entry) }
3228 @$object ];
3229 } elsif (ref($object) eq "") {
3230 return $object;
3231 } else {
3232 die "cannot handle reference type ",ref($object)
3233 ," found in target ",$target," -> ",$entry,"\n";
3234 }
3235 }
3236
bd5192b1 3237 foreach (sort keys %all_keys) {
9c62a279 3238 my $previous = $combined_inheritance{$_};
bd5192b1 3239
84f32c84
DMSP		 3240 # Current target doesn't have a value for the current key?
3241 # Assign it the default combiner, the rest of this loop body
3242 # will handle it just like any other coderef.
3243 if (!exists $table{$target}->{$_}) {
3244 $table{$target}->{$_} = $default_combiner;
3245 }
bd5192b1 3246
84f32c84
DMSP		 3247 $table{$target}->{$_} = process_values($table{$target}->{$_},
3248 $combined_inheritance{$_},
3249 $target, $_);
b0b92a5b
RL		 3250 unless(defined($table{$target}->{$_})) {
3251 delete $table{$target}->{$_};
3252 }
c4718849
RL		 3253# if ($extra_checks &&
3254# $previous && !($add_called || $previous ~~ $table{$target}->{$_})) {
3255# warn "$_ got replaced in $target\n";
3256# }
bd5192b1
RL		 3257 }
3258
3259 # Finally done, return the result.
3260 return %{$table{$target}};
3261}
3262
462ba4f6 3263sub usage
84f32c84
DMSP		 3264 {
3265 print STDERR $usage;
3266 print STDERR "\npick os/compiler from:\n";
3267 my $j=0;
3268 my $i;
10a926c1 3269 my $k=0;
84f32c84
DMSP		 3270 foreach $i (sort keys %table)
3271 {
3272 next if $table{$i}->{template};
3273 next if $i =~ /^debug/;
3274 $k += length($i) + 1;
3275 if ($k > 78)
3276 {
3277 print STDERR "\n";
3278 $k=length($i);
3279 }
3280 print STDERR $i . " ";
3281 }
3282 foreach $i (sort keys %table)
3283 {
3284 next if $table{$i}->{template};
3285 next if $i !~ /^debug/;
3286 $k += length($i) + 1;
3287 if ($k > 78)
3288 {
3289 print STDERR "\n";
3290 $k=length($i);
3291 }
3292 print STDERR $i . " ";
3293 }
3294 print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
3295 exit(1);
3296 }
d02b48c6 3297
01d99976 3298sub run_dofile
107b5792 3299{
107b5792 3300 my $out = shift;
9fe2bb77 3301 my @templates = @_;
107b5792 3302
ced2c2c5
RS		 3303 unlink $out || warn "Can't remove $out, $!"
3304 if -f $out;
9fe2bb77
RL		 3305 foreach (@templates) {
3306 die "Can't open $_, $!" unless -f $_;
3307 }
9e265322 3308 my $perlcmd = (quotify("maybeshell", $config{PERL}))[0];
f879d5ff 3309 my $cmd = "$perlcmd \"-I.\" \"-Mconfigdata\" \"$dofile\" -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\"";
9fe2bb77
RL		 3310 #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
3311 system($cmd);
107b5792
RL		 3312 exit 1 if $? != 0;
3313 rename("$out.new", $out) || die "Can't rename $out.new, $!";
3314}
3315
6d75a83c
RL		 3316sub compiler_predefined {
3317 state %predefined;
41d6e0f3 3318 my $cc = shift;
6d75a83c
RL		 3319
3320 return () if $^O eq 'VMS';
3321
41d6e0f3
AP		 3322 die 'compiler_predefined called without a compiler command'
3323 unless $cc;
6d75a83c 3324
41d6e0f3 3325 if (! $predefined{$cc}) {
6d75a83c 3326
41d6e0f3 3327 $predefined{$cc} = {};
6d75a83c
RL		 3328
3329 # collect compiler pre-defines from gcc or gcc-alike...
3330 open(PIPE, "$cc -dM -E -x c /dev/null 2>&1 |");
3331 while (my $l = <PIPE>) {
3332 $l =~ m/^#define\s+(\w+(?:\(\w+\))?)(?:\s+(.+))?/ or last;
41d6e0f3 3333 $predefined{$cc}->{$1} = $2 // '';
6d75a83c
RL		 3334 }
3335 close(PIPE);
3336 }
3337
41d6e0f3 3338 return %{$predefined{$cc}};
6d75a83c
RL		 3339}
3340
656bbdc6
AP		 3341sub which
3342{
3343 my ($name)=@_;
3344
3345 if (eval { require IPC::Cmd; 1; }) {
3346 IPC::Cmd->import();
3347 return scalar IPC::Cmd::can_run($name);
3348 } else {
3349 # if there is $directories component in splitpath,
3350 # then it's not something to test with $PATH...
3351 return $name if (File::Spec->splitpath($name))[1];
3352
3353 foreach (File::Spec->path()) {
3354 my $fullpath = catfile($_, "$name$target{exe_extension}");
3355 if (-f $fullpath and -x $fullpath) {
3356 return $fullpath;
3357 }
3358 }
3359 }
3360}
3361
7ecdf18d
RL		 3362sub env
3363{
3364 my $name = shift;
ac6ae8a9 3365 my %opts = @_;
7ecdf18d 3366
ac6ae8a9
RL		 3367 unless ($opts{cacheonly}) {
3368 # Note that if $ENV{$name} doesn't exist or is undefined,
3369 # $config{perlenv}->{$name} will be created with the value
3370 # undef. This is intentional.
89bea083 3371
ac6ae8a9
RL		 3372 $config{perlenv}->{$name} = $ENV{$name}
3373 if ! exists $config{perlenv}->{$name};
3374 }
7ecdf18d
RL		 3375 return $config{perlenv}->{$name};
3376}
3377
00ae96ca
RL		 3378# Configuration printer ##############################################
3379
3380sub print_table_entry
3381{
f770d75b
AP		 3382 local $now_printing = shift;
3383 my %target = resolve_config($now_printing);
00ae96ca
RL		 3384 my $type = shift;
3385
3386 # Don't print the templates
3387 return if $target{template};
3388
3389 my @sequence = (
84f32c84
DMSP		 3390 "sys_id",
3391 "cpp",
3392 "cppflags",
3393 "defines",
3394 "includes",
3395 "cc",
3396 "cflags",
3397 "unistd",
3398 "ld",
3399 "lflags",
3400 "loutflag",
3401 "ex_libs",
3402 "bn_ops",
3403 "apps_aux_src",
3404 "cpuid_asm_src",
3405 "uplink_aux_src",
3406 "bn_asm_src",
3407 "ec_asm_src",
3408 "des_asm_src",
3409 "aes_asm_src",
3410 "bf_asm_src",
3411 "md5_asm_src",
3412 "cast_asm_src",
3413 "sha1_asm_src",
3414 "rc4_asm_src",
3415 "rmd160_asm_src",
3416 "rc5_asm_src",
3417 "wp_asm_src",
3418 "cmll_asm_src",
3419 "modes_asm_src",
3420 "padlock_asm_src",
3421 "chacha_asm_src",
3422 "poly1035_asm_src",
3423 "thread_scheme",
3424 "perlasm_scheme",
3425 "dso_scheme",
3426 "shared_target",
3427 "shared_cflag",
3428 "shared_defines",
3429 "shared_ldflag",
3430 "shared_rcflag",
3431 "shared_extension",
3432 "dso_extension",
3433 "obj_extension",
3434 "exe_extension",
3435 "ranlib",
3436 "ar",
3437 "arflags",
3438 "aroutflag",
3439 "rc",
3440 "rcflags",
3441 "rcoutflag",
3442 "mt",
3443 "mtflags",
3444 "mtinflag",
3445 "mtoutflag",
3446 "multilib",
3447 "build_scheme",
3448 );
00ae96ca
RL		 3449
3450 if ($type eq "TABLE") {
84f32c84
DMSP		 3451 print "\n";
3452 print "*** $now_printing\n";
cb212f23
RL		 3453 foreach (@sequence) {
3454 if (ref($target{$_}) eq "ARRAY") {
3455 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
3456 } else {
3457 printf "\$%-12s = %s\n", $_, $target{$_};
3458 }
3459 }
00ae96ca 3460 } elsif ($type eq "HASH") {
84f32c84
DMSP		 3461 my $largest =
3462 length((sort { length($a) <=> length($b) } @sequence)[-1]);
3463 print " '$now_printing' => {\n";
3464 foreach (@sequence) {
3465 if ($target{$_}) {
cb212f23
RL		 3466 if (ref($target{$_}) eq "ARRAY") {
3467 print " '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
3468 } else {
3469 print " '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
3470 }
84f32c84
DMSP		 3471 }
3472 }
3473 print " },\n";
00ae96ca
RL		 3474 }
3475}
3476
3477# Utility routines ###################################################
3478
2e963849
RL		 3479# On VMS, if the given file is a logical name, File::Spec::Functions
3480# will consider it an absolute path. There are cases when we want a
3481# purely syntactic check without checking the environment.
3482sub isabsolute {
3483 my $file = shift;
3484
3485 # On non-platforms, we just use file_name_is_absolute().
3486 return file_name_is_absolute($file) unless $^O eq "VMS";
3487
69687aa8 3488 # If the file spec includes a device or a directory spec,
2e963849
RL		 3489 # file_name_is_absolute() is perfectly safe.
3490 return file_name_is_absolute($file) if $file =~ m|[:\[]|;
3491
3492 # Here, we know the given file spec isn't absolute
3493 return 0;
3494}
3495
ec182ef0
RL		 3496# Makes a directory absolute and cleans out /../ in paths like foo/../bar
3497# On some platforms, this uses rel2abs(), while on others, realpath() is used.
3498# realpath() requires that at least all path components except the last is an
3499# existing directory. On VMS, the last component of the directory spec must
3500# exist.
3501sub absolutedir {
3502 my $dir = shift;
3503
3504 # realpath() is quite buggy on VMS. It uses LIB$FID_TO_NAME, which
3505 # will return the volume name for the device, no matter what. Also,
3506 # it will return an incorrect directory spec if the argument is a
3507 # directory that doesn't exist.
3508 if ($^O eq "VMS") {
3509 return rel2abs($dir);
3510 }
3511
3512 # We use realpath() on Unix, since no other will properly clean out
3513 # a directory spec.
3514 use Cwd qw/realpath/;
3515
3516 return realpath($dir);
3517}
3518
fe05264e
RL		 3519sub quotify {
3520 my %processors = (
84f32c84
DMSP		 3521 perl => sub { my $x = shift;
3522 $x =~ s/([\\\$\@"])/\\$1/g;
3523 return '"'.$x.'"'; },
3524 maybeshell => sub { my $x = shift;
3525 (my $y = $x) =~ s/([\\\"])/\\$1/g;
3526 if ($x ne $y || $x =~ m|\s|) {
3527 return '"'.$y.'"';
3528 } else {
3529 return $x;
3530 }
3531 },
3532 );
fe05264e
RL		 3533 my $for = shift;
3534 my $processor =
84f32c84 3535 defined($processors{$for}) ? $processors{$for} : sub { shift; };
fe05264e 3536
2110febb 3537 return map { $processor->($_); } @_;
fe05264e 3538}
107b5792 3539
9fe2bb77
RL		 3540# collect_from_file($filename, $line_concat_cond_re, $line_concat)
3541# $filename is a file name to read from
3542# $line_concat_cond_re is a regexp detecting a line continuation ending
3543# $line_concat is a CODEref that takes care of concatenating two lines
3544sub collect_from_file {
3545 my $filename = shift;
3546 my $line_concat_cond_re = shift;
3547 my $line_concat = shift;
3548
3549 open my $fh, $filename || die "unable to read $filename: $!\n";
3550 return sub {
3551 my $saved_line = "";
3552 $_ = "";
3553 while (<$fh>) {
04f171c0 3554 s|\R$||;
9fe2bb77
RL		 3555 if (defined $line_concat) {
3556 $_ = $line_concat->($saved_line, $_);
3557 $saved_line = "";
3558 }
3559 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
3560 $saved_line = $_;
3561 next;
3562 }
3563 return $_;
3564 }
3565 die "$filename ending with continuation line\n" if $_;
3566 close $fh;
3567 return undef;
3568 }
3569}
3570
3571# collect_from_array($array, $line_concat_cond_re, $line_concat)
3572# $array is an ARRAYref of lines
3573# $line_concat_cond_re is a regexp detecting a line continuation ending
3574# $line_concat is a CODEref that takes care of concatenating two lines
3575sub collect_from_array {
3576 my $array = shift;
3577 my $line_concat_cond_re = shift;
3578 my $line_concat = shift;
3579 my @array = (@$array);
3580
3581 return sub {
3582 my $saved_line = "";
3583 $_ = "";
3584 while (defined($_ = shift @array)) {
04f171c0 3585 s|\R$||;
9fe2bb77
RL		 3586 if (defined $line_concat) {
3587 $_ = $line_concat->($saved_line, $_);
3588 $saved_line = "";
3589 }
3590 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
3591 $saved_line = $_;
3592 next;
3593 }
3594 return $_;
3595 }
3596 die "input text ending with continuation line\n" if $_;
3597 return undef;
3598 }
3599}
3600
3601# collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
3602# $lineiterator is a CODEref that delivers one line at a time.
107b5792
RL		 3603# All following arguments are regex/CODEref pairs, where the regexp detects a
3604# line and the CODEref does something with the result of the regexp.
3605sub collect_information {
9fe2bb77 3606 my $lineiterator = shift;
107b5792
RL		 3607 my %collectors = @_;
3608
9fe2bb77 3609 while(defined($_ = $lineiterator->())) {
04f171c0 3610 s|\R$||;
9fe2bb77 3611 my $found = 0;
2b6b606c
RL		 3612 if ($collectors{"BEFORE"}) {
3613 $collectors{"BEFORE"}->($_);
3614 }
9fe2bb77 3615 foreach my $re (keys %collectors) {
2b6b606c 3616 if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
9fe2bb77
RL		 3617 $collectors{$re}->($lineiterator);
3618 $found = 1;
3619 };
3620 }
3621 if ($collectors{"OTHERWISE"}) {
3622 $collectors{"OTHERWISE"}->($lineiterator, $_)
3623 unless $found || !defined $collectors{"OTHERWISE"};
3624 }
2b6b606c
RL		 3625 if ($collectors{"AFTER"}) {
3626 $collectors{"AFTER"}->($_);
3627 }
107b5792 3628 }
107b5792 3629}
ce959812
RL		 3630
3631# tokenize($line)
5d3af259 3632# tokenize($line,$separator)
ce959812 3633# $line is a line of text to split up into tokens
5d3af259
RL		 3634# $separator [optional] is a regular expression that separates the tokens,
3635# the default being spaces. Do not use quotes of any kind as separators,
3636# that will give undefined results.
3637# Returns a list of tokens.
ce959812 3638#
5d3af259
RL		 3639# Tokens are divided by separator (spaces by default). If the tokens include
3640# the separators, they have to be quoted with single or double quotes.
3641# Double quotes inside a double quoted token must be escaped. Escaping is done
ce959812
RL		 3642# with backslash.
3643# Basically, the same quoting rules apply for " and ' as in any
3644# Unix shell.
3645sub tokenize {
3646 my $line = my $debug_line = shift;
5d3af259 3647 my $separator = shift // qr|\s+|;
ce959812
RL		 3648 my @result = ();
3649
5d3af259
RL		 3650 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
3651 print STDERR "DEBUG[tokenize]: \$separator = $separator\n";
3652 }
3653
3654 while ($line =~ s|^${separator}||, $line ne "") {
ce959812 3655 my $token = "";
5d3af259
RL		 3656 again:
3657 $line =~ m/^(.*?)(${separator}|"|'|$)/;
3658 $token .= $1;
3659 $line = $2.$';
3660
3661 if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
3662 $token .= $1;
3663 $line = $';
3664 goto again;
3665 } elsif ($line =~ m/^'([^']*)'/) {
3666 $token .= $1;
3667 $line = $';
3668 goto again;
ce959812
RL		 3669 }
3670 push @result, $token;
3671 }
3672
3673 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
5d3af259
RL		 3674 print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
3675 print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";
ce959812
RL		 3676 }
3677 return @result;
3678}
A mirror of the official openssl repository