]> 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
Implement support for AES-256-ECB in the default provider
[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 $disabled{"pic"} = "forced";
896 $disabled{"shared"} = "forced";
897 $disabled{"threads"} = "forced";
898 }
899 elsif (/^-D(.*)$/)
900 {
901 push @{$useradd{CPPDEFINES}}, $1;
902 }
903 elsif (/^-I(.*)$/)
904 {
905 push @{$useradd{CPPINCLUDES}}, $1;
906 }
907 elsif (/^-Wp,$/)
908 {
909 push @{$useradd{CPPFLAGS}}, $1;
910 }
911 else # common if (/^[-+]/), just pass down...
912 {
913 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
914 push @{$useradd{CFLAGS}}, $_;
915 push @{$useradd{CXXFLAGS}}, $_;
8389ec4b 916 }
84f32c84
DMSP		 917 }
918 else
919 {
920 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
921 $target=$_;
922 }
923 unless ($_ eq $target || /^no-/ || /^disable-/)
924 {
925 # "no-..." follows later after implied deactivations
926 # have been derived. (Don't take this too seriously,
927 # we really only write OPTIONS to the Makefile out of
928 # nostalgia.)
929
930 if ($config{options} eq "")
931 { $config{options} = $_; }
932 else
933 { $config{options} .= " ".$_; }
934 }
935 }
489eb740 936
ddbe700e 937if (defined($config{api}) && !exists $apitable->{$config{api}}) {
84f32c84 938 die "***** Unsupported api compatibility level: $config{api}\n",
ddbe700e 939}
98186eb4 940
ddbe700e 941if (keys %deprecated_options)
84f32c84
DMSP		 942 {
943 warn "***** Deprecated options: ",
944 join(", ", keys %deprecated_options), "\n";
945 }
ddbe700e 946if (keys %unsupported_options)
84f32c84
DMSP		 947 {
948 die "***** Unsupported options: ",
949 join(", ", keys %unsupported_options), "\n";
950 }
b6e4dac2 951
ac6ae8a9
RL		 952# If any %useradd entry has been set, we must check that the "make
953# variables" haven't been set. We start by checking of any %useradd entry
fb174faa 954# is set.
b9201360 955if (grep { scalar @$_ > 0 } values %useradd) {
fb174faa 956 # Hash of env / make variables names. The possible values are:
ac6ae8a9 957 # 1 - "make vars"
fb174faa
RL		 958 # 2 - %useradd entry set
959 # 3 - both set
ac6ae8a9 960 my %detected_vars =
fb174faa 961 map { my $v = 0;
ac6ae8a9 962 $v += 1 if $cmdvars{$_};
fb174faa
RL		 963 $v += 2 if @{$useradd{$_}};
964 $_ => $v }
965 keys %useradd;
966
ac6ae8a9
RL		 967 # If any of the corresponding "make variables" is set, we error
968 if (grep { $_ & 1 } values %detected_vars) {
969 my $names = join(', ', grep { $detected_vars{$_} > 0 }
970 sort keys %detected_vars);
b9201360 971 die <<"_____";
ac6ae8a9 972***** Mixing make variables and additional compiler/linker flags as
b9201360 973***** configure command line option is not permitted.
ac6ae8a9 974***** Affected make variables: $names
b9201360
RL		 975_____
976 }
977}
978
ac6ae8a9
RL		 979# Check through all supported command line variables to see if any of them
980# were set, and canonicalise the values we got. If no compiler or linker
981# flag or anything else that affects %useradd was set, we also check the
982# environment for values.
983my $anyuseradd =
984 grep { defined $_ && (ref $_ ne 'ARRAY' || @$_) } values %useradd;
5b18235a 985foreach (keys %user) {
ac6ae8a9
RL		 986 my $value = $cmdvars{$_};
987 $value //= env($_) unless $anyuseradd;
988 $value //=
989 defined $user_synonyms{$_} ? $cmdvars{$user_synonyms{$_}} : undef;
990 $value //= defined $user_synonyms{$_} ? env($user_synonyms{$_}) : undef
991 unless $anyuseradd;
5b18235a
RL		 992
993 if (defined $value) {
994 if (ref $user{$_} eq 'ARRAY') {
995 $user{$_} = [ split /$list_separator_re/, $value ];
996 } elsif (!defined $user{$_}) {
997 $user{$_} = $value;
998 }
999 }
1000}
1001
07e4dc34 1002if (grep { /-rpath\b/ } ($user{LDFLAGS} ? @{$user{LDFLAGS}} : ())
342a1a23
RL		 1003 && !$disabled{shared}
1004 && !($disabled{asan} && $disabled{msan} && $disabled{ubsan})) {
1005 die "***** Cannot simultaneously use -rpath, shared libraries, and\n",
84f32c84 1006 "***** any of asan, msan or ubsan\n";
342a1a23
RL		 1007}
1008
c569e206
RL		 1009my @tocheckfor = (keys %disabled);
1010while (@tocheckfor) {
1011 my %new_tocheckfor = ();
1012 my @cascade_copy = (@disable_cascades);
1013 while (@cascade_copy) {
84f32c84
DMSP		 1014 my ($test, $descendents) = (shift @cascade_copy, shift @cascade_copy);
1015 if (ref($test) eq "CODE" ? $test->() : defined($disabled{$test})) {
1016 foreach(grep { !defined($disabled{$_}) } @$descendents) {
1017 $new_tocheckfor{$_} = 1; $disabled{$_} = "forced";
1018 }
1019 }
c569e206
RL		 1020 }
1021 @tocheckfor = (keys %new_tocheckfor);
1022}
edc032b5 1023
d63c12c6 1024our $die = sub { die @_; };
436a376b 1025if ($target eq "TABLE") {
d63c12c6 1026 local $die = sub { warn @_; };
00ae96ca 1027 foreach (sort keys %table) {
84f32c84 1028 print_table_entry($_, "TABLE");
00ae96ca
RL		 1029 }
1030 exit 0;
436a376b
BM		 1031}
1032
10a926c1 1033if ($target eq "LIST") {
00ae96ca 1034 foreach (sort keys %table) {
84f32c84 1035 print $_,"\n" unless $table{$_}->{template};
00ae96ca
RL		 1036 }
1037 exit 0;
10a926c1
UM		 1038}
1039
aaf878cc 1040if ($target eq "HASH") {
d63c12c6 1041 local $die = sub { warn @_; };
00ae96ca
RL		 1042 print "%table = (\n";
1043 foreach (sort keys %table) {
84f32c84 1044 print_table_entry($_, "HASH");
00ae96ca
RL		 1045 }
1046 exit 0;
aaf878cc
RL		 1047}
1048
16942e08
DMSP		 1049print "Configuring OpenSSL version $config{full_version} ";
1050print "for target $target\n";
64119271 1051
51cf8e0b
RL		 1052if (scalar(@seed_sources) == 0) {
1053 print "Using os-specific seed configuration\n";
1054 push @seed_sources, 'os';
1055}
2805ee1e
RL		 1056if (scalar(grep { $_ eq 'none' } @seed_sources) > 0) {
1057 die "Cannot seed with none and anything else" if scalar(@seed_sources) > 1;
1058 warn <<_____ if scalar(@seed_sources) == 1;
2805ee1e 1059
caa85952
DMSP		 1060============================== WARNING ===============================
1061You have selected the --with-rand-seed=none option, which effectively
1062disables automatic reseeding of the OpenSSL random generator.
1063All operations depending on the random generator such as creating keys
1064will not work unless the random generator is seeded manually by the
1065application.
1066
1067Please read the 'Note on random number generation' section in the
1068INSTALL instructions and the RAND_DRBG(7) manual page for more details.
1069============================== WARNING ===============================
1070
2805ee1e
RL		 1071_____
1072}
e0bf7c01 1073push @{$config{openssl_feature_defines}},
51cf8e0b 1074 map { (my $x = $_) =~ tr|[\-a-z]|[_A-Z]|; "OPENSSL_RAND_SEED_$x" }
84f32c84 1075 @seed_sources;
51cf8e0b 1076
00ae96ca 1077# Backward compatibility?
49e04548 1078if ($target =~ m/^CygWin32(-.*)$/) {
00ae96ca 1079 $target = "Cygwin".$1;
49e04548
RL		 1080}
1081
906eb3d0
RL		 1082# Support for legacy targets having a name starting with 'debug-'
1083my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
1084if ($d) {
1085 $config{build_type} = "debug";
1086
1087 # If we do not find debug-foo in the table, the target is set to foo.
1088 if (!$table{$target}) {
84f32c84 1089 $target = $t;
906eb3d0
RL		 1090 }
1091}
4e360445
RL		 1092
1093&usage if !$table{$target} || $table{$target}->{template};
1094
906eb3d0
RL		 1095$config{target} = $target;
1096my %target = resolve_config($target);
1097
abe256e7
RL		 1098foreach (keys %target_attr_translate) {
1099 $target{$target_attr_translate{$_}} = $target{$_}
1100 if $target{$_};
1101 delete $target{$_};
1102}
1103
793077d0
RL		 1104%target = ( %{$table{DEFAULTS}}, %target );
1105
1106# Make the flags to build DSOs the same as for shared libraries unless they
1107# are already defined
48dcca26
RL		 1108$target{module_cflags} = $target{shared_cflag} unless defined $target{module_cflags};
1109$target{module_cxxflags} = $target{shared_cxxflag} unless defined $target{module_cxxflags};
1110$target{module_ldflags} = $target{shared_ldflag} unless defined $target{module_ldflags};
793077d0
RL		 1111{
1112 my $shared_info_pl =
1113 catfile(dirname($0), "Configurations", "shared-info.pl");
1114 my %shared_info = read_eval_file($shared_info_pl);
1115 push @{$target{_conf_fname_int}}, $shared_info_pl;
1116 my $si = $target{shared_target};
1117 while (ref $si ne "HASH") {
1118 last if ! defined $si;
1119 if (ref $si eq "CODE") {
1120 $si = $si->();
1121 } else {
1122 $si = $shared_info{$si};
1123 }
1124 }
1125
1126 # Some of the 'shared_target' values don't have any entried in
1127 # %shared_info. That's perfectly fine, AS LONG AS the build file
1128 # template knows how to handle this. That is currently the case for
1129 # Windows and VMS.
1130 if (defined $si) {
1131 # Just as above, copy certain shared_* attributes to the corresponding
48dcca26
RL		 1132 # module_ attribute unless the latter is already defined
1133 $si->{module_cflags} = $si->{shared_cflag} unless defined $si->{module_cflags};
1134 $si->{module_cxxflags} = $si->{shared_cxxflag} unless defined $si->{module_cxxflags};
1135 $si->{module_ldflags} = $si->{shared_ldflag} unless defined $si->{module_ldflags};
793077d0
RL		 1136 foreach (sort keys %$si) {
1137 $target{$_} = defined $target{$_}
1138 ? add($si->{$_})->($target{$_})
1139 : $si->{$_};
1140 }
1141 }
1142}
1143
906eb3d0
RL		 1144my %conf_files = map { $_ => 1 } (@{$target{_conf_fname_int}});
1145$config{conf_files} = [ sort keys %conf_files ];
906eb3d0
RL		 1146
1147foreach my $feature (@{$target{disable}}) {
1148 if (exists $deprecated_disablables{$feature}) {
1149 warn "***** config $target disables deprecated feature $feature\n";
1150 } elsif (!grep { $feature eq $_ } @disablables) {
1151 die "***** config $target disables unknown feature $feature\n";
1152 }
1153 $disabled{$feature} = 'config';
1154}
1155foreach my $feature (@{$target{enable}}) {
7a8a35ff 1156 if ("default" eq ($disabled{$feature} // "")) {
906eb3d0
RL		 1157 if (exists $deprecated_disablables{$feature}) {
1158 warn "***** config $target enables deprecated feature $feature\n";
1159 } elsif (!grep { $feature eq $_ } @disablables) {
1160 die "***** config $target enables unknown feature $feature\n";
1161 }
7a8a35ff 1162 delete $disabled{$feature};
906eb3d0
RL		 1163 }
1164}
1165
abe256e7
RL		 1166$target{CXXFLAGS}//=$target{CFLAGS} if $target{CXX};
1167$target{cxxflags}//=$target{cflags} if $target{CXX};
9dd4ed28 1168$target{exe_extension}=".exe" if ($config{target} eq "DJGPP");
107b5792 1169$target{exe_extension}=".pm" if ($config{target} =~ /vos/);
e987f9f2 1170
9e265322
RL		 1171# Fill %config with values from %user, and in case those are undefined or
1172# empty, use values from %target (acting as a default).
5b18235a 1173foreach (keys %user) {
5b18235a
RL		 1174 my $ref_type = ref $user{$_};
1175
1176 # Temporary function. Takes an intended ref type (empty string or "ARRAY")
1177 # and a value that's to be coerced into that type.
1178 my $mkvalue = sub {
1179 my $type = shift;
1180 my $value = shift;
1181 my $undef_p = shift;
1182
1183 die "Too many arguments for \$mkvalue" if @_;
1184
1185 while (ref $value eq 'CODE') {
1186 $value = $value->();
1187 }
1188
1189 if ($type eq 'ARRAY') {
1190 return undef unless defined $value;
1191 return undef if ref $value ne 'ARRAY' && !$value;
1192 return undef if ref $value eq 'ARRAY' && !@$value;
1193 return [ $value ] unless ref $value eq 'ARRAY';
1194 }
1195 return undef unless $value;
1196 return $value;
1197 };
1198
abe256e7 1199 $config{$_} =
5b18235a 1200 $mkvalue->($ref_type, $user{$_})
abe256e7
RL		 1201 || $mkvalue->($ref_type, $target{$_});
1202 delete $config{$_} unless defined $config{$_};
5b18235a 1203}
aaf878cc 1204
8b5156d1 1205# Allow overriding the build file name
5b18235a 1206$config{build_file} = env('BUILDFILE') || $target{build_file} || "Makefile";
bd5192b1 1207
75d47db4
RL		 1208######################################################################
1209# Build up information for skipping certain directories depending on disabled
1210# features, as well as setting up macros for disabled features.
1211
1212# This is a tentative database of directories to skip. Some entries may not
1213# correspond to anything real, but that's ok, they will simply be ignored.
1214# The actual processing of these entries is done in the build.info lookup
1215# loop further down.
1216#
1217# The key is a Unix formated path in the source tree, the value is an index
1218# into %disabled_info, so any existing path gets added to a corresponding
1219# 'skipped' entry in there with the list of skipped directories.
1220my %skipdir = ();
ca372414
RL		 1221my %disabled_info = (); # For configdata.pm
1222foreach my $what (sort keys %disabled) {
469ce8ff
RL		 1223 # There are deprecated disablables that translate to themselves.
1224 # They cause disabling cascades, but should otherwise not regiter.
1225 next if $deprecated_disablables{$what};
1226
ca372414
RL		 1227 $config{options} .= " no-$what";
1228
e7545517
MC		 1229 if (!grep { $what eq $_ } ( 'buildtest-c++', 'fips', 'threads', 'shared',
1230 'module', 'pic', 'dynamic-engine', 'makedepend',
d0308923 1231 'zlib-dynamic', 'zlib', 'sse2', 'legacy' )) {
ca372414 1232 (my $WHAT = uc $what) =~ s|-|_|g;
75d47db4 1233 my $skipdir = $what;
ca372414
RL		 1234
1235 # fix-up crypto/directory name(s)
75d47db4
RL		 1236 $skipdir = "ripemd" if $what eq "rmd160";
1237 $skipdir = "whrlpool" if $what eq "whirlpool";
ca372414
RL		 1238
1239 my $macro = $disabled_info{$what}->{macro} = "OPENSSL_NO_$WHAT";
75d47db4 1240 push @{$config{openssl_feature_defines}}, $macro;
ca372414 1241
75d47db4
RL		 1242 $skipdir{engines} = $what if $what eq 'engine';
1243 $skipdir{"crypto/$skipdir"} = $what
1244 unless $what eq 'async' || $what eq 'err';
ca372414
RL		 1245 }
1246}
1247
291e94df
RL		 1248# Make sure build_scheme is consistent.
1249$target{build_scheme} = [ $target{build_scheme} ]
1250 if ref($target{build_scheme}) ne "ARRAY";
1251
ddf1847d
RL		 1252my ($builder, $builder_platform, @builder_opts) =
1253 @{$target{build_scheme}};
1254
d192a3aa
RL		 1255foreach my $checker (($builder_platform."-".$target{build_file}."-checker.pm",
1256 $builder_platform."-checker.pm")) {
1257 my $checker_path = catfile($srcdir, "Configurations", $checker);
1258 if (-f $checker_path) {
1259 my $fn = $ENV{CONFIGURE_CHECKER_WARN}
1260 ? sub { warn $@; } : sub { die $@; };
1261 if (! do $checker_path) {
1262 if ($@) {
1263 $fn->($@);
1264 } elsif ($!) {
1265 $fn->($!);
1266 } else {
1267 $fn->("The detected tools didn't match the platform\n");
1268 }
1269 }
1270 last;
1271 }
1272}
1273
488e2b0f
RL		 1274push @{$config{defines}}, "NDEBUG" if $config{build_type} eq "release";
1275
abe256e7 1276if ($target =~ /^mingw/ && `$config{CC} --target-help 2>&1` =~ m/-mno-cygwin/m)
84f32c84
DMSP		 1277 {
1278 push @{$config{cflags}}, "-mno-cygwin";
1279 push @{$config{cxxflags}}, "-mno-cygwin" if $config{CXX};
1280 push @{$config{shared_ldflag}}, "-mno-cygwin";
1281 }
cbecd29a 1282
5b18235a 1283if ($target =~ /linux.*-mips/ && !$disabled{asm}
26f0340d 1284 && !grep { $_ !~ /-m(ips|arch=)/ } (@{$user{CFLAGS}},
9be64336 1285 @{$useradd{CFLAGS}})) {
84f32c84
DMSP		 1286 # minimally required architecture flags for assembly modules
1287 my $value;
1288 $value = '-mips2' if ($target =~ /mips32/);
1289 $value = '-mips3' if ($target =~ /mips64/);
1290 unshift @{$config{cflags}}, $value;
1291 unshift @{$config{cxxflags}}, $value if $config{CXX};
63d8834c
AP		 1292}
1293
9c62a279
RL		 1294# If threads aren't disabled, check how possible they are
1295unless ($disabled{threads}) {
1296 if ($auto_threads) {
1297 # Enabled by default, disable it forcibly if unavailable
1298 if ($target{thread_scheme} eq "(unknown)") {
1299 $disabled{threads} = "unavailable";
1300 }
1301 } else {
8483a003 1302 # The user chose to enable threads explicitly, let's see
9c62a279
RL		 1303 # if there's a chance that's possible
1304 if ($target{thread_scheme} eq "(unknown)") {
1305 # If the user asked for "threads" and we don't have internal
1306 # knowledge how to do it, [s]he is expected to provide any
1307 # system-dependent compiler options that are necessary. We
1308 # can't truly check that the given options are correct, but
1309 # we expect the user to know what [s]He is doing.
26f0340d
RL		 1310 if (!@{$user{CFLAGS}} && !@{$useradd{CFLAGS}}
1311 && !@{$user{CPPDEFINES}} && !@{$useradd{CPPDEFINES}}) {
9c62a279
RL		 1312 die "You asked for multi-threading support, but didn't\n"
1313 ,"provide any system-specific compiler options\n";
1314 }
1315 }
1316 }
1317}
1318
1319# If threads still aren't disabled, add a C macro to ensure the source
1320# code knows about it. Any other flag is taken care of by the configs.
1321unless($disabled{threads}) {
e0bf7c01 1322 push @{$config{openssl_feature_defines}}, "OPENSSL_THREADS";
9c62a279 1323}
e452de9d 1324
98186eb4
VD		 1325# With "deprecated" disable all deprecated features.
1326if (defined($disabled{"deprecated"})) {
107b5792 1327 $config{api} = $maxapi;
98186eb4 1328}
07c4c14c 1329
8c3bc594 1330my $no_shared_warn=0;
291e94df 1331if ($target{shared_target} eq "")
84f32c84
DMSP		 1332 {
1333 $no_shared_warn = 1
1334 if (!$disabled{shared} || !$disabled{"dynamic-engine"});
84f32c84 1335 $disabled{pic} = $disabled{shared} = $disabled{"dynamic-engine"} =
34786bde 1336 $disabled{module} = "no-shared-target";
84f32c84 1337 }
b436a982 1338
19ab5790 1339if ($disabled{"dynamic-engine"}) {
e0bf7c01 1340 push @{$config{openssl_feature_defines}}, "OPENSSL_NO_DYNAMIC_ENGINE";
343ec2b0 1341 $config{dynamic_engines} = 0;
19ab5790 1342} else {
e0bf7c01 1343 push @{$config{openssl_feature_defines}}, "OPENSSL_NO_STATIC_ENGINE";
19ab5790 1344 $config{dynamic_engines} = 1;
343ec2b0 1345}
ecd45314 1346
c38bb727 1347unless ($disabled{asan}) {
5b18235a 1348 push @{$config{cflags}}, "-fsanitize=address";
abe256e7 1349 push @{$config{cxxflags}}, "-fsanitize=address" if $config{CXX};
c38bb727
BL		 1350}
1351
1352unless ($disabled{ubsan}) {
f430ba31 1353 # -DPEDANTIC or -fnosanitize=alignment may also be required on some
c38bb727 1354 # platforms.
5b18235a 1355 push @{$config{cflags}}, "-fsanitize=undefined", "-fno-sanitize-recover=all";
fa153b57 1356 push @{$config{cxxflags}}, "-fsanitize=undefined", "-fno-sanitize-recover=all"
abe256e7 1357 if $config{CXX};
c38bb727
BL		 1358}
1359
29df3061 1360unless ($disabled{msan}) {
5b18235a 1361 push @{$config{cflags}}, "-fsanitize=memory";
abe256e7 1362 push @{$config{cxxflags}}, "-fsanitize=memory" if $config{CXX};
29df3061
EK		 1363}
1364
65cc6d5c 1365unless ($disabled{"fuzz-libfuzzer"} && $disabled{"fuzz-afl"}
29df3061 1366 && $disabled{asan} && $disabled{ubsan} && $disabled{msan}) {
5b18235a 1367 push @{$config{cflags}}, "-fno-omit-frame-pointer", "-g";
abe256e7 1368 push @{$config{cxxflags}}, "-fno-omit-frame-pointer", "-g" if $config{CXX};
c38bb727 1369}
c313e32a
AP		 1370#
1371# Platform fix-ups
1372#
ae48242c
RL		 1373
1374# This saves the build files from having to check
1375if ($disabled{pic})
84f32c84
DMSP		 1376 {
1377 foreach (qw(shared_cflag shared_cxxflag shared_cppflag
1378 shared_defines shared_includes shared_ldflag
1379 module_cflags module_cxxflags module_cppflags
1380 module_defines module_includes module_lflags))
1381 {
1382 delete $config{$_};
1383 $target{$_} = "";
1384 }
1385 }
4f16039e 1386else
84f32c84
DMSP		 1387 {
1388 push @{$config{lib_defines}}, "OPENSSL_PIC";
1389 }
ae48242c 1390
291e94df 1391if ($target{sys_id} ne "")
84f32c84
DMSP		 1392 {
1393 push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
1394 }
cf1b7d96 1395
00b0d663 1396unless ($disabled{asm}) {
d2b2221a 1397 $target{cpuid_asm_src}=$table{DEFAULTS}->{cpuid_asm_src} if ($config{processor} eq "386");
68b8bcf4 1398 push @{$config{lib_defines}}, "OPENSSL_CPUID_OBJ" if ($target{cpuid_asm_src} ne "mem_clr.c");
2ad2281a 1399
9fe2bb77 1400 $target{bn_asm_src} =~ s/\w+-gf2m.c// if (defined($disabled{ec2m}));
f8c469de 1401
9e0724a1 1402 # bn-586 is the only one implementing bn_*_part_words
68b8bcf4
RL		 1403 push @{$config{lib_defines}}, "OPENSSL_BN_ASM_PART_WORDS" if ($target{bn_asm_src} =~ /bn-586/);
1404 push @{$config{lib_defines}}, "OPENSSL_IA32_SSE2" if (!$disabled{sse2} && $target{bn_asm_src} =~ /86/);
dfeab068 1405
68b8bcf4
RL		 1406 push @{$config{lib_defines}}, "OPENSSL_BN_ASM_MONT" if ($target{bn_asm_src} =~ /-mont/);
1407 push @{$config{lib_defines}}, "OPENSSL_BN_ASM_MONT5" if ($target{bn_asm_src} =~ /-mont5/);
1408 push @{$config{lib_defines}}, "OPENSSL_BN_ASM_GF2m" if ($target{bn_asm_src} =~ /-gf2m/);
31703da3 1409 push @{$config{lib_defines}}, "BN_DIV3W" if ($target{bn_asm_src} =~ /-div3w/);
5ac7bde7 1410
9fe2bb77 1411 if ($target{sha1_asm_src}) {
84f32c84
DMSP		 1412 push @{$config{lib_defines}}, "SHA1_ASM" if ($target{sha1_asm_src} =~ /sx86/ || $target{sha1_asm_src} =~ /sha1/);
1413 push @{$config{lib_defines}}, "SHA256_ASM" if ($target{sha1_asm_src} =~ /sha256/);
1414 push @{$config{lib_defines}}, "SHA512_ASM" if ($target{sha1_asm_src} =~ /sha512/);
9e0724a1 1415 }
e4739e31 1416 if ($target{keccak1600_asm_src} ne $table{DEFAULTS}->{keccak1600_asm_src}) {
84f32c84 1417 push @{$config{lib_defines}}, "KECCAK1600_ASM";
e4739e31 1418 }
216e8d91 1419 if ($target{rc4_asm_src} ne $table{DEFAULTS}->{rc4_asm_src}) {
84f32c84 1420 push @{$config{lib_defines}}, "RC4_ASM";
216e8d91 1421 }
9fe2bb77 1422 if ($target{md5_asm_src}) {
84f32c84 1423 push @{$config{lib_defines}}, "MD5_ASM";
9e0724a1 1424 }
d2b2221a 1425 $target{cast_asm_src}=$table{DEFAULTS}->{cast_asm_src} unless $disabled{pic}; # CAST assembler is not PIC
9fe2bb77 1426 if ($target{rmd160_asm_src}) {
84f32c84 1427 push @{$config{lib_defines}}, "RMD160_ASM";
9e0724a1 1428 }
9fe2bb77 1429 if ($target{aes_asm_src}) {
84f32c84
DMSP		 1430 push @{$config{lib_defines}}, "AES_ASM" if ($target{aes_asm_src} =~ m/\baes-/);;
1431 # aes-ctr.fake is not a real file, only indication that assembler
1432 # module implements AES_ctr32_encrypt...
1433 push @{$config{lib_defines}}, "AES_CTR_ASM" if ($target{aes_asm_src} =~ s/\s*aes-ctr\.fake//);
1434 # aes-xts.fake indicates presence of AES_xts_[en|de]crypt...
1435 push @{$config{lib_defines}}, "AES_XTS_ASM" if ($target{aes_asm_src} =~ s/\s*aes-xts\.fake//);
1436 $target{aes_asm_src} =~ s/\s*(vpaes|aesni)-x86\.s//g if ($disabled{sse2});
1437 push @{$config{lib_defines}}, "VPAES_ASM" if ($target{aes_asm_src} =~ m/vpaes/);
1438 push @{$config{lib_defines}}, "BSAES_ASM" if ($target{aes_asm_src} =~ m/bsaes/);
9e0724a1 1439 }
9fe2bb77 1440 if ($target{wp_asm_src} =~ /mmx/) {
46d4d865 1441 if ($config{processor} eq "386") {
84f32c84
DMSP		 1442 $target{wp_asm_src}=$table{DEFAULTS}->{wp_asm_src};
1443 } elsif (!$disabled{"whirlpool"}) {
1444 push @{$config{lib_defines}}, "WHIRLPOOL_ASM";
1445 }
9e0724a1 1446 }
9fe2bb77 1447 if ($target{modes_asm_src} =~ /ghash-/) {
84f32c84 1448 push @{$config{lib_defines}}, "GHASH_ASM";
9e0724a1 1449 }
9fe2bb77 1450 if ($target{ec_asm_src} =~ /ecp_nistz256/) {
84f32c84 1451 push @{$config{lib_defines}}, "ECP_NISTZ256_ASM";
9e0724a1 1452 }
0e5c8d56 1453 if ($target{ec_asm_src} =~ /x25519/) {
84f32c84 1454 push @{$config{lib_defines}}, "X25519_ASM";
0e5c8d56 1455 }
7b176a54 1456 if ($target{padlock_asm_src} ne $table{DEFAULTS}->{padlock_asm_src}) {
84f32c84 1457 push @{$config{dso_defines}}, "PADLOCK_ASM";
7b176a54 1458 }
9fe2bb77 1459 if ($target{poly1305_asm_src} ne "") {
84f32c84 1460 push @{$config{lib_defines}}, "POLY1305_ASM";
9e0724a1
RL		 1461 }
1462}
d02b48c6 1463
e373c70a
RL		 1464my %predefined_C = compiler_predefined($config{CROSS_COMPILE}.$config{CC});
1465my %predefined_CXX = $config{CXX}
1466 ? compiler_predefined($config{CROSS_COMPILE}.$config{CXX})
1467 : ();
54cf3b98 1468
fe191b49 1469# Check for makedepend capabilities.
6d75a83c 1470if (!$disabled{makedepend}) {
fe191b49
RL		 1471 if ($config{target} =~ /^(VC|vms)-/) {
1472 # For VC- and vms- targets, there's nothing more to do here. The
1473 # functionality is hard coded in the corresponding build files for
1474 # cl (Windows) and CC/DECC (VMS).
e373c70a 1475 } elsif (($predefined_C{__GNUC__} // -1) >= 3
84f32c84 1476 && !($predefined_C{__APPLE_CC__} && !$predefined_C{__clang__})) {
fe191b49 1477 # We know that GNU C version 3 and up as well as all clang
717f308e
TS		 1478 # versions support dependency generation, but Xcode did not
1479 # handle $cc -M before clang support (but claims __GNUC__ = 3)
abe256e7 1480 $config{makedepprog} = "\$(CROSS_COMPILE)$config{CC}";
6d75a83c 1481 } else {
fe191b49
RL		 1482 # In all other cases, we look for 'makedepend', and disable the
1483 # capability if not found.
6d75a83c
RL		 1484 $config{makedepprog} = which('makedepend');
1485 $disabled{makedepend} = "unavailable" unless $config{makedepprog};
54cf3b98 1486 }
f1f07a23 1487}
8ed40b83 1488
e373c70a 1489if (!$disabled{asm} && !$predefined_C{__MACH__} && $^O ne 'VMS') {
0ad4078c 1490 # probe for -Wa,--noexecstack option...
e373c70a 1491 if ($predefined_C{__clang__}) {
0ad4078c
AP		 1492 # clang has builtin assembler, which doesn't recognize --help,
1493 # but it apparently recognizes the option in question on all
1494 # supported platforms even when it's meaningless. In other words
1495 # probe would fail, but probed option always accepted...
1496 push @{$config{cflags}}, "-Wa,--noexecstack", "-Qunused-arguments";
8e5da579 1497 } else {
0ad4078c
AP		 1498 my $cc = $config{CROSS_COMPILE}.$config{CC};
1499 open(PIPE, "$cc -Wa,--help -c -o null.$$.o -x assembler /dev/null 2>&1 |");
1500 while(<PIPE>) {
1501 if (m/--noexecstack/) {
1502 push @{$config{cflags}}, "-Wa,--noexecstack";
1503 last;
1504 }
1505 }
1506 close(PIPE);
1507 unlink("null.$$.o");
1508 }
1509}
7d130f68
RL		 1510
1511# Deal with bn_ops ###################################################
1512
84f32c84
DMSP		 1513$config{bn_ll} =0;
1514$config{export_var_as_fn} =0;
7d130f68 1515my $def_int="unsigned int";
84f32c84 1516$config{rc4_int} =$def_int;
b4f35e5e 1517($config{b64l},$config{b64},$config{b32})=(0,0,1);
7d130f68 1518
94af0cd7 1519my $count = 0;
7d130f68 1520foreach (sort split(/\s+/,$target{bn_ops})) {
94af0cd7
RS		 1521 $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1522 $config{export_var_as_fn}=1 if $_ eq 'EXPORT_VAR_AS_FN';
84f32c84
DMSP		 1523 $config{bn_ll}=1 if $_ eq 'BN_LLONG';
1524 $config{rc4_int}="unsigned char" if $_ eq 'RC4_CHAR';
94af0cd7 1525 ($config{b64l},$config{b64},$config{b32})
84f32c84 1526 =(0,1,0) if $_ eq 'SIXTY_FOUR_BIT';
94af0cd7 1527 ($config{b64l},$config{b64},$config{b32})
84f32c84 1528 =(1,0,0) if $_ eq 'SIXTY_FOUR_BIT_LONG';
94af0cd7 1529 ($config{b64l},$config{b64},$config{b32})
84f32c84 1530 =(0,0,1) if $_ eq 'THIRTY_TWO_BIT';
7d130f68 1531}
94af0cd7
RS		 1532die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1533 if $count > 1;
7d130f68
RL		 1534
1535
1536# Hack cflags for better warnings (dev option) #######################
1537
fa153b57
RL		 1538# "Stringify" the C and C++ flags string. This permits it to be made part of
1539# a string and works as well on command lines.
5b18235a
RL		 1540$config{cflags} = [ map { (my $x = $_) =~ s/([\\\"])/\\$1/g; $x }
1541 @{$config{cflags}} ];
fa153b57 1542$config{cxxflags} = [ map { (my $x = $_) =~ s/([\\\"])/\\$1/g; $x }
abe256e7 1543 @{$config{cxxflags}} ] if $config{CXX};
b436a982 1544
fcd2d5a6
RL		 1545$config{openssl_api_defines} = [
1546 "OPENSSL_MIN_API=".($apitable->{$config{api} // ""} // -1)
1547];
98186eb4 1548
e373c70a 1549my %strict_warnings_collection=( CFLAGS => [], CXXFLAGS => []);
0c28f277 1550if ($strict_warnings)
84f32c84
DMSP		 1551 {
1552 my $wopt;
1553 my $gccver = $predefined_C{__GNUC__} // -1;
1554 my $gxxver = $predefined_CXX{__GNUC__} // -1;
6d50589c 1555
84f32c84 1556 warn "WARNING --strict-warnings requires gcc[>=4] or gcc-alike"
6d50589c 1557 unless $gccver >= 4;
84f32c84 1558 warn "WARNING --strict-warnings requires g++[>=4] or g++-alike"
e373c70a 1559 unless $gxxver >= 4;
84f32c84
DMSP		 1560 foreach (qw(CFLAGS CXXFLAGS))
1561 {
1562 push @{$strict_warnings_collection{$_}},
1563 @{$gcc_devteam_warn{$_}};
1564 }
1565 push @{$strict_warnings_collection{CFLAGS}},
1566 @{$clang_devteam_warn{CFLAGS}}
1567 if (defined($predefined_C{__clang__}));
1568 push @{$strict_warnings_collection{CXXFLAGS}},
1569 @{$clang_devteam_warn{CXXFLAGS}}
1570 if (defined($predefined_CXX{__clang__}));
1571 }
e373c70a 1572foreach my $idx (qw(CFLAGS CXXFLAGS))
fcee5394 1573 {
e373c70a
RL		 1574 $useradd{$idx} = [ map { $_ eq '--ossl-strict-warnings'
1575 ? @{$strict_warnings_collection{$idx}}
1576 : ( $_ ) }
1577 @{$useradd{$idx}} ];
fcee5394 1578 }
ef8ca6bd
RL		 1579
1580unless ($disabled{"crypto-mdebug-backtrace"})
84f32c84
DMSP		 1581 {
1582 foreach my $wopt (split /\s+/, $memleak_devteam_backtrace)
1583 {
1584 push @{$config{cflags}}, $wopt
1585 unless grep { $_ eq $wopt } @{$config{cflags}};
1586 push @{$config{cxxflags}}, $wopt
1587 if ($config{CXX}
1588 && !grep { $_ eq $wopt } @{$config{cxxflags}});
1589 }
1590 if ($target =~ /^BSD-/)
1591 {
1592 push @{$config{ex_libs}}, "-lexecinfo";
1593 }
1594 }
0c28f277 1595
c91a0a83
EK		 1596unless ($disabled{afalgeng}) {
1597 $config{afalgeng}="";
9e381e8a 1598 if (grep { $_ eq 'afalgeng' } @{$target{enable}}) {
79fff39d 1599 my $minver = 4*10000 + 1*100 + 0;
abe256e7 1600 if ($config{CROSS_COMPILE} eq "") {
79fff39d
RL		 1601 my $verstr = `uname -r`;
1602 my ($ma, $mi1, $mi2) = split("\\.", $verstr);
1603 ($mi2) = $mi2 =~ /(\d+)/;
1604 my $ver = $ma*10000 + $mi1*100 + $mi2;
1605 if ($ver < $minver) {
c91a0a83 1606 $disabled{afalgeng} = "too-old-kernel";
79fff39d
RL		 1607 } else {
1608 push @{$config{engdirs}}, "afalg";
1609 }
68dc37c1
MC		 1610 } else {
1611 $disabled{afalgeng} = "cross-compiling";
6cba4a66 1612 }
79fff39d 1613 } else {
c91a0a83 1614 $disabled{afalgeng} = "not-linux";
7f458a48 1615 }
1616}
8da00a38 1617
e0bf7c01 1618push @{$config{openssl_feature_defines}}, "OPENSSL_NO_AFALGENG" if ($disabled{afalgeng});
7f458a48 1619
69495e3d
BP		 1620unless ($disabled{ktls}) {
1621 $config{ktls}="";
1622 if ($target =~ m/^linux/) {
1623 my $usr = "/usr/$config{cross_compile_prefix}";
1624 chop($usr);
1625 if ($config{cross_compile_prefix} eq "") {
1626 $usr = "/usr";
1627 }
1628 my $minver = (4 << 16) + (13 << 8) + 0;
1629 my @verstr = split(" ",`cat $usr/include/linux/version.h | grep LINUX_VERSION_CODE`);
1630
1631 if ($verstr[2] < $minver) {
1632 $disabled{ktls} = "too-old-kernel";
1633 }
1634 } else {
1635 $disabled{ktls} = "not-linux";
1636 }
1637}
1638
1639push @{$config{openssl_other_defines}}, "OPENSSL_NO_KTLS" if ($disabled{ktls});
1640
63468812
RL		 1641# Finish up %config by appending things the user gave us on the command line
1642# apart from "make variables"
1643foreach (keys %useradd) {
1644 # The must all be lists, so we assert that here
1645 die "internal error: \$useradd{$_} isn't an ARRAY\n"
1646 unless ref $useradd{$_} eq 'ARRAY';
1647
abe256e7
RL		 1648 if (defined $config{$_}) {
1649 push @{$config{$_}}, @{$useradd{$_}};
63468812 1650 } else {
abe256e7 1651 $config{$_} = [ @{$useradd{$_}} ];
63468812
RL		 1652 }
1653}
1654
5b18235a
RL		 1655# ALL MODIFICATIONS TO %config and %target MUST BE DONE FROM HERE ON
1656
9fe2bb77
RL		 1657# If we use the unified build, collect information from build.info files
1658my %unified_info = ();
1659
2b6b606c 1660my $buildinfo_debug = defined($ENV{CONFIGURE_DEBUG_BUILDINFO});
ddf1847d 1661if ($builder eq "unified") {
9fe2bb77
RL		 1662 use with_fallback qw(Text::Template);
1663
9fe2bb77 1664 sub cleandir {
2e963849 1665 my $base = shift;
9fe2bb77 1666 my $dir = shift;
2e963849
RL		 1667 my $relativeto = shift || ".";
1668
1669 $dir = catdir($base,$dir) unless isabsolute($dir);
9fe2bb77 1670
ec182ef0
RL		 1671 # Make sure the directories we're building in exists
1672 mkpath($dir);
1673
2e963849 1674 my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
9fe2bb77
RL		 1675 #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1676 return $res;
1677 }
1678
1679 sub cleanfile {
2e963849 1680 my $base = shift;
9fe2bb77 1681 my $file = shift;
2e963849
RL		 1682 my $relativeto = shift || ".";
1683
1684 $file = catfile($base,$file) unless isabsolute($file);
1685
9fe2bb77
RL		 1686 my $d = dirname($file);
1687 my $f = basename($file);
1688
ec182ef0
RL		 1689 # Make sure the directories we're building in exists
1690 mkpath($d);
1691
2e963849 1692 my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
9fe2bb77
RL		 1693 #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1694 return $res;
1695 }
1696
1967a42e
RL		 1697 # Store the name of the template file we will build the build file from
1698 # in %config. This may be useful for the build file itself.
1699 my @build_file_template_names =
84f32c84
DMSP		 1700 ( $builder_platform."-".$target{build_file}.".tmpl",
1701 $target{build_file}.".tmpl" );
1967a42e
RL		 1702 my @build_file_templates = ();
1703
1704 # First, look in the user provided directory, if given
7ecdf18d 1705 if (defined env($local_config_envname)) {
84f32c84
DMSP		 1706 @build_file_templates =
1707 map {
1708 if ($^O eq 'VMS') {
1709 # VMS environment variables are logical names,
1710 # which can be used as is
1711 $local_config_envname . ':' . $_;
1712 } else {
1713 catfile(env($local_config_envname), $_);
1714 }
1715 }
1716 @build_file_template_names;
1967a42e
RL		 1717 }
1718 # Then, look in our standard directory
1719 push @build_file_templates,
84f32c84
DMSP		 1720 ( map { cleanfile($srcdir, catfile("Configurations", $_), $blddir) }
1721 @build_file_template_names );
1967a42e
RL		 1722
1723 my $build_file_template;
1724 for $_ (@build_file_templates) {
84f32c84 1725 $build_file_template = $_;
1967a42e
RL		 1726 last if -f $build_file_template;
1727
1728 $build_file_template = undef;
1729 }
1730 if (!defined $build_file_template) {
84f32c84 1731 die "*** Couldn't find any of:\n", join("\n", @build_file_templates), "\n";
1967a42e
RL		 1732 }
1733 $config{build_file_templates}
8258975c
RL		 1734 = [ cleanfile($srcdir, catfile("Configurations", "common0.tmpl"),
1735 $blddir),
1736 $build_file_template,
1967a42e
RL		 1737 cleanfile($srcdir, catfile("Configurations", "common.tmpl"),
1738 $blddir) ];
1739
7f73eafe 1740 my @build_dirs = ( [ ] ); # current directory
9fe2bb77 1741
2e0956ba
RL		 1742 $config{build_infos} = [ ];
1743
d201dbc9 1744 my %ordinals = ();
7f73eafe
RL		 1745 while (@build_dirs) {
1746 my @curd = @{shift @build_dirs};
1747 my $sourced = catdir($srcdir, @curd);
1748 my $buildd = catdir($blddir, @curd);
9fe2bb77 1749
75d47db4
RL		 1750 my $unixdir = join('/', @curd);
1751 if (exists $skipdir{$unixdir}) {
1752 my $what = $skipdir{$unixdir};
1753 push @{$disabled_info{$what}->{skipped}}, catdir(@curd);
1754 next;
1755 }
1756
dca99383 1757 mkpath($buildd);
9fe2bb77 1758
7f73eafe 1759 my $f = 'build.info';
9fe2bb77
RL		 1760 # The basic things we're trying to build
1761 my @programs = ();
1762 my @libraries = ();
1842f369 1763 my @modules = ();
9fe2bb77 1764 my @scripts = ();
9fe2bb77 1765
c91f24d4 1766 my %attributes = ();
9fe2bb77 1767 my %sources = ();
2a08d1a0 1768 my %shared_sources = ();
9fe2bb77 1769 my %includes = ();
b96ab5e6 1770 my %defines = ();
9fe2bb77 1771 my %depends = ();
ae4c7450 1772 my %generate = ();
9fe2bb77 1773
846e4c4d
RL		 1774 # We want to detect configdata.pm in the source tree, so we
1775 # don't use it if the build tree is different.
1776 my $src_configdata = cleanfile($srcdir, "configdata.pm", $blddir);
1777
2e0956ba 1778 push @{$config{build_infos}}, catfile(abs2rel($sourced, $blddir), $f);
cb6afcd6
RL		 1779 my $template =
1780 Text::Template->new(TYPE => 'FILE',
1781 SOURCE => catfile($sourced, $f),
1782 PREPEND => qq{use lib "$FindBin::Bin/util/perl";});
9fe2bb77
RL		 1783 die "Something went wrong with $sourced/$f: $!\n" unless $template;
1784 my @text =
1785 split /^/m,
1786 $template->fill_in(HASH => { config => \%config,
1787 target => \%target,
9e04edf2 1788 disabled => \%disabled,
f59d0131 1789 withargs => \%withargs,
9fe2bb77
RL		 1790 builddir => abs2rel($buildd, $blddir),
1791 sourcedir => abs2rel($sourced, $blddir),
1792 buildtop => abs2rel($blddir, $blddir),
1793 sourcetop => abs2rel($srcdir, $blddir) },
1794 DELIMITERS => [ "{-", "-}" ]);
1795
1796 # The top item of this stack has the following values
1797 # -2 positive already run and we found ELSE (following ELSIF should fail)
1798 # -1 positive already run (skip until ENDIF)
1799 # 0 negatives so far (if we're at a condition, check it)
1800 # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
1801 # 2 positive ELSE (following ELSIF should fail)
1802 my @skip = ();
1803 collect_information(
1804 collect_from_array([ @text ],
1805 qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
1806 $l1 =~ s/\\$//; $l1.$l2 }),
1807 # Info we're looking for
1808 qr/^\s*IF\[((?:\\.|[^\\\]])*)\]\s*$/
635bd409 1809 => sub {
c5798e0e 1810 if (! @skip || $skip[$#skip] > 0) {
635bd409
RL		 1811 push @skip, !! $1;
1812 } else {
1813 push @skip, -1;
1814 }
1815 },
9fe2bb77
RL		 1816 qr/^\s*ELSIF\[((?:\\.|[^\\\]])*)\]\s*$/
1817 => sub { die "ELSIF out of scope" if ! @skip;
1818 die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
1819 $skip[$#skip] = -1 if $skip[$#skip] != 0;
1820 $skip[$#skip] = !! $1
1821 if $skip[$#skip] == 0; },
1822 qr/^\s*ELSE\s*$/
1823 => sub { die "ELSE out of scope" if ! @skip;
1824 $skip[$#skip] = -2 if $skip[$#skip] != 0;
1825 $skip[$#skip] = 2 if $skip[$#skip] == 0; },
1826 qr/^\s*ENDIF\s*$/
1827 => sub { die "ENDIF out of scope" if ! @skip;
1828 pop @skip; },
7f73eafe
RL		 1829 qr/^\s*SUBDIRS\s*=\s*(.*)\s*$/
1830 => sub {
1831 if (!@skip || $skip[$#skip] > 0) {
1832 foreach (tokenize($1)) {
1833 push @build_dirs, [ @curd, splitdir($_, 1) ];
1834 }
1835 }
1836 },
c91f24d4 1837 qr/^\s*PROGRAMS(?:{([\w=]+(?:\s*,\s*[\w=]+)*)})?\s*=\s*(.*)\s*$/
7f5af797
RL		 1838 => sub {
1839 if (!@skip || $skip[$#skip] > 0) {
c91f24d4
RL		 1840 my @a = tokenize($1, qr|\s*,\s*|);
1841 my @p = tokenize($2);
1842 push @programs, @p;
1843 foreach my $a (@a) {
1844 my $ak = $a;
1845 my $av = 1;
1846 if ($a =~ m|^(.*?)\s*=\s*(.*?)$|) {
1847 $ak = $1;
1848 $av = $2;
1849 }
1850 foreach my $p (@p) {
1851 $attributes{$p}->{$ak} = $av;
1852 }
1853 }
7f5af797
RL		 1854 }
1855 },
c91f24d4 1856 qr/^\s*LIBS(?:{([\w=]+(?:\s*,\s*[\w=]+)*)})?\s*=\s*(.*)\s*$/
7f5af797
RL		 1857 => sub {
1858 if (!@skip || $skip[$#skip] > 0) {
c91f24d4
RL		 1859 my @a = tokenize($1, qr|\s*,\s*|);
1860 my @l = tokenize($2);
1861 push @libraries, @l;
1862 foreach my $a (@a) {
1863 my $ak = $a;
1864 my $av = 1;
1865 if ($a =~ m|^(.*?)\s*=\s*(.*?)$|) {
1866 $ak = $1;
1867 $av = $2;
1868 }
1869 foreach my $l (@l) {
1870 $attributes{$l}->{$ak} = $av;
1871 }
1872 }
7f5af797
RL		 1873 }
1874 },
1842f369 1875 qr/^\s*MODULES(?:{([\w=]+(?:\s*,\s*[\w=]+)*)})?\s*=\s*(.*)\s*$/
7f5af797
RL		 1876 => sub {
1877 if (!@skip || $skip[$#skip] > 0) {
c91f24d4 1878 my @a = tokenize($1, qr|\s*,\s*|);
1842f369
RL		 1879 my @m = tokenize($2);
1880 push @modules, @m;
c91f24d4
RL		 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 }
1842f369
RL		 1888 foreach my $m (@m) {
1889 $attributes{$m}->{$ak} = $av;
c91f24d4
RL		 1890 }
1891 }
7f5af797
RL		 1892 }
1893 },
c91f24d4 1894 qr/^\s*SCRIPTS(?:{([\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 @s = tokenize($2);
1899 push @scripts, @s;
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 $s (@s) {
1908 $attributes{$s}->{$ak} = $av;
1909 }
1910 }
7f5af797
RL		 1911 }
1912 },
9fe2bb77
RL		 1913
1914 qr/^\s*ORDINALS\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/,
ce959812 1915 => sub { push @{$ordinals{$1}}, tokenize($2)
9fe2bb77
RL		 1916 if !@skip || $skip[$#skip] > 0 },
1917 qr/^\s*SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1918 => sub { push @{$sources{$1}}, tokenize($2)
9fe2bb77 1919 if !@skip || $skip[$#skip] > 0 },
2a08d1a0 1920 qr/^\s*SHARED_SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1921 => sub { push @{$shared_sources{$1}}, tokenize($2)
2a08d1a0 1922 if !@skip || $skip[$#skip] > 0 },
9fe2bb77 1923 qr/^\s*INCLUDE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1924 => sub { push @{$includes{$1}}, tokenize($2)
9fe2bb77 1925 if !@skip || $skip[$#skip] > 0 },
b96ab5e6
RL		 1926 qr/^\s*DEFINE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1927 => sub { push @{$defines{$1}}, tokenize($2)
1928 if !@skip || $skip[$#skip] > 0 },
4f858293 1929 qr/^\s*DEPEND\[((?:\\.|[^\\\]])*)\]\s*=\s*(.*)\s*$/
ce959812 1930 => sub { push @{$depends{$1}}, tokenize($2)
9fe2bb77 1931 if !@skip || $skip[$#skip] > 0 },
ae4c7450
RL		 1932 qr/^\s*GENERATE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1933 => sub { push @{$generate{$1}}, $2
1934 if !@skip || $skip[$#skip] > 0 },
ab6e147c 1935 qr/^\s*(?:#.*)?$/ => sub { },
2b6b606c
RL		 1936 "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" },
1937 "BEFORE" => sub {
1938 if ($buildinfo_debug) {
1939 print STDERR "DEBUG: Parsing ",join(" ", @_),"\n";
1940 print STDERR "DEBUG: ... before parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1941 }
1942 },
1943 "AFTER" => sub {
1944 if ($buildinfo_debug) {
1945 print STDERR "DEBUG: .... after parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1946 }
1947 },
9fe2bb77
RL		 1948 );
1949 die "runaway IF?" if (@skip);
1950
1842f369
RL		 1951 if (grep { defined $attributes{$_}->{engine} } keys %attributes
1952 and !$config{dynamic_engines}) {
1953 die <<"EOF"
19ab5790 1954ENGINES can only be used if configured with 'dynamic-engine'.
9fe2bb77
RL		 1955This is usually a fault in a build.info file.
1956EOF
1842f369 1957 }
7f5af797 1958
c91f24d4
RL		 1959 foreach (keys %attributes) {
1960 my $dest = $_;
1961 my $ddest = cleanfile($buildd, $_, $blddir);
1962 foreach (keys %{$attributes{$dest} // {}}) {
1963 $unified_info{attributes}->{$ddest}->{$_} =
1964 $attributes{$dest}->{$_};
1965 }
9fe2bb77
RL		 1966 }
1967
c91f24d4
RL		 1968 {
1969 my %infos = ( programs => [ @programs ],
1970 libraries => [ @libraries ],
1842f369 1971 modules => [ @modules ],
da7e31e0 1972 scripts => [ @scripts ] );
c91f24d4
RL		 1973 foreach my $k (keys %infos) {
1974 foreach (@{$infos{$k}}) {
1975 my $item = cleanfile($buildd, $_, $blddir);
1976 $unified_info{$k}->{$item} = 1;
1977 }
1978 }
8a67946e
RL		 1979 }
1980
f5fb6f05
RL		 1981 # Check that we haven't defined any library as both shared and
1982 # explicitly static. That is forbidden.
1983 my @doubles = ();
1984 foreach (grep /\.a$/, keys %{$unified_info{libraries}}) {
1985 (my $l = $_) =~ s/\.a$//;
1986 push @doubles, $l if defined $unified_info{libraries}->{$l};
9fe2bb77 1987 }
f5fb6f05
RL		 1988 die "these libraries are both explicitly static and shared:\n ",
1989 join(" ", @doubles), "\n"
1990 if @doubles;
9fe2bb77 1991
9fe2bb77
RL		 1992 foreach (keys %sources) {
1993 my $dest = $_;
2e963849 1994 my $ddest = cleanfile($buildd, $_, $blddir);
9fe2bb77 1995 foreach (@{$sources{$dest}}) {
2e963849 1996 my $s = cleanfile($sourced, $_, $blddir);
9fe2bb77
RL		 1997
1998 # If it isn't in the source tree, we assume it's generated
1999 # in the build tree
846e4c4d 2000 if ($s eq $src_configdata || ! -f $s || $generate{$_}) {
2e963849 2001 $s = cleanfile($buildd, $_, $blddir);
9fe2bb77 2002 }
ea241958
RL		 2003 # We recognise C++, C and asm files
2004 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
2005 my $o = $_;
2006 $o =~ s/\.[csS]$/.o/; # C and assembler
2007 $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
2e963849 2008 $o = cleanfile($buildd, $o, $blddir);
bec2db18
RL		 2009 $unified_info{sources}->{$ddest}->{$o} = -1;
2010 $unified_info{sources}->{$o}->{$s} = -1;
83900628
RS		 2011 } elsif ($s =~ /\.rc$/) {
2012 # We also recognise resource files
2013 my $o = $_;
2014 $o =~ s/\.rc$/.res/; # Resource configuration
2015 my $o = cleanfile($buildd, $o, $blddir);
bec2db18
RL		 2016 $unified_info{sources}->{$ddest}->{$o} = -1;
2017 $unified_info{sources}->{$o}->{$s} = -1;
9fe2bb77
RL		 2018 } else {
2019 $unified_info{sources}->{$ddest}->{$s} = 1;
2020 }
2021 }
2022 }
2023
2a08d1a0
RL		 2024 foreach (keys %shared_sources) {
2025 my $dest = $_;
2026 my $ddest = cleanfile($buildd, $_, $blddir);
2a08d1a0
RL		 2027 foreach (@{$shared_sources{$dest}}) {
2028 my $s = cleanfile($sourced, $_, $blddir);
2029
2030 # If it isn't in the source tree, we assume it's generated
2031 # in the build tree
846e4c4d 2032 if ($s eq $src_configdata || ! -f $s || $generate{$_}) {
2a08d1a0
RL		 2033 $s = cleanfile($buildd, $_, $blddir);
2034 }
ccce3e1d 2035
ea241958 2036 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
ccce3e1d 2037 # We recognise C++, C and asm files
ea241958
RL		 2038 my $o = $_;
2039 $o =~ s/\.[csS]$/.o/; # C and assembler
2040 $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
2a08d1a0 2041 $o = cleanfile($buildd, $o, $blddir);
bec2db18
RL		 2042 $unified_info{shared_sources}->{$ddest}->{$o} = -1;
2043 $unified_info{sources}->{$o}->{$s} = -1;
ccce3e1d
RL		 2044 } elsif ($s =~ /\.rc$/) {
2045 # We also recognise resource files
2046 my $o = $_;
2047 $o =~ s/\.rc$/.res/; # Resource configuration
2048 my $o = cleanfile($buildd, $o, $blddir);
bec2db18
RL		 2049 $unified_info{shared_sources}->{$ddest}->{$o} = -1;
2050 $unified_info{sources}->{$o}->{$s} = -1;
ef2dfc99
RL		 2051 } elsif ($s =~ /\.ld$/) {
2052 # We also recognise linker scripts (or corresponding)
ccce3e1d 2053 # We know they are generated files
05a72c28 2054 my $ld = cleanfile($buildd, $_, $blddir);
ef2dfc99 2055 $unified_info{shared_sources}->{$ddest}->{$ld} = 1;
2a08d1a0
RL		 2056 } else {
2057 die "unrecognised source file type for shared library: $s\n";
2058 }
2059 }
2060 }
2061
ae4c7450
RL		 2062 foreach (keys %generate) {
2063 my $dest = $_;
2064 my $ddest = cleanfile($buildd, $_, $blddir);
ae4c7450
RL		 2065 die "more than one generator for $dest: "
2066 ,join(" ", @{$generate{$_}}),"\n"
2067 if scalar @{$generate{$_}} > 1;
2068 my @generator = split /\s+/, $generate{$dest}->[0];
2069 $generator[0] = cleanfile($sourced, $generator[0], $blddir),
2070 $unified_info{generate}->{$ddest} = [ @generator ];
2071 }
2072
9fe2bb77
RL		 2073 foreach (keys %depends) {
2074 my $dest = $_;
4f858293 2075 my $ddest = $dest eq "" ? "" : cleanfile($sourced, $_, $blddir);
8d34daf0
RL		 2076
2077 # If the destination doesn't exist in source, it can only be
2078 # a generated file in the build tree.
846e4c4d 2079 if ($ddest ne "" && ($ddest eq $src_configdata || ! -f $ddest)) {
8d34daf0 2080 $ddest = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 2081 }
2082 foreach (@{$depends{$dest}}) {
2e963849 2083 my $d = cleanfile($sourced, $_, $blddir);
9fe2bb77 2084
e737d7b1
RL		 2085 # If we know it's generated, or assume it is because we can't
2086 # find it in the source tree, we set file we depend on to be
2087 # in the build tree rather than the source tree, and assume
2088 # and that there are lines to build it in a BEGINRAW..ENDRAW
2089 # section or in the Makefile template.
846e4c4d
RL		 2090 if ($d eq $src_configdata
2091 || ! -f $d
da1f2104
RL		 2092 || (grep { $d eq $_ }
2093 map { cleanfile($srcdir, $_, $blddir) }
4f858293 2094 grep { /\.h$/ } keys %{$unified_info{generate}})) {
2e963849 2095 $d = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 2096 }
2097 # Take note if the file to depend on is being renamed
186a31e5
RL		 2098 # Take extra care with files ending with .a, they should
2099 # be treated without that extension, and the extension
2100 # should be added back after treatment.
2101 $d =~ /(\.a)?$/;
2102 my $e = $1 // "";
f5fb6f05 2103 $d = $`.$e;
9fe2bb77 2104 $unified_info{depends}->{$ddest}->{$d} = 1;
9fe2bb77
RL		 2105 }
2106 }
2107
2108 foreach (keys %includes) {
2109 my $dest = $_;
8d34daf0
RL		 2110 my $ddest = cleanfile($sourced, $_, $blddir);
2111
2112 # If the destination doesn't exist in source, it can only be
2113 # a generated file in the build tree.
846e4c4d 2114 if ($ddest eq $src_configdata || ! -f $ddest) {
8d34daf0 2115 $ddest = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 2116 }
2117 foreach (@{$includes{$dest}}) {
4748f890
RL		 2118 my $is = cleandir($sourced, $_, $blddir);
2119 my $ib = cleandir($buildd, $_, $blddir);
2120 push @{$unified_info{includes}->{$ddest}->{source}}, $is
2121 unless grep { $_ eq $is } @{$unified_info{includes}->{$ddest}->{source}};
2122 push @{$unified_info{includes}->{$ddest}->{build}}, $ib
2123 unless grep { $_ eq $ib } @{$unified_info{includes}->{$ddest}->{build}};
9fe2bb77
RL		 2124 }
2125 }
b96ab5e6
RL		 2126
2127 foreach (keys %defines) {
2128 my $dest = $_;
2129 my $ddest = cleanfile($sourced, $_, $blddir);
2130
2131 # If the destination doesn't exist in source, it can only be
2132 # a generated file in the build tree.
2133 if (! -f $ddest) {
2134 $ddest = cleanfile($buildd, $_, $blddir);
2135 if ($unified_info{rename}->{$ddest}) {
2136 $ddest = $unified_info{rename}->{$ddest};
2137 }
2138 }
2139 foreach (@{$defines{$dest}}) {
2140 m|^([^=]*)(=.*)?$|;
2141 die "0 length macro name not permitted\n" if $1 eq "";
2142 die "$1 defined more than once\n"
2143 if defined $unified_info{defines}->{$ddest}->{$1};
2144 $unified_info{defines}->{$ddest}->{$1} = $2;
2145 }
2146 }
9fe2bb77
RL		 2147 }
2148
d201dbc9
RL		 2149 my $ordinals_text = join(', ', sort keys %ordinals);
2150 warn <<"EOF" if $ordinals_text;
2151
2152WARNING: ORDINALS were specified for $ordinals_text
2153They are ignored and should be replaced with a combination of GENERATE,
2154DEPEND and SHARED_SOURCE.
2155EOF
2156
1b5ad51f
RL		 2157 # Massage the result
2158
e431bcfa
RL		 2159 # If we depend on a header file or a perl module, add an inclusion of
2160 # its directory to allow smoothe inclusion
2161 foreach my $dest (keys %{$unified_info{depends}}) {
2162 next if $dest eq "";
2163 foreach my $d (keys %{$unified_info{depends}->{$dest}}) {
2164 next unless $d =~ /\.(h|pm)$/;
906032d5
RL		 2165 my $i = dirname($d);
2166 my $spot =
2167 $d eq "configdata.pm" || defined($unified_info{generate}->{$d})
2168 ? 'build' : 'source';
2169 push @{$unified_info{includes}->{$dest}->{$spot}}, $i
2170 unless grep { $_ eq $i } @{$unified_info{includes}->{$dest}->{$spot}};
e431bcfa
RL		 2171 }
2172 }
2173
ef2dfc99 2174 # Go through all intermediary files and change their names to something that
bec2db18
RL		 2175 # reflects what they will be built for. Note that for some source files,
2176 # this leads to duplicate object files because they are used multiple times.
2177 # the goal is to rename all object files according to this scheme:
2178 # {productname}-{midfix}-{origobjname}.[o|res]
2179 # the {midfix} is a keyword indicating the type of product, which is mostly
2180 # valuable for libraries since they come in two forms.
2181 #
2182 # This also reorganises the {sources} and {shared_sources} so that the
2183 # former only contains ALL object files that are supposed to end up in
2184 # static libraries and programs, while the latter contains ALL object files
2185 # that are supposed to end up in shared libraries and DSOs.
2186 # The main reason for having two different source structures is to allow
2187 # the same name to be used for the static and the shared variants of a
2188 # library.
2189 {
2190 # Take copies so we don't get interference from added stuff
2191 my %unified_copy = ();
2192 foreach (('sources', 'shared_sources')) {
2193 $unified_copy{$_} = { %{$unified_info{$_}} }
2194 if defined($unified_info{$_});
2195 delete $unified_info{$_};
2196 }
1842f369 2197 foreach my $prodtype (('programs', 'libraries', 'modules', 'scripts')) {
bec2db18
RL		 2198 # $intent serves multi purposes:
2199 # - give a prefix for the new object files names
2200 # - in the case of libraries, rearrange the object files so static
2201 # libraries use the 'sources' structure exclusively, while shared
2202 # libraries use the 'shared_sources' structure exclusively.
2203 my $intent = {
2204 programs => { bin => { src => [ 'sources' ],
2205 dst => 'sources' } },
2206 libraries => { lib => { src => [ 'sources' ],
2207 dst => 'sources' },
2208 shlib => { prodselect =>
2209 sub { grep !/\.a$/, @_ },
2210 src => [ 'sources',
2211 'shared_sources' ],
2212 dst => 'shared_sources' } },
22b41467
RL		 2213 modules => { dso => { src => [ 'sources' ],
2214 dst => 'sources' } },
bec2db18
RL		 2215 scripts => { script => { src => [ 'sources' ],
2216 dst => 'sources' } }
2217 } -> {$prodtype};
2218 foreach my $kind (keys %$intent) {
856b1b65
RL		 2219 next if ($intent->{$kind}->{dst} eq 'shared_sources'
2220 && $disabled{shared});
2221
bec2db18
RL		 2222 my @src = @{$intent->{$kind}->{src}};
2223 my $dst = $intent->{$kind}->{dst};
2224 my $prodselect = $intent->{$kind}->{prodselect} // sub { @_ };
2225 foreach my $prod ($prodselect->(keys %{$unified_info{$prodtype}})) {
2226 # %prod_sources has all applicable objects as keys, and
2227 # their corresponding sources as values
2228 my %prod_sources =
2229 map { $_ => [ keys %{$unified_copy{sources}->{$_}} ] }
2230 map { keys %{$unified_copy{$_}->{$prod}} }
2231 @src;
2232 foreach (keys %prod_sources) {
ef2dfc99
RL		 2233 # Only affect object files and resource files,
2234 # the others simply get a new value
2235 # (+1 instead of -1)
bec2db18
RL		 2236 if ($_ =~ /\.(o|res)$/) {
2237 (my $prodname = $prod) =~ s|\.a$||;
2238 my $newobj =
2239 catfile(dirname($_),
2240 basename($prodname)
2241 . '-' . $kind
2242 . '-' . basename($_));
2243 $unified_info{$dst}->{$prod}->{$newobj} = 1;
2244 foreach my $src (@{$prod_sources{$_}}) {
2245 $unified_info{sources}->{$newobj}->{$src} = 1;
2246 }
2247 # Adjust dependencies
2248 foreach my $deps (keys %{$unified_info{depends}->{$_}}) {
2249 $unified_info{depends}->{$_}->{$deps} = -1;
2250 $unified_info{depends}->{$newobj}->{$deps} = 1;
2251 }
2252 # Adjust includes
2253 foreach my $k (('source', 'build')) {
2254 next unless
2255 defined($unified_info{includes}->{$_}->{$k});
2256 my @incs = @{$unified_info{includes}->{$_}->{$k}};
2257 $unified_info{includes}->{$newobj}->{$k} = [ @incs ];
2258 }
2259 } else {
2260 $unified_info{$dst}->{$prod}->{$_} = 1;
2261 }
2262 }
2263 }
2264 }
2265 }
2266 }
2267 # At this point, we have a number of sources with the value -1. They
2268 # aren't part of the local build and are probably meant for a different
2269 # platform, and can therefore be cleaned away. That happens when making
2270 # %unified_info more efficient below.
2271
9fe2bb77
RL		 2272 ### Make unified_info a bit more efficient
2273 # One level structures
1842f369 2274 foreach (("programs", "libraries", "modules", "scripts")) {
9fe2bb77
RL		 2275 $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
2276 }
2277 # Two level structures
c91f24d4 2278 foreach my $l1 (("sources", "shared_sources", "ldadd", "depends")) {
9fe2bb77 2279 foreach my $l2 (sort keys %{$unified_info{$l1}}) {
bec2db18
RL		 2280 my @items =
2281 sort
2282 grep { $unified_info{$l1}->{$l2}->{$_} > 0 }
2283 keys %{$unified_info{$l1}->{$l2}};
2284 if (@items) {
2285 $unified_info{$l1}->{$l2} = [ @items ];
2286 } else {
2287 delete $unified_info{$l1}->{$l2};
2288 }
9fe2bb77
RL		 2289 }
2290 }
b96ab5e6
RL		 2291 # Defines
2292 foreach my $dest (sort keys %{$unified_info{defines}}) {
2293 $unified_info{defines}->{$dest}
2294 = [ map { $_.$unified_info{defines}->{$dest}->{$_} }
2295 sort keys %{$unified_info{defines}->{$dest}} ];
2296 }
4748f890
RL		 2297 # Includes
2298 foreach my $dest (sort keys %{$unified_info{includes}}) {
2299 if (defined($unified_info{includes}->{$dest}->{build})) {
e431bcfa
RL		 2300 my @source_includes = ();
2301 @source_includes = ( @{$unified_info{includes}->{$dest}->{source}} )
2302 if defined($unified_info{includes}->{$dest}->{source});
4748f890
RL		 2303 $unified_info{includes}->{$dest} =
2304 [ @{$unified_info{includes}->{$dest}->{build}} ];
2305 foreach my $inc (@source_includes) {
2306 push @{$unified_info{includes}->{$dest}}, $inc
2307 unless grep { $_ eq $inc } @{$unified_info{includes}->{$dest}};
2308 }
609e4be8 2309 } elsif (defined($unified_info{includes}->{$dest}->{source})) {
4748f890
RL		 2310 $unified_info{includes}->{$dest} =
2311 [ @{$unified_info{includes}->{$dest}->{source}} ];
609e4be8
RL		 2312 } else {
2313 delete $unified_info{includes}->{$dest};
4748f890
RL		 2314 }
2315 }
b6e66075
RL		 2316
2317 # For convenience collect information regarding directories where
2318 # files are generated, those generated files and the end product
2319 # they end up in where applicable. Then, add build rules for those
2320 # directories
2321 my %loopinfo = ( "lib" => [ @{$unified_info{libraries}} ],
1842f369 2322 "dso" => [ @{$unified_info{modules}} ],
b6e66075
RL		 2323 "bin" => [ @{$unified_info{programs}} ],
2324 "script" => [ @{$unified_info{scripts}} ] );
2325 foreach my $type (keys %loopinfo) {
2326 foreach my $product (@{$loopinfo{$type}}) {
2327 my %dirs = ();
2328 my $pd = dirname($product);
2329
3bed01a0 2330 foreach (@{$unified_info{sources}->{$product} // []},
b6e66075
RL		 2331 @{$unified_info{shared_sources}->{$product} // []}) {
2332 my $d = dirname($_);
2333
2334 # We don't want to create targets for source directories
2335 # when building out of source
2336 next if ($config{sourcedir} ne $config{builddir}
2337 && $d =~ m|^\Q$config{sourcedir}\E|);
2338 # We already have a "test" target, and the current directory
2339 # is just silly to make a target for
2340 next if $d eq "test" || $d eq ".";
2341
2342 $dirs{$d} = 1;
2343 push @{$unified_info{dirinfo}->{$d}->{deps}}, $_
2344 if $d ne $pd;
2345 }
2346 foreach (keys %dirs) {
2347 push @{$unified_info{dirinfo}->{$_}->{products}->{$type}},
2348 $product;
2349 }
2350 }
2351 }
9fe2bb77
RL		 2352}
2353
2354# For the schemes that need it, we provide the old *_obj configs
2355# from the *_asm_obj ones
3a55c92b 2356foreach (grep /_(asm|aux)_src$/, keys %target) {
9fe2bb77 2357 my $src = $_;
3a55c92b 2358 (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
ea241958
RL		 2359 $target{$obj} = $target{$src};
2360 $target{$obj} =~ s/\.[csS]\b/.o/g; # C and assembler
2361 $target{$obj} =~ s/\.(cc|cpp)\b/_cc.o/g; # C++
9fe2bb77
RL		 2362}
2363
291e94df
RL		 2364# Write down our configuration where it fits #########################
2365
b1fafff6 2366print "Creating configdata.pm\n";
291e94df
RL		 2367open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
2368print OUT <<"EOF";
abe256e7 2369#! $config{HASHBANGPERL}
b1fafff6 2370
291e94df
RL		 2371package configdata;
2372
2373use strict;
2374use warnings;
2375
2376use Exporter;
2377#use vars qw(\@ISA \@EXPORT);
2378our \@ISA = qw(Exporter);
3850f8cb 2379our \@EXPORT = qw(\%config \%target \%disabled \%withargs \%unified_info \@disablables);
291e94df
RL		 2380
2381EOF
2382print OUT "our %config = (\n";
2383foreach (sort keys %config) {
2384 if (ref($config{$_}) eq "ARRAY") {
84f32c84
DMSP		 2385 print OUT " ", $_, " => [ ", join(", ",
2386 map { quotify("perl", $_) }
2387 @{$config{$_}}), " ],\n";
7ecdf18d 2388 } elsif (ref($config{$_}) eq "HASH") {
84f32c84 2389 print OUT " ", $_, " => {";
7ecdf18d
RL		 2390 if (scalar keys %{$config{$_}} > 0) {
2391 print OUT "\n";
2392 foreach my $key (sort keys %{$config{$_}}) {
2393 print OUT " ",
2394 join(" => ",
2395 quotify("perl", $key),
2396 defined $config{$_}->{$key}
2397 ? quotify("perl", $config{$_}->{$key})
2398 : "undef");
2399 print OUT ",\n";
2400 }
2401 print OUT " ";
2402 }
2403 print OUT "},\n";
291e94df 2404 } else {
84f32c84 2405 print OUT " ", $_, " => ", quotify("perl", $config{$_}), ",\n"
291e94df
RL		 2406 }
2407}
2408print OUT <<"EOF";
2409);
2410
2411EOF
2412print OUT "our %target = (\n";
2413foreach (sort keys %target) {
2414 if (ref($target{$_}) eq "ARRAY") {
84f32c84
DMSP		 2415 print OUT " ", $_, " => [ ", join(", ",
2416 map { quotify("perl", $_) }
2417 @{$target{$_}}), " ],\n";
291e94df 2418 } else {
84f32c84 2419 print OUT " ", $_, " => ", quotify("perl", $target{$_}), ",\n"
291e94df
RL		 2420 }
2421}
2422print OUT <<"EOF";
2423);
2424
96d2d7bc
RL		 2425EOF
2426print OUT "our \%available_protocols = (\n";
2427print OUT " tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n";
2428print OUT " dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n";
2429print OUT <<"EOF";
2430);
2431
3850f8cb
RL		 2432EOF
2433print OUT "our \@disablables = (\n";
2434foreach (@disablables) {
2435 print OUT " ", quotify("perl", $_), ",\n";
2436}
2437print OUT <<"EOF";
2438);
2439
96d2d7bc
RL		 2440EOF
2441print OUT "our \%disabled = (\n";
2442foreach (sort keys %disabled) {
2443 print OUT " ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n";
2444}
2445print OUT <<"EOF";
2446);
2447
291e94df 2448EOF
107b5792
RL		 2449print OUT "our %withargs = (\n";
2450foreach (sort keys %withargs) {
2451 if (ref($withargs{$_}) eq "ARRAY") {
84f32c84
DMSP		 2452 print OUT " ", $_, " => [ ", join(", ",
2453 map { quotify("perl", $_) }
2454 @{$withargs{$_}}), " ],\n";
107b5792 2455 } else {
84f32c84 2456 print OUT " ", $_, " => ", quotify("perl", $withargs{$_}), ",\n"
107b5792
RL		 2457 }
2458}
2459print OUT <<"EOF";
2460);
edd4d402 2461
107b5792 2462EOF
ddf1847d 2463if ($builder eq "unified") {
9fe2bb77
RL		 2464 my $recurse;
2465 $recurse = sub {
2466 my $indent = shift;
2467 foreach (@_) {
2468 if (ref $_ eq "ARRAY") {
2469 print OUT " "x$indent, "[\n";
2470 foreach (@$_) {
2471 $recurse->($indent + 4, $_);
2472 }
2473 print OUT " "x$indent, "],\n";
2474 } elsif (ref $_ eq "HASH") {
2475 my %h = %$_;
2476 print OUT " "x$indent, "{\n";
2477 foreach (sort keys %h) {
2478 if (ref $h{$_} eq "") {
2479 print OUT " "x($indent + 4), quotify("perl", $_), " => ", quotify("perl", $h{$_}), ",\n";
2480 } else {
2481 print OUT " "x($indent + 4), quotify("perl", $_), " =>\n";
2482 $recurse->($indent + 8, $h{$_});
2483 }
2484 }
2485 print OUT " "x$indent, "},\n";
2486 } else {
2487 print OUT " "x$indent, quotify("perl", $_), ",\n";
2488 }
2489 }
2490 };
2491 print OUT "our %unified_info = (\n";
2492 foreach (sort keys %unified_info) {
2493 if (ref $unified_info{$_} eq "") {
2494 print OUT " "x4, quotify("perl", $_), " => ", quotify("perl", $unified_info{$_}), ",\n";
2495 } else {
2496 print OUT " "x4, quotify("perl", $_), " =>\n";
2497 $recurse->(8, $unified_info{$_});
2498 }
2499 }
2500 print OUT <<"EOF";
2501);
2502
2503EOF
2504}
047f0292
RL		 2505print OUT
2506 "# The following data is only used when this files is use as a script\n";
abe256e7 2507print OUT "my \@makevars = (\n";
b1fafff6 2508foreach (sort keys %user) {
abe256e7 2509 print OUT " '",$_,"',\n";
b1fafff6
RL		 2510}
2511print OUT ");\n";
ca372414
RL		 2512print OUT "my \%disabled_info = (\n";
2513foreach my $what (sort keys %disabled_info) {
2514 print OUT " '$what' => {\n";
2515 foreach my $info (sort keys %{$disabled_info{$what}}) {
2516 if (ref $disabled_info{$what}->{$info} eq 'ARRAY') {
2517 print OUT " $info => [ ",
2518 join(', ', map { "'$_'" } @{$disabled_info{$what}->{$info}}),
2519 " ],\n";
2520 } else {
2521 print OUT " $info => '", $disabled_info{$what}->{$info},
2522 "',\n";
2523 }
2524 }
2525 print OUT " },\n";
2526}
2527print OUT ");\n";
f729ba55 2528print OUT 'my @user_crossable = qw( ', join (' ', @user_crossable), " );\n";
b1fafff6 2529print OUT << 'EOF';
b1fafff6
RL		 2530# If run directly, we can give some answers, and even reconfigure
2531unless (caller) {
2532 use Getopt::Long;
2533 use File::Spec::Functions;
2534 use File::Basename;
2535 use Pod::Usage;
2536
2537 my $here = dirname($0);
2538
2539 my $dump = undef;
2540 my $cmdline = undef;
ca372414 2541 my $options = undef;
50ea9d2b 2542 my $target = undef;
b1fafff6
RL		 2543 my $envvars = undef;
2544 my $makevars = undef;
2545 my $buildparams = undef;
2546 my $reconf = undef;
2547 my $verbose = undef;
2548 my $help = undef;
2549 my $man = undef;
2550 GetOptions('dump|d' => \$dump,
2551 'command-line|c' => \$cmdline,
ca372414 2552 'options|o' => \$options,
50ea9d2b 2553 'target|t' => \$target,
b1fafff6
RL		 2554 'environment|e' => \$envvars,
2555 'make-variables|m' => \$makevars,
2556 'build-parameters|b' => \$buildparams,
2557 'reconfigure|reconf|r' => \$reconf,
2558 'verbose|v' => \$verbose,
2559 'help' => \$help,
2560 'man' => \$man)
2561 or die "Errors in command line arguments\n";
2562
50ea9d2b 2563 unless ($dump || $cmdline || $options || $target || $envvars || $makevars
ca372414 2564 || $buildparams || $reconf || $verbose || $help || $man) {
b1fafff6
RL		 2565 print STDERR <<"_____";
2566You must give at least one option.
2567For more information, do '$0 --help'
2568_____
2569 exit(2);
2570 }
2571
2572 if ($help) {
2573 pod2usage(-exitval => 0,
2574 -verbose => 1);
2575 }
2576 if ($man) {
2577 pod2usage(-exitval => 0,
2578 -verbose => 2);
2579 }
2580 if ($dump || $cmdline) {
d5fa7035 2581 print "\nCommand line (with current working directory = $here):\n\n";
b1fafff6 2582 print ' ',join(' ',
9e265322 2583 $config{PERL},
b1fafff6
RL		 2584 catfile($config{sourcedir}, 'Configure'),
2585 @{$config{perlargv}}), "\n";
d5fa7035
RL		 2586 print "\nPerl information:\n\n";
2587 print ' ',$config{perl_cmd},"\n";
2588 print ' ',$config{perl_version},' for ',$config{perl_archname},"\n";
b1fafff6 2589 }
ca372414
RL		 2590 if ($dump || $options) {
2591 my $longest = 0;
0b80103b 2592 my $longest2 = 0;
ca372414
RL		 2593 foreach my $what (@disablables) {
2594 $longest = length($what) if $longest < length($what);
1d2c6b7d
RL		 2595 $longest2 = length($disabled{$what})
2596 if $disabled{$what} && $longest2 < length($disabled{$what});
ca372414
RL		 2597 }
2598 print "\nEnabled features:\n\n";
2599 foreach my $what (@disablables) {
2600 print " $what\n" unless $disabled{$what};
2601 }
2602 print "\nDisabled features:\n\n";
2603 foreach my $what (@disablables) {
2604 if ($disabled{$what}) {
2605 print " $what", ' ' x ($longest - length($what) + 1),
0b80103b 2606 "[$disabled{$what}]", ' ' x ($longest2 - length($disabled{$what}) + 1);
ca372414
RL		 2607 print $disabled_info{$what}->{macro}
2608 if $disabled_info{$what}->{macro};
2609 print ' (skip ',
2610 join(', ', @{$disabled_info{$what}->{skipped}}),
2611 ')'
2612 if $disabled_info{$what}->{skipped};
2613 print "\n";
2614 }
2615 }
2616 }
50ea9d2b
RL		 2617 if ($dump || $target) {
2618 print "\nConfig target attributes:\n\n";
2619 foreach (sort keys %target) {
2620 next if $_ =~ m|^_| || $_ eq 'template';
2621 my $quotify = sub {
2622 map { (my $x = $_) =~ s|([\\\$\@"])|\\$1|g; "\"$x\""} @_;
2623 };
2624 print ' ', $_, ' => ';
2625 if (ref($target{$_}) eq "ARRAY") {
2626 print '[ ', join(', ', $quotify->(@{$target{$_}})), " ],\n";
2627 } else {
2628 print $quotify->($target{$_}), ",\n"
2629 }
2630 }
2631 }
b1fafff6
RL		 2632 if ($dump || $envvars) {
2633 print "\nRecorded environment:\n\n";
2634 foreach (sort keys %{$config{perlenv}}) {
2635 print ' ',$_,' = ',($config{perlenv}->{$_} || ''),"\n";
2636 }
2637 }
2638 if ($dump || $makevars) {
2639 print "\nMakevars:\n\n";
abe256e7 2640 foreach my $var (@makevars) {
f729ba55 2641 my $prefix = '';
abe256e7 2642 $prefix = $config{CROSS_COMPILE}
f729ba55 2643 if grep { $var eq $_ } @user_crossable;
b700bc59 2644 $prefix //= '';
f729ba55 2645 print ' ',$var,' ' x (16 - length $var),'= ',
abe256e7
RL		 2646 (ref $config{$var} eq 'ARRAY'
2647 ? join(' ', @{$config{$var}})
2648 : $prefix.$config{$var}),
b1fafff6 2649 "\n"
abe256e7 2650 if defined $config{$var};
b1fafff6
RL		 2651 }
2652
2653 my @buildfile = ($config{builddir}, $config{build_file});
2654 unshift @buildfile, $here
2655 unless file_name_is_absolute($config{builddir});
2656 my $buildfile = canonpath(catdir(@buildfile));
2657 print <<"_____";
2658
2659NOTE: These variables only represent the configuration view. The build file
2660template may have processed these variables further, please have a look at the
2661build file for more exact data:
2662 $buildfile
2663_____
2664 }
2665 if ($dump || $buildparams) {
2666 my @buildfile = ($config{builddir}, $config{build_file});
2667 unshift @buildfile, $here
2668 unless file_name_is_absolute($config{builddir});
2669 print "\nbuild file:\n\n";
2670 print " ", canonpath(catfile(@buildfile)),"\n";
2671
2672 print "\nbuild file templates:\n\n";
2673 foreach (@{$config{build_file_templates}}) {
2674 my @tmpl = ($_);
2675 unshift @tmpl, $here
2676 unless file_name_is_absolute($config{sourcedir});
2677 print ' ',canonpath(catfile(@tmpl)),"\n";
2678 }
2679 }
2680 if ($reconf) {
2681 if ($verbose) {
2682 print 'Reconfiguring with: ', join(' ',@{$config{perlargv}}), "\n";
84f32c84
DMSP		 2683 foreach (sort keys %{$config{perlenv}}) {
2684 print ' ',$_,' = ',($config{perlenv}->{$_} || ""),"\n";
2685 }
b1fafff6
RL		 2686 }
2687
2688 chdir $here;
2689 exec $^X,catfile($config{sourcedir}, 'Configure'),'reconf';
2690 }
2691}
2692
26931;
2694
2695__END__
2696
2697=head1 NAME
2698
2699configdata.pm - configuration data for OpenSSL builds
2700
2701=head1 SYNOPSIS
2702
2703Interactive:
2704
2705 perl configdata.pm [options]
2706
2707As data bank module:
2708
2709 use configdata;
f2d4be3b 2710
b1fafff6
RL		 2711=head1 DESCRIPTION
2712
2713This module can be used in two modes, interactively and as a module containing
2714all the data recorded by OpenSSL's Configure script.
2715
2716When used interactively, simply run it as any perl script, with at least one
2717option, and you will get the information you ask for. See L</OPTIONS> below.
2718
2719When loaded as a module, you get a few databanks with useful information to
2720perform build related tasks. The databanks are:
2721
2722 %config Configured things.
2723 %target The OpenSSL config target with all inheritances
2724 resolved.
2725 %disabled The features that are disabled.
2726 @disablables The list of features that can be disabled.
2727 %withargs All data given through --with-THING options.
2728 %unified_info All information that was computed from the build.info
2729 files.
2730
2731=head1 OPTIONS
2732
2733=over 4
2734
2735=item B<--help>
2736
2737Print a brief help message and exit.
2738
2739=item B<--man>
2740
2741Print the manual page and exit.
2742
85d6ad34 2743=item B<--dump> | B<-d>
b1fafff6
RL		 2744
2745Print all relevant configuration data. This is equivalent to B<--command-line>
50ea9d2b
RL		 2746B<--options> B<--target> B<--environment> B<--make-variables>
2747B<--build-parameters>.
b1fafff6
RL		 2748
2749=item B<--command-line> | B<-c>
2750
2751Print the current configuration command line.
2752
ca372414
RL		 2753=item B<--options> | B<-o>
2754
2755Print the features, both enabled and disabled, and display defined macro and
2756skipped directories where applicable.
2757
50ea9d2b
RL		 2758=item B<--target> | B<-t>
2759
2760Print the config attributes for this config target.
2761
b1fafff6
RL		 2762=item B<--environment> | B<-e>
2763
2764Print the environment variables and their values at the time of configuration.
2765
2766=item B<--make-variables> | B<-m>
2767
2768Print the main make variables generated in the current configuration
2769
2770=item B<--build-parameters> | B<-b>
2771
2772Print the build parameters, i.e. build file and build file templates.
2773
2774=item B<--reconfigure> | B<--reconf> | B<-r>
2775
2776Redo the configuration.
2777
2778=item B<--verbose> | B<-v>
2779
2780Verbose output.
2781
2782=back
2783
2784=cut
2785
2786EOF
2787close(OUT);
2788if ($builder_platform eq 'unix') {
2789 my $mode = (0755 & ~umask);
2790 chmod $mode, 'configdata.pm'
2791 or warn sprintf("WARNING: Couldn't change mode for 'configdata.pm' to 0%03o: %s\n",$mode,$!);
2792}
cba5068d 2793
88087414 2794my %builders = (
9fe2bb77 2795 unified => sub {
b1fafff6 2796 print 'Creating ',$target{build_file},"\n";
ddf1847d 2797 run_dofile(catfile($blddir, $target{build_file}),
1967a42e 2798 @{$config{build_file_templates}});
9fe2bb77 2799 },
88087414
RL		 2800 );
2801
ddf1847d 2802$builders{$builder}->($builder_platform, @builder_opts);
fce0ba5f 2803
8937a4ed
RL		 2804$SIG{__DIE__} = $orig_death_handler;
2805
9c62a279 2806print <<"EOF" if ($disabled{threads} eq "unavailable");
5f8d5c96
BM		 2807
2808The library could not be configured for supporting multi-threaded
2809applications as the compiler options required on this system are not known.
ff1b7e09 2810See file INSTALL for details if you need multi-threading.
ec577822
BM		 2811EOF
2812
76ffb43d 2813print <<"EOF" if ($no_shared_warn);
2964ba8c 2814
ae48242c
RL		 2815The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
2816platform, so we will pretend you gave the option 'no-pic', which also disables
2817'shared' and 'dynamic-engine'. If you know how to implement shared libraries
2818or position independent code, please let us know (but please first make sure
2819you have tried with a current version of OpenSSL).
2e31ef03
RS		 2820EOF
2821
820e414d
RL		 2822print <<"EOF";
2823
2824**********************************************************************
2825*** ***
41349b5e 2826*** OpenSSL has been successfully configured ***
820e414d 2827*** ***
41349b5e
DMSP		 2828*** If you encounter a problem while building, please open an ***
2829*** issue on GitHub <https://github.com/openssl/openssl/issues> ***
2830*** and include the output from the following command: ***
2831*** ***
2832*** perl configdata.pm --dump ***
2833*** ***
2834*** (If you are new to OpenSSL, you might want to consult the ***
2835*** 'Troubleshooting' section in the INSTALL file first) ***
820e414d
RL		 2836*** ***
2837**********************************************************************
2838EOF
2839
d02b48c6
RE		 2840exit(0);
2841
bd5192b1
RL		 2842######################################################################
2843#
2844# Helpers and utility functions
2845#
2846
8937a4ed
RL		 2847# Death handler, to print a helpful message in case of failure #######
2848#
2849sub death_handler {
eb807d53 2850 die @_ if $^S; # To prevent the added message in eval blocks
8937a4ed 2851 my $build_file = $target{build_file} // "build file";
eb807d53 2852 my @message = ( <<"_____", @_ );
8937a4ed
RL		 2853
2854Failure! $build_file wasn't produced.
2855Please read INSTALL and associated NOTES files. You may also have to look over
2856your available compiler tool chain or change your configuration.
2857
2858_____
eb807d53
RL		 2859
2860 # Dying is terminal, so it's ok to reset the signal handler here.
2861 $SIG{__DIE__} = $orig_death_handler;
2862 die @message;
8937a4ed
RL		 2863}
2864
bd5192b1
RL		 2865# Configuration file reading #########################################
2866
1f2e1cd5
RL		 2867# Note: All of the helper functions are for lazy evaluation. They all
2868# return a CODE ref, which will return the intended value when evaluated.
2869# Thus, whenever there's mention of a returned value, it's about that
2870# intended value.
2871
bd5192b1 2872# Helper function to implement conditional inheritance depending on the
00b0d663 2873# value of $disabled{asm}. Used in inherit_from values as follows:
bd5192b1
RL		 2874#
2875# inherit_from => [ "template", asm("asm_tmpl") ]
2876#
2877sub asm {
2878 my @x = @_;
2879 sub {
84f32c84 2880 $disabled{asm} ? () : @x;
bd5192b1
RL		 2881 }
2882}
2883
1f2e1cd5
RL		 2884# Helper function to implement conditional value variants, with a default
2885# plus additional values based on the value of $config{build_type}.
2886# Arguments are given in hash table form:
2887#
2888# picker(default => "Basic string: ",
2889# debug => "debug",
2890# release => "release")
2891#
2892# When configuring with --debug, the resulting string will be
2893# "Basic string: debug", and when not, it will be "Basic string: release"
2894#
2895# This can be used to create variants of sets of flags according to the
2896# build type:
2897#
2898# cflags => picker(default => "-Wall",
2899# debug => "-g -O0",
2900# release => "-O3")
2901#
2902sub picker {
2903 my %opts = @_;
2904 return sub { add($opts{default} || (),
2905 $opts{$config{build_type}} || ())->(); }
2906}
2907
2908# Helper function to combine several values of different types into one.
2909# This is useful if you want to combine a string with the result of a
2910# lazy function, such as:
2911#
2912# cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
2913#
2914sub combine {
2915 my @stuff = @_;
2916 return sub { add(@stuff)->(); }
2917}
2918
2919# Helper function to implement conditional values depending on the value
2920# of $disabled{threads}. Can be used as follows:
2921#
2922# cflags => combine("-Wall", threads("-pthread"))
2923#
2924sub threads {
2925 my @flags = @_;
2926 return sub { add($disabled{threads} ? () : @flags)->(); }
2927}
2928
60aa6c1a
AP		 2929sub shared {
2930 my @flags = @_;
2931 return sub { add($disabled{shared} ? () : @flags)->(); }
2932}
1f2e1cd5 2933
9c62a279 2934our $add_called = 0;
88087414
RL		 2935# Helper function to implement adding values to already existing configuration
2936# values. It handles elements that are ARRAYs, CODEs and scalars
2937sub _add {
2938 my $separator = shift;
2939
bcb1977b
RL		 2940 # If there's any ARRAY in the collection of values OR the separator
2941 # is undef, we will return an ARRAY of combined values, otherwise a
2942 # string of joined values with $separator as the separator.
2943 my $found_array = !defined($separator);
88087414
RL		 2944
2945 my @values =
84f32c84
DMSP		 2946 map {
2947 my $res = $_;
2948 while (ref($res) eq "CODE") {
2949 $res = $res->();
2950 }
2951 if (defined($res)) {
2952 if (ref($res) eq "ARRAY") {
2953 $found_array = 1;
2954 @$res;
2955 } else {
2956 $res;
2957 }
2958 } else {
2959 ();
2960 }
88087414
RL		 2961 } (@_);
2962
9c62a279
RL		 2963 $add_called = 1;
2964
88087414 2965 if ($found_array) {
84f32c84 2966 [ @values ];
88087414 2967 } else {
84f32c84 2968 join($separator, grep { defined($_) && $_ ne "" } @values);
88087414
RL		 2969 }
2970}
2971sub add_before {
bdcd83e1
RL		 2972 my $separator = " ";
2973 if (ref($_[$#_]) eq "HASH") {
2974 my $opts = pop;
2975 $separator = $opts->{separator};
2976 }
88087414
RL		 2977 my @x = @_;
2978 sub { _add($separator, @x, @_) };
2979}
2980sub add {
bdcd83e1
RL		 2981 my $separator = " ";
2982 if (ref($_[$#_]) eq "HASH") {
2983 my $opts = pop;
2984 $separator = $opts->{separator};
2985 }
88087414
RL		 2986 my @x = @_;
2987 sub { _add($separator, @_, @x) };
2988}
2989
3b6c4b07
RL		 2990sub read_eval_file {
2991 my $fname = shift;
2992 my $content;
2993 my @result;
2994
2995 open F, "< $fname" or die "Can't open '$fname': $!\n";
2996 {
2997 undef local $/;
2998 $content = <F>;
2999 }
3000 close F;
3001 {
3002 local $@;
3003
3004 @result = ( eval $content );
3005 warn $@ if $@;
3006 }
3007 return wantarray ? @result : $result[0];
3008}
3009
bd5192b1
RL		 3010# configuration reader, evaluates the input file as a perl script and expects
3011# it to fill %targets with target configurations. Those are then added to
3012# %table.
3013sub read_config {
3014 my $fname = shift;
3b6c4b07
RL		 3015 my %targets;
3016
bd5192b1 3017 {
84f32c84
DMSP		 3018 # Protect certain tables from tampering
3019 local %table = ();
bd5192b1 3020
84f32c84 3021 %targets = read_eval_file($fname);
bd5192b1 3022 }
225f980d
RL		 3023 my %preexisting = ();
3024 foreach (sort keys %targets) {
3025 $preexisting{$_} = 1 if $table{$_};
3026 }
3027 die <<"EOF",
3028The following config targets from $fname
3029shadow pre-existing config targets with the same name:
3030EOF
3031 map { " $_\n" } sort keys %preexisting
3032 if %preexisting;
3033
bd5192b1
RL		 3034
3035 # For each target, check that it's configured with a hash table.
3036 foreach (keys %targets) {
84f32c84
DMSP		 3037 if (ref($targets{$_}) ne "HASH") {
3038 if (ref($targets{$_}) eq "") {
3039 warn "Deprecated target configuration for $_, ignoring...\n";
3040 } else {
3041 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
3042 }
3043 delete $targets{$_};
3044 } else {
ee9b0bbb
RL		 3045 $targets{$_}->{_conf_fname_int} = add([ $fname ]);
3046 }
bd5192b1
RL		 3047 }
3048
3049 %table = (%table, %targets);
3050
3051}
3052
8483a003
F		 3053# configuration resolver. Will only resolve all the lazy evaluation
3054# codeblocks for the chosen target and all those it inherits from,
bd5192b1
RL		 3055# recursively
3056sub resolve_config {
3057 my $target = shift;
3058 my @breadcrumbs = @_;
3059
c4718849 3060# my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
9c62a279 3061
bd5192b1 3062 if (grep { $_ eq $target } @breadcrumbs) {
84f32c84
DMSP		 3063 die "inherit_from loop! target backtrace:\n "
3064 ,$target,"\n ",join("\n ", @breadcrumbs),"\n";
bd5192b1
RL		 3065 }
3066
3067 if (!defined($table{$target})) {
84f32c84
DMSP		 3068 warn "Warning! target $target doesn't exist!\n";
3069 return ();
bd5192b1
RL		 3070 }
3071 # Recurse through all inheritances. They will be resolved on the
3072 # fly, so when this operation is done, they will all just be a
3073 # bunch of attributes with string values.
3074 # What we get here, though, are keys with references to lists of
3075 # the combined values of them all. We will deal with lists after
3076 # this stage is done.
3077 my %combined_inheritance = ();
3078 if ($table{$target}->{inherit_from}) {
84f32c84
DMSP		 3079 my @inherit_from =
3080 map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
3081 foreach (@inherit_from) {
3082 my %inherited_config = resolve_config($_, $target, @breadcrumbs);
3083
3084 # 'template' is a marker that's considered private to
3085 # the config that had it.
3086 delete $inherited_config{template};
3087
3088 foreach (keys %inherited_config) {
3089 if (!$combined_inheritance{$_}) {
3090 $combined_inheritance{$_} = [];
3091 }
3092 push @{$combined_inheritance{$_}}, $inherited_config{$_};
3093 }
3094 }
bd5192b1
RL		 3095 }
3096
3097 # We won't need inherit_from in this target any more, since we've
3098 # resolved all the inheritances that lead to this
3099 delete $table{$target}->{inherit_from};
3100
3101 # Now is the time to deal with those lists. Here's the place to
3102 # decide what shall be done with those lists, all based on the
3103 # values of the target we're currently dealing with.
3104 # - If a value is a coderef, it will be executed with the list of
3105 # inherited values as arguments.
3106 # - If the corresponding key doesn't have a value at all or is the
8483a003 3107 # empty string, the inherited value list will be run through the
bd5192b1
RL		 3108 # default combiner (below), and the result becomes this target's
3109 # value.
3110 # - Otherwise, this target's value is assumed to be a string that
3111 # will simply override the inherited list of values.
a26d8be9 3112 my $default_combiner = add();
bd5192b1
RL		 3113
3114 my %all_keys =
84f32c84
DMSP		 3115 map { $_ => 1 } (keys %combined_inheritance,
3116 keys %{$table{$target}});
b0b92a5b
RL		 3117
3118 sub process_values {
84f32c84
DMSP		 3119 my $object = shift;
3120 my $inherited = shift; # Always a [ list ]
3121 my $target = shift;
3122 my $entry = shift;
b0b92a5b 3123
9c62a279
RL		 3124 $add_called = 0;
3125
b0b92a5b
RL		 3126 while(ref($object) eq "CODE") {
3127 $object = $object->(@$inherited);
3128 }
3129 if (!defined($object)) {
3130 return ();
3131 }
3132 elsif (ref($object) eq "ARRAY") {
9c62a279 3133 local $add_called; # To make sure recursive calls don't affect it
b0b92a5b
RL		 3134 return [ map { process_values($_, $inherited, $target, $entry) }
3135 @$object ];
3136 } elsif (ref($object) eq "") {
3137 return $object;
3138 } else {
3139 die "cannot handle reference type ",ref($object)
3140 ," found in target ",$target," -> ",$entry,"\n";
3141 }
3142 }
3143
bd5192b1 3144 foreach (sort keys %all_keys) {
9c62a279 3145 my $previous = $combined_inheritance{$_};
bd5192b1 3146
84f32c84
DMSP		 3147 # Current target doesn't have a value for the current key?
3148 # Assign it the default combiner, the rest of this loop body
3149 # will handle it just like any other coderef.
3150 if (!exists $table{$target}->{$_}) {
3151 $table{$target}->{$_} = $default_combiner;
3152 }
bd5192b1 3153
84f32c84
DMSP		 3154 $table{$target}->{$_} = process_values($table{$target}->{$_},
3155 $combined_inheritance{$_},
3156 $target, $_);
b0b92a5b
RL		 3157 unless(defined($table{$target}->{$_})) {
3158 delete $table{$target}->{$_};
3159 }
c4718849
RL		 3160# if ($extra_checks &&
3161# $previous && !($add_called || $previous ~~ $table{$target}->{$_})) {
3162# warn "$_ got replaced in $target\n";
3163# }
bd5192b1
RL		 3164 }
3165
3166 # Finally done, return the result.
3167 return %{$table{$target}};
3168}
3169
462ba4f6 3170sub usage
84f32c84
DMSP		 3171 {
3172 print STDERR $usage;
3173 print STDERR "\npick os/compiler from:\n";
3174 my $j=0;
3175 my $i;
10a926c1 3176 my $k=0;
84f32c84
DMSP		 3177 foreach $i (sort keys %table)
3178 {
3179 next if $table{$i}->{template};
3180 next if $i =~ /^debug/;
3181 $k += length($i) + 1;
3182 if ($k > 78)
3183 {
3184 print STDERR "\n";
3185 $k=length($i);
3186 }
3187 print STDERR $i . " ";
3188 }
3189 foreach $i (sort keys %table)
3190 {
3191 next if $table{$i}->{template};
3192 next if $i !~ /^debug/;
3193 $k += length($i) + 1;
3194 if ($k > 78)
3195 {
3196 print STDERR "\n";
3197 $k=length($i);
3198 }
3199 print STDERR $i . " ";
3200 }
3201 print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
3202 exit(1);
3203 }
d02b48c6 3204
01d99976 3205sub run_dofile
107b5792 3206{
107b5792 3207 my $out = shift;
9fe2bb77 3208 my @templates = @_;
107b5792 3209
ced2c2c5
RS		 3210 unlink $out || warn "Can't remove $out, $!"
3211 if -f $out;
9fe2bb77
RL		 3212 foreach (@templates) {
3213 die "Can't open $_, $!" unless -f $_;
3214 }
9e265322 3215 my $perlcmd = (quotify("maybeshell", $config{PERL}))[0];
f879d5ff 3216 my $cmd = "$perlcmd \"-I.\" \"-Mconfigdata\" \"$dofile\" -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\"";
9fe2bb77
RL		 3217 #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
3218 system($cmd);
107b5792
RL		 3219 exit 1 if $? != 0;
3220 rename("$out.new", $out) || die "Can't rename $out.new, $!";
3221}
3222
6d75a83c
RL		 3223sub compiler_predefined {
3224 state %predefined;
41d6e0f3 3225 my $cc = shift;
6d75a83c
RL		 3226
3227 return () if $^O eq 'VMS';
3228
41d6e0f3
AP		 3229 die 'compiler_predefined called without a compiler command'
3230 unless $cc;
6d75a83c 3231
41d6e0f3 3232 if (! $predefined{$cc}) {
6d75a83c 3233
41d6e0f3 3234 $predefined{$cc} = {};
6d75a83c
RL		 3235
3236 # collect compiler pre-defines from gcc or gcc-alike...
3237 open(PIPE, "$cc -dM -E -x c /dev/null 2>&1 |");
3238 while (my $l = <PIPE>) {
3239 $l =~ m/^#define\s+(\w+(?:\(\w+\))?)(?:\s+(.+))?/ or last;
41d6e0f3 3240 $predefined{$cc}->{$1} = $2 // '';
6d75a83c
RL		 3241 }
3242 close(PIPE);
3243 }
3244
41d6e0f3 3245 return %{$predefined{$cc}};
6d75a83c
RL		 3246}
3247
656bbdc6
AP		 3248sub which
3249{
3250 my ($name)=@_;
3251
3252 if (eval { require IPC::Cmd; 1; }) {
3253 IPC::Cmd->import();
3254 return scalar IPC::Cmd::can_run($name);
3255 } else {
3256 # if there is $directories component in splitpath,
3257 # then it's not something to test with $PATH...
3258 return $name if (File::Spec->splitpath($name))[1];
3259
3260 foreach (File::Spec->path()) {
3261 my $fullpath = catfile($_, "$name$target{exe_extension}");
3262 if (-f $fullpath and -x $fullpath) {
3263 return $fullpath;
3264 }
3265 }
3266 }
3267}
3268
7ecdf18d
RL		 3269sub env
3270{
3271 my $name = shift;
ac6ae8a9 3272 my %opts = @_;
7ecdf18d 3273
ac6ae8a9
RL		 3274 unless ($opts{cacheonly}) {
3275 # Note that if $ENV{$name} doesn't exist or is undefined,
3276 # $config{perlenv}->{$name} will be created with the value
3277 # undef. This is intentional.
89bea083 3278
ac6ae8a9
RL		 3279 $config{perlenv}->{$name} = $ENV{$name}
3280 if ! exists $config{perlenv}->{$name};
3281 }
7ecdf18d
RL		 3282 return $config{perlenv}->{$name};
3283}
3284
00ae96ca
RL		 3285# Configuration printer ##############################################
3286
3287sub print_table_entry
3288{
f770d75b
AP		 3289 local $now_printing = shift;
3290 my %target = resolve_config($now_printing);
00ae96ca
RL		 3291 my $type = shift;
3292
3293 # Don't print the templates
3294 return if $target{template};
3295
3296 my @sequence = (
84f32c84
DMSP		 3297 "sys_id",
3298 "cpp",
3299 "cppflags",
3300 "defines",
3301 "includes",
3302 "cc",
3303 "cflags",
3304 "unistd",
3305 "ld",
3306 "lflags",
3307 "loutflag",
3308 "ex_libs",
3309 "bn_ops",
3310 "apps_aux_src",
3311 "cpuid_asm_src",
3312 "uplink_aux_src",
3313 "bn_asm_src",
3314 "ec_asm_src",
3315 "des_asm_src",
3316 "aes_asm_src",
3317 "bf_asm_src",
3318 "md5_asm_src",
3319 "cast_asm_src",
3320 "sha1_asm_src",
3321 "rc4_asm_src",
3322 "rmd160_asm_src",
3323 "rc5_asm_src",
3324 "wp_asm_src",
3325 "cmll_asm_src",
3326 "modes_asm_src",
3327 "padlock_asm_src",
3328 "chacha_asm_src",
3329 "poly1035_asm_src",
3330 "thread_scheme",
3331 "perlasm_scheme",
3332 "dso_scheme",
3333 "shared_target",
3334 "shared_cflag",
3335 "shared_defines",
3336 "shared_ldflag",
3337 "shared_rcflag",
3338 "shared_extension",
3339 "dso_extension",
3340 "obj_extension",
3341 "exe_extension",
3342 "ranlib",
3343 "ar",
3344 "arflags",
3345 "aroutflag",
3346 "rc",
3347 "rcflags",
3348 "rcoutflag",
3349 "mt",
3350 "mtflags",
3351 "mtinflag",
3352 "mtoutflag",
3353 "multilib",
3354 "build_scheme",
3355 );
00ae96ca
RL		 3356
3357 if ($type eq "TABLE") {
84f32c84
DMSP		 3358 print "\n";
3359 print "*** $now_printing\n";
cb212f23
RL		 3360 foreach (@sequence) {
3361 if (ref($target{$_}) eq "ARRAY") {
3362 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
3363 } else {
3364 printf "\$%-12s = %s\n", $_, $target{$_};
3365 }
3366 }
00ae96ca 3367 } elsif ($type eq "HASH") {
84f32c84
DMSP		 3368 my $largest =
3369 length((sort { length($a) <=> length($b) } @sequence)[-1]);
3370 print " '$now_printing' => {\n";
3371 foreach (@sequence) {
3372 if ($target{$_}) {
cb212f23
RL		 3373 if (ref($target{$_}) eq "ARRAY") {
3374 print " '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
3375 } else {
3376 print " '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
3377 }
84f32c84
DMSP		 3378 }
3379 }
3380 print " },\n";
00ae96ca
RL		 3381 }
3382}
3383
3384# Utility routines ###################################################
3385
2e963849
RL		 3386# On VMS, if the given file is a logical name, File::Spec::Functions
3387# will consider it an absolute path. There are cases when we want a
3388# purely syntactic check without checking the environment.
3389sub isabsolute {
3390 my $file = shift;
3391
3392 # On non-platforms, we just use file_name_is_absolute().
3393 return file_name_is_absolute($file) unless $^O eq "VMS";
3394
69687aa8 3395 # If the file spec includes a device or a directory spec,
2e963849
RL		 3396 # file_name_is_absolute() is perfectly safe.
3397 return file_name_is_absolute($file) if $file =~ m|[:\[]|;
3398
3399 # Here, we know the given file spec isn't absolute
3400 return 0;
3401}
3402
ec182ef0
RL		 3403# Makes a directory absolute and cleans out /../ in paths like foo/../bar
3404# On some platforms, this uses rel2abs(), while on others, realpath() is used.
3405# realpath() requires that at least all path components except the last is an
3406# existing directory. On VMS, the last component of the directory spec must
3407# exist.
3408sub absolutedir {
3409 my $dir = shift;
3410
3411 # realpath() is quite buggy on VMS. It uses LIB$FID_TO_NAME, which
3412 # will return the volume name for the device, no matter what. Also,
3413 # it will return an incorrect directory spec if the argument is a
3414 # directory that doesn't exist.
3415 if ($^O eq "VMS") {
3416 return rel2abs($dir);
3417 }
3418
3419 # We use realpath() on Unix, since no other will properly clean out
3420 # a directory spec.
3421 use Cwd qw/realpath/;
3422
3423 return realpath($dir);
3424}
3425
fe05264e
RL		 3426sub quotify {
3427 my %processors = (
84f32c84
DMSP		 3428 perl => sub { my $x = shift;
3429 $x =~ s/([\\\$\@"])/\\$1/g;
3430 return '"'.$x.'"'; },
3431 maybeshell => sub { my $x = shift;
3432 (my $y = $x) =~ s/([\\\"])/\\$1/g;
3433 if ($x ne $y || $x =~ m|\s|) {
3434 return '"'.$y.'"';
3435 } else {
3436 return $x;
3437 }
3438 },
3439 );
fe05264e
RL		 3440 my $for = shift;
3441 my $processor =
84f32c84 3442 defined($processors{$for}) ? $processors{$for} : sub { shift; };
fe05264e 3443
2110febb 3444 return map { $processor->($_); } @_;
fe05264e 3445}
107b5792 3446
9fe2bb77
RL		 3447# collect_from_file($filename, $line_concat_cond_re, $line_concat)
3448# $filename is a file name to read from
3449# $line_concat_cond_re is a regexp detecting a line continuation ending
3450# $line_concat is a CODEref that takes care of concatenating two lines
3451sub collect_from_file {
3452 my $filename = shift;
3453 my $line_concat_cond_re = shift;
3454 my $line_concat = shift;
3455
3456 open my $fh, $filename || die "unable to read $filename: $!\n";
3457 return sub {
3458 my $saved_line = "";
3459 $_ = "";
3460 while (<$fh>) {
04f171c0 3461 s|\R$||;
9fe2bb77
RL		 3462 if (defined $line_concat) {
3463 $_ = $line_concat->($saved_line, $_);
3464 $saved_line = "";
3465 }
3466 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
3467 $saved_line = $_;
3468 next;
3469 }
3470 return $_;
3471 }
3472 die "$filename ending with continuation line\n" if $_;
3473 close $fh;
3474 return undef;
3475 }
3476}
3477
3478# collect_from_array($array, $line_concat_cond_re, $line_concat)
3479# $array is an ARRAYref of lines
3480# $line_concat_cond_re is a regexp detecting a line continuation ending
3481# $line_concat is a CODEref that takes care of concatenating two lines
3482sub collect_from_array {
3483 my $array = shift;
3484 my $line_concat_cond_re = shift;
3485 my $line_concat = shift;
3486 my @array = (@$array);
3487
3488 return sub {
3489 my $saved_line = "";
3490 $_ = "";
3491 while (defined($_ = shift @array)) {
04f171c0 3492 s|\R$||;
9fe2bb77
RL		 3493 if (defined $line_concat) {
3494 $_ = $line_concat->($saved_line, $_);
3495 $saved_line = "";
3496 }
3497 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
3498 $saved_line = $_;
3499 next;
3500 }
3501 return $_;
3502 }
3503 die "input text ending with continuation line\n" if $_;
3504 return undef;
3505 }
3506}
3507
3508# collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
3509# $lineiterator is a CODEref that delivers one line at a time.
107b5792
RL		 3510# All following arguments are regex/CODEref pairs, where the regexp detects a
3511# line and the CODEref does something with the result of the regexp.
3512sub collect_information {
9fe2bb77 3513 my $lineiterator = shift;
107b5792
RL		 3514 my %collectors = @_;
3515
9fe2bb77 3516 while(defined($_ = $lineiterator->())) {
04f171c0 3517 s|\R$||;
9fe2bb77 3518 my $found = 0;
2b6b606c
RL		 3519 if ($collectors{"BEFORE"}) {
3520 $collectors{"BEFORE"}->($_);
3521 }
9fe2bb77 3522 foreach my $re (keys %collectors) {
2b6b606c 3523 if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
9fe2bb77
RL		 3524 $collectors{$re}->($lineiterator);
3525 $found = 1;
3526 };
3527 }
3528 if ($collectors{"OTHERWISE"}) {
3529 $collectors{"OTHERWISE"}->($lineiterator, $_)
3530 unless $found || !defined $collectors{"OTHERWISE"};
3531 }
2b6b606c
RL		 3532 if ($collectors{"AFTER"}) {
3533 $collectors{"AFTER"}->($_);
3534 }
107b5792 3535 }
107b5792 3536}
ce959812
RL		 3537
3538# tokenize($line)
5d3af259 3539# tokenize($line,$separator)
ce959812 3540# $line is a line of text to split up into tokens
5d3af259
RL		 3541# $separator [optional] is a regular expression that separates the tokens,
3542# the default being spaces. Do not use quotes of any kind as separators,
3543# that will give undefined results.
3544# Returns a list of tokens.
ce959812 3545#
5d3af259
RL		 3546# Tokens are divided by separator (spaces by default). If the tokens include
3547# the separators, they have to be quoted with single or double quotes.
3548# Double quotes inside a double quoted token must be escaped. Escaping is done
ce959812
RL		 3549# with backslash.
3550# Basically, the same quoting rules apply for " and ' as in any
3551# Unix shell.
3552sub tokenize {
3553 my $line = my $debug_line = shift;
5d3af259 3554 my $separator = shift // qr|\s+|;
ce959812
RL		 3555 my @result = ();
3556
5d3af259
RL		 3557 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
3558 print STDERR "DEBUG[tokenize]: \$separator = $separator\n";
3559 }
3560
3561 while ($line =~ s|^${separator}||, $line ne "") {
ce959812 3562 my $token = "";
5d3af259
RL		 3563 again:
3564 $line =~ m/^(.*?)(${separator}|"|'|$)/;
3565 $token .= $1;
3566 $line = $2.$';
3567
3568 if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
3569 $token .= $1;
3570 $line = $';
3571 goto again;
3572 } elsif ($line =~ m/^'([^']*)'/) {
3573 $token .= $1;
3574 $line = $';
3575 goto again;
ce959812
RL		 3576 }
3577 push @result, $token;
3578 }
3579
3580 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
5d3af259
RL		 3581 print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
3582 print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";
ce959812
RL		 3583 }
3584 return @result;
3585}
A mirror of the official openssl repository