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