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