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