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