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