]> git.ipfire.org Git - thirdparty/openssl.git/blame - Configure
projects / thirdparty / openssl.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
fix 'set but not used' warning
[thirdparty/openssl.git] / Configure
CommitLineData
de17db91 1#! /usr/bin/env perl
f4d8f037 2# -*- mode: perl; -*-
ac3d0e13
RS		 3# Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
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
9f519add 12require 5.10.0;
1641cb60 13use strict;
f09e7ca9 14use File::Basename;
85152ca4 15use File::Spec::Functions qw/:DEFAULT abs2rel rel2abs/;
dca99383 16use File::Path qw/mkpath/;
23049aa5 17use if $^O ne "VMS", 'File::Glob' => qw/glob/;
1641cb60 18
22a4f969 19# see INSTALL for instructions.
462ba4f6 20
e4ef2e25 21my $usage="Usage: Configure [no-<cipher> ...] [enable-<cipher> ...] [-Dxxx] [-lxxx] [-Lxxx] [-fxxx] [-Kxxx] [no-hw-xxx|no-hw] [[no-]threads] [[no-]shared] [[no-]zlib|zlib-dynamic] [no-asm] [no-dso] [no-egd] [sctp] [386] [--prefix=DIR] [--openssldir=OPENSSLDIR] [--with-xxx[=vvv]] [--config=FILE] os/compiler[:flags]\n";
462ba4f6 22
434c5dd3 23# Options:
e5f3045f 24#
f09e7ca9
RS		 25# --config add the given configuration file, which will be read after
26# any "Configurations*" files that are found in the same
27# directory as this script.
d74dfafd
RL		 28# --prefix prefix for the OpenSSL installation, which includes the
29# directories bin, lib, include, share/man, share/doc/openssl
30# This becomes the value of INSTALLTOP in Makefile
31# (Default: /usr/local)
32# --openssldir OpenSSL data area, such as openssl.cnf, certificates and keys.
33# If it's a relative directory, it will be added on the directory
34# given with --prefix.
35# This becomes the value of OPENSSLDIR in Makefile and in C.
36# (Default: PREFIX/ssl)
e5f3045f 37#
cbfb39d1
AP		 38# --cross-compile-prefix Add specified prefix to binutils components.
39#
98186eb4
VD		 40# --api One of 0.9.8, 1.0.0 or 1.1.0. Do not compile support for
41# interfaces deprecated as of the specified OpenSSL version.
42#
5270e702
RL		 43# no-hw-xxx do not compile support for specific crypto hardware.
44# Generic OpenSSL-style methods relating to this support
45# are always compiled but return NULL if the hardware
46# support isn't compiled.
47# no-hw do not compile support for any crypto hardware.
5f8d5c96
BM		 48# [no-]threads [don't] try to create a library that is suitable for
49# multithreaded applications (default is "threads" if we
50# know how to do it)
fcc6a1c4 51# [no-]shared [don't] try to create shared libraries when supported.
ae48242c 52# [no-]pic [don't] try to build position independent code when supported.
45b71abe 53# If disabled, it also disables shared and dynamic-engine.
a723979d 54# no-asm do not use assembler
bc2aadad
GT		 55# no-dso do not compile in any native shared-library methods. This
56# will ensure that all methods just return NULL.
0423f812 57# no-egd do not compile support for the entropy-gathering daemon APIs
e452de9d
RL		 58# [no-]zlib [don't] compile support for zlib compression.
59# zlib-dynamic Like "zlib", but the zlib library is expected to be a shared
60# library and will be loaded in run-time by the OpenSSL library.
7e159e01 61# sctp include SCTP support
22a4f969 62# 386 generate 80386 code
8b1a5af3
MC		 63# enable-weak-ssl-ciphers
64# Enable weak ciphers that are disabled by default. This currently
65# only includes RC4 based ciphers.
d0590fe6 66# no-sse2 disables IA-32 SSE2 code, above option implies no-sse2
79df9d62 67# no-<cipher> build without specified algorithm (rsa, idea, rc5, ...)
fce0ba5f 68# -<xxx> +<xxx> compiler options are passed through
e41c8d6a
GT		 69#
70# DEBUG_SAFESTACK use type-safe stacks to enforce type-safety on stack items
71# provided to stack calls. Generates unique stack functions for
72# each possible stack type.
d02b48c6 73# BN_LLONG use the type 'long long' in crypto/bn/bn.h
d02b48c6 74# RC4_CHAR use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
d0590fe6
AP		 75# Following are set automatically by this script
76#
8483a003
F		 77# MD5_ASM use some extra md5 assembler,
78# SHA1_ASM use some extra sha1 assembler, must define L_ENDIAN for x86
79# RMD160_ASM use some extra ripemd160 assembler,
d0590fe6
AP		 80# SHA256_ASM sha256_block is implemented in assembler
81# SHA512_ASM sha512_block is implemented in assembler
28bd8e94 82# AES_ASM AES_[en|de]crypt is implemented in assembler
d02b48c6 83
363bd0b4 84# Minimum warning options... any contributions to OpenSSL should at least get
fce0ba5f 85# past these.
363bd0b4 86
463a7b8c
AP		 87# DEBUG_UNUSED enables __owur (warn unused result) checks.
88my $gcc_devteam_warn = "-DDEBUG_UNUSED"
89 # -DPEDANTIC complements -pedantic and is meant to mask code that
f430ba31 90 # is not strictly standard-compliant and/or implementation-specific,
463a7b8c
AP		 91 # e.g. inline assembly, disregards to alignment requirements, such
92 # that -pedantic would complain about. Incidentally -DPEDANTIC has
93 # to be used even in sanitized builds, because sanitizer too is
94 # supposed to and does take notice of non-standard behaviour. Then
95 # -pedantic with pre-C9x compiler would also complain about 'long
96 # long' not being supported. As 64-bit algorithms are common now,
97 # it grew impossible to resolve this without sizeable additional
98 # code, so we just tell compiler to be pedantic about everything
99 # but 'long long' type.
100 . " -DPEDANTIC -pedantic -Wno-long-long"
8bccbce5 101 . " -Wall"
8bccbce5
RS		 102 . " -Wsign-compare"
103 . " -Wmissing-prototypes"
104 . " -Wshadow"
105 . " -Wformat"
106 . " -Wtype-limits"
107 . " -Werror"
108 ;
363bd0b4 109
190c8c60
BL		 110# These are used in addition to $gcc_devteam_warn when the compiler is clang.
111# TODO(openssl-team): fix problems and investigate if (at least) the
480405e4 112# following warnings can also be enabled:
8bccbce5 113# -Wswitch-enum
8bccbce5
RS		 114# -Wcast-align
115# -Wunreachable-code
a773b52a
RS		 116# -Wlanguage-extension-token -- no, we use asm()
117# -Wunused-macros -- no, too tricky for BN and _XOPEN_SOURCE etc
118# -Wextended-offsetof -- no, needed in CMS ASN1 code
8bccbce5
RS		 119my $clang_devteam_warn = ""
120 . " -Qunused-arguments"
121 . " -Wextra"
122 . " -Wno-unused-parameter"
123 . " -Wno-missing-field-initializers"
124 . " -Wno-language-extension-token"
125 . " -Wno-extended-offsetof"
126 . " -Wconditional-uninitialized"
127 . " -Wincompatible-pointer-types-discards-qualifiers"
128 . " -Wmissing-variable-declarations"
129 ;
cb2bc054 130
ef8ca6bd
RL		 131# This adds backtrace information to the memory leak info. Is only used
132# when crypto-mdebug-backtrace is enabled.
133my $memleak_devteam_backtrace = "-rdynamic";
a1d3f3d1 134
0c28f277
DSH		 135my $strict_warnings = 0;
136
b7efa56a 137# As for $BSDthreads. Idea is to maintain "collective" set of flags,
fce0ba5f 138# which would cover all BSD flavors. -pthread applies to them all,
b7efa56a
AP		 139# but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
140# -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
141# which has to be accompanied by explicit -D_THREAD_SAFE and
142# sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
143# seems to be sufficient?
9c62a279 144our $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
d02b48c6 145
98186eb4 146#
f430ba31 147# API compatibility name to version number mapping.
98186eb4
VD		 148#
149my $maxapi = "1.1.0"; # API for "no-deprecated" builds
150my $apitable = {
151 "1.1.0" => "0x10100000L",
152 "1.0.0" => "0x10000000L",
153 "0.9.8" => "0x00908000L",
154};
155
9e0724a1 156our %table = ();
291e94df 157our %config = ();
98fdbce0 158our %withargs = ();
3e83e686 159
bd5192b1 160# Forward declarations ###############################################
7ead0c89 161
bd5192b1
RL		 162# read_config(filename)
163#
164# Reads a configuration file and populates %table with the contents
165# (which the configuration file places in %targets).
166sub read_config;
7d46b942 167
bd5192b1
RL		 168# resolve_config(target)
169#
8483a003 170# Resolves all the late evaluations, inheritances and so on for the
bd5192b1
RL		 171# chosen target and any target it inherits from.
172sub resolve_config;
7d46b942 173
15c7adb0 174
107b5792
RL		 175# Information collection #############################################
176
9fe2bb77 177# Unified build supports separate build dir
ec182ef0
RL		 178my $srcdir = catdir(absolutedir(dirname($0))); # catdir ensures local syntax
179my $blddir = catdir(absolutedir(".")); # catdir ensures local syntax
9fe2bb77
RL		 180my $dofile = abs2rel(catfile($srcdir, "util/dofile.pl"));
181
b5293d4c
RL		 182my $local_config_envname = 'OPENSSL_LOCAL_CONFIG_DIR';
183
9fe2bb77
RL		 184$config{sourcedir} = abs2rel($srcdir);
185$config{builddir} = abs2rel($blddir);
186
107b5792
RL		 187# Collect version numbers
188$config{version} = "unknown";
189$config{version_num} = "unknown";
190$config{shlib_version_number} = "unknown";
191$config{shlib_version_history} = "unknown";
192
193collect_information(
9fe2bb77 194 collect_from_file(catfile($srcdir,'include/openssl/opensslv.h')),
107b5792
RL		 195 qr/OPENSSL.VERSION.TEXT.*OpenSSL (\S+) / => sub { $config{version} = $1; },
196 qr/OPENSSL.VERSION.NUMBER.*(0x\S+)/ => sub { $config{version_num}=$1 },
197 qr/SHLIB_VERSION_NUMBER *"([^"]+)"/ => sub { $config{shlib_version_number}=$1 },
198 qr/SHLIB_VERSION_HISTORY *"([^"]*)"/ => sub { $config{shlib_version_history}=$1 }
199 );
200if ($config{shlib_version_history} ne "") { $config{shlib_version_history} .= ":"; }
201
202($config{major}, $config{minor})
203 = ($config{version} =~ /^([0-9]+)\.([0-9\.]+)/);
204($config{shlib_major}, $config{shlib_minor})
205 = ($config{shlib_version_number} =~ /^([0-9]+)\.([0-9\.]+)/);
206die "erroneous version information in opensslv.h: ",
207 "$config{major}, $config{minor}, $config{shlib_major}, $config{shlib_minor}\n"
208 if ($config{major} eq "" || $config{minor} eq ""
209 || $config{shlib_major} eq "" || $config{shlib_minor} eq "");
210
211# Collect target configurations
212
85152ca4 213my $pattern = catfile(dirname($0), "Configurations", "*.conf");
97855556 214foreach (sort glob($pattern)) {
f09e7ca9
RS		 215 &read_config($_);
216}
d02b48c6 217
b5293d4c
RL		 218if (defined $ENV{$local_config_envname}) {
219 if ($^O eq 'VMS') {
220 # VMS environment variables are logical names,
221 # which can be used as is
222 $pattern = $local_config_envname . ':' . '*.conf';
223 } else {
224 $pattern = catfile($ENV{$local_config_envname}, '*.conf');
225 }
226
97855556 227 foreach (sort glob($pattern)) {
b5293d4c
RL		 228 &read_config($_);
229 }
230}
231
291e94df 232
107b5792
RL		 233print "Configuring OpenSSL version $config{version} (0x$config{version_num})\n";
234
291e94df
RL		 235$config{prefix}="";
236$config{openssldir}="";
7d130f68 237$config{processor}="";
107b5792 238$config{libdir}="";
642a6138 239$config{cross_compile_prefix}="";
107b5792 240$config{fipslibdir}="/usr/local/ssl/fips-2.0/lib/";
1ab2f7f1 241my $nofipscanistercheck=0;
107b5792 242$config{baseaddr}="0xFB00000";
9c62a279 243my $auto_threads=1; # enable threads automatically? true by default
0396479d 244my $default_ranlib;
107b5792
RL		 245$config{fips}=0;
246
247# Top level directories to build
90d28f05 248$config{dirs} = [ "crypto", "ssl", "engines", "apps", "test", "tools", "fuzz" ];
107b5792
RL		 249# crypto/ subdirectories to build
250$config{sdirs} = [
251 "objects",
2d0b4412 252 "md2", "md4", "md5", "sha", "mdc2", "hmac", "ripemd", "whrlpool", "poly1305", "blake2",
107b5792
RL		 253 "des", "aes", "rc2", "rc4", "rc5", "idea", "bf", "cast", "camellia", "seed", "chacha", "modes",
254 "bn", "ec", "rsa", "dsa", "dh", "dso", "engine",
255 "buffer", "bio", "stack", "lhash", "rand", "err",
256 "evp", "asn1", "pem", "x509", "x509v3", "conf", "txt_db", "pkcs7", "pkcs12", "comp", "ocsp", "ui",
dba31777 257 "cms", "ts", "srp", "cmac", "ct", "async", "kdf"
107b5792 258 ];
99aab161 259
6b01bed2
VD		 260# Known TLS and DTLS protocols
261my @tls = qw(ssl3 tls1 tls1_1 tls1_2);
262my @dtls = qw(dtls1 dtls1_2);
263
8483a003 264# Explicitly known options that are possible to disable. They can
8b527be2
RL		 265# be regexps, and will be used like this: /^no-${option}$/
266# For developers: keep it sorted alphabetically
267
268my @disablables = (
c91a0a83 269 "afalgeng",
c38bb727 270 "asan",
8b527be2 271 "asm",
52739e40 272 "async",
b184e3ef 273 "autoalginit",
498abff0 274 "autoerrinit",
8b527be2 275 "bf",
2d0b4412 276 "blake2",
8b527be2
RL		 277 "camellia",
278 "capieng",
279 "cast",
48f14845 280 "chacha",
8b527be2
RL		 281 "cmac",
282 "cms",
283 "comp",
3e45d393 284 "crypto-mdebug",
ef8ca6bd 285 "crypto-mdebug-backtrace",
8b527be2
RL		 286 "ct",
287 "deprecated",
288 "des",
289 "dgram",
290 "dh",
291 "dsa",
292 "dso",
a5ecdc6a 293 "dtls",
343ec2b0 294 "dynamic-engine",
8b527be2
RL		 295 "ec",
296 "ec2m",
6b01bed2
VD		 297 "ecdh",
298 "ecdsa",
8b527be2 299 "ec_nistp_64_gcc_128",
b31feae6 300 "egd",
8b527be2 301 "engine",
1288f26f 302 "err",
02f7114a 303 "filenames",
f59d0131
KR		 304 "fuzz-libfuzzer",
305 "fuzz-afl",
168c3b73 306 "gost",
8b527be2 307 "heartbeats",
8b527be2
RL		 308 "hw(-.+)?",
309 "idea",
09aa263a 310 "makedepend",
8b527be2
RL		 311 "md2",
312 "md4",
8b527be2 313 "mdc2",
fa22f98f 314 "multiblock",
8b527be2
RL		 315 "nextprotoneg",
316 "ocb",
317 "ocsp",
ae48242c 318 "pic",
48f14845 319 "poly1305",
8b527be2
RL		 320 "posix-io",
321 "psk",
322 "rc2",
323 "rc4",
324 "rc5",
325 "rdrand",
326 "rfc3779",
8b527be2 327 "rmd160",
8b527be2 328 "scrypt",
8b527be2
RL		 329 "sctp",
330 "seed",
8b527be2
RL		 331 "shared",
332 "sock",
333 "srp",
334 "srtp",
335 "sse2",
336 "ssl",
8b527be2
RL		 337 "ssl-trace",
338 "static-engine",
339 "stdio",
8b527be2
RL		 340 "threads",
341 "tls",
1288f26f 342 "ts",
c38bb727 343 "ubsan",
1288f26f 344 "ui",
8b527be2
RL		 345 "unit-test",
346 "whirlpool",
8b1a5af3 347 "weak-ssl-ciphers",
8b527be2
RL		 348 "zlib",
349 "zlib-dynamic",
350 );
6b01bed2
VD		 351foreach my $proto ((@tls, @dtls))
352 {
353 push(@disablables, $proto);
354 push(@disablables, "$proto-method");
355 }
8b527be2 356
2b1343b9
MC		 357my %deprecated_disablables = (
358 "ssl2" => undef,
359 "buf-freelists" => undef,
360 "ripemd" => "rmd160"
e80381e1
RL		 361 );
362
c9a112f5
BM		 363# All of the following is disabled by default (RC5 was enabled before 0.9.8):
364
9e04edf2 365our %disabled = ( # "what" => "comment"
c38bb727 366 "asan" => "default",
9e04edf2 367 "ec_nistp_64_gcc_128" => "default",
8b1a5af3 368 "egd" => "default",
f59d0131
KR		 369 "fuzz-libfuzzer" => "default",
370 "fuzz-afl" => "default",
8b1a5af3
MC		 371 "md2" => "default",
372 "rc5" => "default",
373 "sctp" => "default",
8b1a5af3 374 "ssl-trace" => "default",
9829b5ab
KR		 375 "ssl3" => "default",
376 "ssl3-method" => "default",
c38bb727 377 "ubsan" => "default",
8b1a5af3
MC		 378 "unit-test" => "default",
379 "weak-ssl-ciphers" => "default",
380 "zlib" => "default",
381 "zlib-dynamic" => "default",
382 "crypto-mdebug" => "default",
4639c68b 383 "crypto-mdebug-backtrace" => "default",
8b1a5af3 384 "heartbeats" => "default",
9e04edf2 385 );
c9a112f5 386
c569e206
RL		 387# Note: => pair form used for aesthetics, not to truly make a hash table
388my @disable_cascades = (
389 # "what" => [ "cascade", ... ]
7d130f68 390 sub { $config{processor} eq "386" }
c569e206
RL		 391 => [ "sse2" ],
392 "ssl" => [ "ssl3" ],
393 "ssl3-method" => [ "ssl3" ],
394 "zlib" => [ "zlib-dynamic" ],
c569e206 395 "des" => [ "mdc2" ],
9e4d6fbf 396 "ec" => [ "ecdsa", "ecdh" ],
c569e206 397
3fd4d211 398 "dgram" => [ "dtls", "sctp" ],
505f74ca 399 "sock" => [ "dgram" ],
c569e206
RL		 400 "dtls" => [ @dtls ],
401
402 # SSL 3.0, (D)TLS 1.0 and TLS 1.1 require MD5 and SHA
403 "md5" => [ "ssl", "tls1", "tls1_1", "dtls1" ],
404 "sha" => [ "ssl", "tls1", "tls1_1", "dtls1" ],
405
406 # Additionally, SSL 3.0 requires either RSA or DSA+DH
407 sub { $disabled{rsa}
408 && ($disabled{dsa} || $disabled{dh}); }
409 => [ "ssl" ],
410
411 # (D)TLS 1.0 and TLS 1.1 also require either RSA or DSA+DH
412 # or ECDSA + ECDH. (D)TLS 1.2 has this requirement as well.
413 # (XXX: We don't support PSK-only builds).
414 sub { $disabled{rsa}
415 && ($disabled{dsa} || $disabled{dh})
416 && ($disabled{ecdsa} || $disabled{ecdh}); }
417 => [ "tls1", "tls1_1", "tls1_2",
418 "dtls1", "dtls1_2" ],
419
420 "tls" => [ @tls ],
421
422 # SRP and HEARTBEATS require TLSEXT
423 "tlsext" => [ "srp", "heartbeats" ],
ef8ca6bd
RL		 424
425 "crypto-mdebug" => [ "crypto-mdebug-backtrace" ],
343ec2b0
RL		 426
427 # Without DSO, we can't load dynamic engines, so don't build them dynamic
428 "dso" => [ "dynamic-engine" ],
ae48242c
RL		 429
430 # Without position independent code, there can be no shared libraries or DSOs
00698061
RL		 431 "pic" => [ "shared" ],
432 "shared" => [ "dynamic-engine" ],
c91a0a83 433 "engine" => [ "afalgeng" ],
d90a6beb
MC		 434
435 # no-autoalginit is only useful when building non-shared
436 "autoalginit" => [ "shared", "apps" ],
437
438 "stdio" => [ "apps" ],
439 "apps" => [ "tests" ],
b8ce6dda 440 "comp" => [ "zlib" ],
686c86a4 441 sub { !$disabled{"unit-test"} } => [ "heartbeats" ],
c569e206
RL		 442 );
443
444# Avoid protocol support holes. Also disable all versions below N, if version
445# N is disabled while N+1 is enabled.
446#
447my @list = (reverse @tls);
448while ((my $first, my $second) = (shift @list, shift @list)) {
449 last unless @list;
450 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
451 => [ @list ] );
452 unshift @list, $second;
453}
454my @list = (reverse @dtls);
455while ((my $first, my $second) = (shift @list, shift @list)) {
456 last unless @list;
457 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
458 => [ @list ] );
459 unshift @list, $second;
460}
461
7a762197 462# Explicit "no-..." options will be collected in %disabled along with the defaults.
e4ef2e25 463# To remove something from %disabled, use "enable-foo".
7a762197
BM		 464# For symmetry, "disable-foo" is a synonym for "no-foo".
465
d0590fe6 466my $no_sse2=0;
b6e4dac2 467
462ba4f6 468&usage if ($#ARGV < 0);
d02b48c6 469
bcb1977b
RL		 470my $user_cflags="";
471my @user_defines=();
7d130f68
RL		 472$config{openssl_api_defines}=[];
473$config{openssl_algorithm_defines}=[];
474$config{openssl_thread_defines}=[];
475$config{openssl_sys_defines}=[];
476$config{openssl_other_defines}=[];
fe05264e
RL		 477my $libs="";
478my $target="";
3fa04f0d 479$config{options}="";
8864f0de 480$config{build_type} = "release";
c59cb511
RL		 481
482my @argvcopy=@ARGV;
c59cb511 483
fe05264e 484if (grep /^reconf(igure)?$/, @argvcopy) {
642a6138
RL		 485 if (-f "./configdata.pm") {
486 my $file = "./configdata.pm";
487 unless (my $return = do $file) {
488 die "couldn't parse $file: $@" if $@;
489 die "couldn't do $file: $!" unless defined $return;
490 die "couldn't run $file" unless $return;
fe05264e 491 }
642a6138
RL		 492
493 @argvcopy = defined($configdata::config{perlargv}) ?
494 @{$configdata::config{perlargv}} : ();
495 die "Incorrect data to reconfigure, please do a normal configuration\n"
496 if (grep(/^reconf/,@argvcopy));
497 $ENV{CROSS_COMPILE} = $configdata::config{cross_compile_prefix}
498 if defined($configdata::config{cross_compile_prefix});
499 $ENV{CROSS_COMPILE} = $configdata::config{cc}
500 if defined($configdata::config{cc});
501
fe05264e
RL		 502 print "Reconfiguring with: ", join(" ",@argvcopy), "\n";
503 print " CROSS_COMPILE = ",$ENV{CROSS_COMPILE},"\n"
504 if $ENV{CROSS_COMPILE};
505 print " CC = ",$ENV{CC},"\n" if $ENV{CC};
642a6138
RL		 506 } elsif (open IN, "<Makefile") {
507 #
508 # THIS SECTION IS TEMPORARY, it helps transitioning from Makefile
509 # centered information gathering the reading configdata.pm
510 #
511 while (<IN>) {
04f171c0 512 s|\R$||;
642a6138
RL		 513 if (/^CONFIGURE_ARGS=\s*(.*)\s*/) {
514 # Older form, we split the string and hope for the best
515 @argvcopy = split /\s+/, $_;
516 die "Incorrect data to reconfigure, please do a normal configuration\n"
517 if (grep(/^reconf/,@argvcopy));
518 } elsif (/^CROSS_COMPILE=\s*(.*)/) {
519 $ENV{CROSS_COMPILE}=$1;
520 } elsif (/^CC=\s*(?:\$\(CROSS_COMPILE\))?(.*?)$/) {
521 $ENV{CC}=$1;
522 }
523 }
524 #
525 # END OF TEMPORARY SECTION
526 #
fe05264e
RL		 527 } else {
528 die "Insufficient data to reconfigure, please do a normal configuration\n";
529 }
530}
531
642a6138 532$config{perlargv} = [ @argvcopy ];
fe05264e
RL		 533
534my %unsupported_options = ();
e80381e1 535my %deprecated_options = ();
fe05264e 536foreach (@argvcopy)
16b6081e 537 {
7c55e22c
RL		 538 # VMS is a case insensitive environment, and depending on settings
539 # out of our control, we may receive options uppercased. Let's
540 # downcase at least the part before any equal sign.
541 if ($^O eq "VMS")
542 {
543 s/^([^=]*)/lc($1)/e;
544 }
fe05264e 545 s /^-no-/no-/; # some people just can't read the instructions
c9a112f5 546
fe05264e
RL		 547 # rewrite some options in "enable-..." form
548 s /^-?-?shared$/enable-shared/;
549 s /^sctp$/enable-sctp/;
550 s /^threads$/enable-threads/;
551 s /^zlib$/enable-zlib/;
552 s /^zlib-dynamic$/enable-zlib-dynamic/;
c9a112f5 553
e4ef2e25 554 if (/^(no|disable|enable)-(.+)$/)
2b1343b9
MC		 555 {
556 my $word = $2;
557 if (!exists $deprecated_disablables{$word}
558 && !grep { $word =~ /^${_}$/ } @disablables)
559 {
560 $unsupported_options{$_} = 1;
561 next;
562 }
563 }
564 if (/^no-(.+)$/ || /^disable-(.+)$/)
565 {
e4ef2e25
RS		 566 foreach my $proto ((@tls, @dtls))
567 {
568 if ($1 eq "$proto-method")
569 {
570 $disabled{"$proto"} = "option($proto-method)";
571 last;
572 }
573 }
574 if ($1 eq "dtls")
575 {
576 foreach my $proto (@dtls)
577 {
578 $disabled{$proto} = "option(dtls)";
579 }
c5c7700c 580 $disabled{"dtls"} = "option(dtls)";
e4ef2e25
RS		 581 }
582 elsif ($1 eq "ssl")
583 {
584 # Last one of its kind
585 $disabled{"ssl3"} = "option(ssl)";
586 }
587 elsif ($1 eq "tls")
588 {
589 # XXX: Tests will fail if all SSL/TLS
590 # protocols are disabled.
591 foreach my $proto (@tls)
592 {
593 $disabled{$proto} = "option(tls)";
594 }
595 }
343ec2b0
RL		 596 elsif ($1 eq "static-engine")
597 {
19ab5790 598 delete $disabled{"dynamic-engine"};
343ec2b0
RL		 599 }
600 elsif ($1 eq "dynamic-engine")
601 {
19ab5790 602 $disabled{"dynamic-engine"} = "option";
343ec2b0 603 }
2b1343b9
MC		 604 elsif (exists $deprecated_disablables{$1})
605 {
606 $deprecated_options{$_} = 1;
607 if (defined $deprecated_disablables{$1})
608 {
609 $disabled{$deprecated_disablables{$1}} = "option";
610 }
611 }
e4ef2e25
RS		 612 else
613 {
614 $disabled{$1} = "option";
615 }
9c62a279
RL		 616 # No longer an automatic choice
617 $auto_threads = 0 if ($1 eq "threads");
fe05264e 618 }
e4ef2e25 619 elsif (/^enable-(.+)$/)
fe05264e 620 {
343ec2b0
RL		 621 if ($1 eq "static-engine")
622 {
19ab5790 623 $disabled{"dynamic-engine"} = "option";
343ec2b0
RL		 624 }
625 elsif ($1 eq "dynamic-engine")
626 {
19ab5790 627 delete $disabled{"dynamic-engine"};
343ec2b0 628 }
25004db7
RL		 629 elsif ($1 eq "zlib-dynamic")
630 {
631 delete $disabled{"zlib"};
632 }
fe05264e 633 my $algo = $1;
fe05264e 634 delete $disabled{$algo};
c9a112f5 635
9c62a279
RL		 636 # No longer an automatic choice
637 $auto_threads = 0 if ($1 eq "threads");
fe05264e
RL		 638 }
639 elsif (/^--strict-warnings$/)
640 {
641 $strict_warnings = 1;
642 }
643 elsif (/^--debug$/)
644 {
8864f0de 645 $config{build_type} = "debug";
fe05264e
RL		 646 }
647 elsif (/^--release$/)
648 {
8864f0de 649 $config{build_type} = "release";
fe05264e
RL		 650 }
651 elsif (/^386$/)
7d130f68 652 { $config{processor}=386; }
fe05264e
RL		 653 elsif (/^fips$/)
654 {
107b5792 655 $config{fips}=1;
fe05264e
RL		 656 }
657 elsif (/^rsaref$/)
658 {
659 # No RSAref support any more since it's not needed.
660 # The check for the option is there so scripts aren't
661 # broken
662 }
663 elsif (/^nofipscanistercheck$/)
664 {
107b5792 665 $config{fips} = 1;
fe05264e
RL		 666 $nofipscanistercheck = 1;
667 }
668 elsif (/^[-+]/)
669 {
45c6e23c 670 if (/^--prefix=(.*)$/)
fe05264e 671 {
291e94df 672 $config{prefix}=$1;
5482dac9
RL		 673 die "Directory given with --prefix MUST be absolute\n"
674 unless file_name_is_absolute($config{prefix});
c9a112f5 675 }
fe05264e 676 elsif (/^--api=(.*)$/)
0c28f277 677 {
107b5792 678 $config{api}=$1;
0c28f277 679 }
fe05264e 680 elsif (/^--libdir=(.*)$/)
9e43c6b5 681 {
107b5792 682 $config{libdir}=$1;
9e43c6b5 683 }
fe05264e 684 elsif (/^--openssldir=(.*)$/)
9e43c6b5 685 {
291e94df 686 $config{openssldir}=$1;
9e43c6b5 687 }
fe05264e 688 elsif (/^--with-zlib-lib=(.*)$/)
9fdb2cc5 689 {
20a5819f 690 $withargs{zlib_lib}=$1;
7d8bb912 691 }
fe05264e 692 elsif (/^--with-zlib-include=(.*)$/)
3eb0ed6d 693 {
da430a55 694 $withargs{zlib_include}=$1;
462ba4f6 695 }
f59d0131
KR		 696 elsif (/^--with-fuzzer-lib=(.*)$/)
697 {
698 $withargs{fuzzer_lib}=$1;
699 }
700 elsif (/^--with-fuzzer-include=(.*)$/)
701 {
702 $withargs{fuzzer_include}=$1;
703 }
fe05264e 704 elsif (/^--with-fipslibdir=(.*)$/)
1ab2f7f1 705 {
107b5792 706 $config{fipslibdir}="$1/";
1ab2f7f1 707 }
fe05264e 708 elsif (/^--with-baseaddr=(.*)$/)
462ba4f6 709 {
107b5792 710 $config{baseaddr}="$1";
3eb0ed6d 711 }
fe05264e 712 elsif (/^--cross-compile-prefix=(.*)$/)
e5f3045f 713 {
642a6138 714 $config{cross_compile_prefix}=$1;
e5f3045f 715 }
fe05264e 716 elsif (/^--config=(.*)$/)
d02b48c6 717 {
fe05264e 718 read_config $1;
c59cb511 719 }
fe05264e 720 elsif (/^-[lL](.*)$/ or /^-Wl,/)
c9a112f5 721 {
fe05264e 722 $libs.=$_." ";
d02b48c6 723 }
bcb1977b
RL		 724 elsif (/^-D(.*)$/)
725 {
726 push @user_defines, $1;
727 }
fe05264e
RL		 728 else # common if (/^[-+]/), just pass down...
729 {
730 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
2b91ec75 731 $user_cflags.=" ".$_;
fe05264e
RL		 732 }
733 }
fe05264e
RL		 734 else
735 {
736 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
737 $target=$_;
738 }
739 unless ($_ eq $target || /^no-/ || /^disable-/)
740 {
741 # "no-..." follows later after implied disactivations
8483a003 742 # have been derived. (Don't take this too seriously,
fe05264e
RL		 743 # we really only write OPTIONS to the Makefile out of
744 # nostalgia.)
745
3fa04f0d
RL		 746 if ($config{options} eq "")
747 { $config{options} = $_; }
fe05264e 748 else
3fa04f0d 749 { $config{options} .= " ".$_; }
fbabb752 750 }
489eb740 751
107b5792
RL		 752 if (defined($config{api}) && !exists $apitable->{$config{api}}) {
753 die "***** Unsupported api compatibility level: $config{api}\n",
98186eb4
VD		 754 }
755
e80381e1
RL		 756 if (keys %deprecated_options)
757 {
758 warn "***** Deprecated options: ",
759 join(", ", keys %deprecated_options), "\n";
760 }
489eb740
RL		 761 if (keys %unsupported_options)
762 {
763 die "***** Unsupported options: ",
764 join(", ", keys %unsupported_options), "\n";
765 }
fbabb752 766 }
b6e4dac2 767
107b5792 768if ($config{fips})
a7a14a23 769 {
c569e206 770 delete $disabled{"shared"} if ($disabled{"shared"} =~ /^default/);
6b01bed2 771 }
107b5792
RL		 772else
773 {
774 @{$config{dirs}} = grep !/^fips$/, @{$config{dirs}};
775 }
c9a112f5 776
c569e206
RL		 777my @tocheckfor = (keys %disabled);
778while (@tocheckfor) {
779 my %new_tocheckfor = ();
780 my @cascade_copy = (@disable_cascades);
781 while (@cascade_copy) {
782 my ($test, $descendents) = (shift @cascade_copy, shift @cascade_copy);
783 if (ref($test) eq "CODE" ? $test->() : defined($disabled{$test})) {
2110febb 784 foreach(grep { !defined($disabled{$_}) } @$descendents) {
01d99976 785 $new_tocheckfor{$_} = 1; $disabled{$_} = "forced";
2110febb 786 }
ef236ec3 787 }
c569e206
RL		 788 }
789 @tocheckfor = (keys %new_tocheckfor);
790}
edc032b5 791
436a376b 792if ($target eq "TABLE") {
00ae96ca
RL		 793 foreach (sort keys %table) {
794 print_table_entry($_, "TABLE");
795 }
796 exit 0;
436a376b
BM		 797}
798
10a926c1 799if ($target eq "LIST") {
00ae96ca
RL		 800 foreach (sort keys %table) {
801 print $_,"\n" unless $table{$_}->{template};
802 }
803 exit 0;
10a926c1
UM		 804}
805
aaf878cc 806if ($target eq "HASH") {
00ae96ca
RL		 807 print "%table = (\n";
808 foreach (sort keys %table) {
809 print_table_entry($_, "HASH");
810 }
811 exit 0;
aaf878cc
RL		 812}
813
00ae96ca 814# Backward compatibility?
49e04548 815if ($target =~ m/^CygWin32(-.*)$/) {
00ae96ca 816 $target = "Cygwin".$1;
49e04548
RL		 817}
818
c9a112f5
BM		 819foreach (sort (keys %disabled))
820 {
3fa04f0d 821 $config{options} .= " no-$_";
c9a112f5
BM		 822
823 printf " no-%-12s %-10s", $_, "[$disabled{$_}]";
824
825 if (/^dso$/)
721f9058 826 { }
c9a112f5 827 elsif (/^threads$/)
22bfe05e 828 { }
c9a112f5 829 elsif (/^shared$/)
84af1bae 830 { }
ae48242c
RL		 831 elsif (/^pic$/)
832 { }
c9a112f5 833 elsif (/^zlib$/)
36a30909 834 { }
19ab5790 835 elsif (/^dynamic-engine$/)
fbf002bb 836 { }
09aa263a
RL		 837 elsif (/^makedepend$/)
838 { }
c9a112f5
BM		 839 elsif (/^zlib-dynamic$/)
840 { }
c9a112f5
BM		 841 elsif (/^sse2$/)
842 { $no_sse2 = 1; }
107b5792 843 elsif (/^engine$/)
1288f26f
RS		 844 {
845 @{$config{dirs}} = grep !/^engines$/, @{$config{dirs}};
846 @{$config{sdirs}} = grep !/^engine$/, @{$config{sdirs}};
847 push @{$config{openssl_other_defines}}, "OPENSSL_NO_ENGINE";
848 }
c9a112f5
BM		 849 else
850 {
851 my ($ALGO, $algo);
30fafdeb 852 ($ALGO = $algo = $_) =~ tr/[\-a-z]/[_A-Z]/;
c9a112f5 853
316fae2a 854 if (/^asm$/ || /^err$/ || /^hw$/ || /^hw-/ || /^async$/
498abff0 855 || /^autoalginit/ || /^autoerrinit/)
c9a112f5 856 {
7d130f68 857 push @{$config{openssl_other_defines}}, "OPENSSL_NO_$ALGO";
c9a112f5 858 print " OPENSSL_NO_$ALGO";
fce0ba5f 859
bcb1977b 860 if (/^err$/) { push @user_defines, "OPENSSL_NO_ERR"; }
c9a112f5
BM		 861 }
862 else
863 {
2a4af947
AP		 864 ($ALGO,$algo) = ("RMD160","rmd160") if ($algo eq "ripemd");
865
7d130f68 866 push @{$config{openssl_algorithm_defines}}, "OPENSSL_NO_$ALGO";
c9a112f5
BM		 867 print " OPENSSL_NO_$ALGO";
868
e36827f6 869 # fix-up crypto/directory name(s)
107b5792
RL		 870 $algo="whrlpool" if $algo eq "whirlpool";
871 $algo="ripemd" if $algo eq "rmd160";
872 @{$config{sdirs}} = grep { $_ ne $algo} @{$config{sdirs}};
2a4af947 873
e36827f6 874 print " (skip dir)";
c9a112f5
BM		 875 }
876 }
877
878 print "\n";
879 }
880
9e0724a1
RL		 881print "Configuring for $target\n";
882
883# Support for legacy targets having a name starting with 'debug-'
884my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
885if ($d) {
8864f0de 886 $config{build_type} = "debug";
9e0724a1
RL		 887
888 # If we do not find debug-foo in the table, the target is set to foo.
889 if (!$table{$target}) {
890 $target = $t;
891 }
892}
291e94df 893$config{target} = $target;
79302211 894my %target = resolve_config($target);
9e0724a1
RL		 895
896&usage if (!%target || $target{template});
897
d2b2221a 898%target = ( %{$table{DEFAULTS}}, %target );
79302211 899
107b5792 900$target{exe_extension}="";
f99f91f1
RL		 901$target{exe_extension}=".exe" if ($config{target} eq "DJGPP"
902 || $config{target} =~ /^(?:Cygwin|mingw)/);
107b5792 903$target{exe_extension}=".pm" if ($config{target} =~ /vos/);
462ba4f6 904
e987f9f2
RL		 905($target{shared_extension_simple}=$target{shared_extension})
906 =~ s|\.\$\(SHLIB_MAJOR\)\.\$\(SHLIB_MINOR\)||;
907$target{dso_extension}=$target{shared_extension_simple};
908($target{shared_import_extension}=$target{shared_extension_simple}.".a")
909 if ($config{target} =~ /^(?:Cygwin|mingw)/);
910
911
642a6138
RL		 912$config{cross_compile_prefix} = $ENV{'CROSS_COMPILE'}
913 if $config{cross_compile_prefix} eq "";
f99f41cf 914
b0a1e8bf 915# Allow overriding the names of some tools. USE WITH CARE
5902821d 916$config{perl} = $ENV{'PERL'} || ($^O ne "VMS" ? $^X : "perl");
b0a1e8bf 917$target{cc} = $ENV{'CC'} || $target{cc} || "cc";
f58a0acb 918$target{ranlib} = $ENV{'RANLIB'} || $target{ranlib} ||
656bbdc6 919 (which("$config{cross_compile_prefix}ranlib") ?
f58a0acb 920 "\$(CROSS_COMPILE)ranlib" : "true");
b0a1e8bf
RL		 921$target{ar} = $ENV{'AR'} || $target{ar} || "ar";
922$target{nm} = $ENV{'NM'} || $target{nm} || "nm";
8f41ff2d
RL		 923$target{rc} =
924 $ENV{'RC'} || $ENV{'WINDRES'} || $target{rc} || "windres";
aaf878cc 925
bcb1977b
RL		 926# For cflags, lflags, plib_lflags, ex_libs and defines, add the debug_
927# or release_ attributes.
aaf878cc 928# Do it in such a way that no spurious space is appended (hence the grep).
2952b9b8
RL		 929$config{defines} = [];
930$config{cflags} = "";
931$config{ex_libs} = "";
932$config{shared_ldflag} = "";
bd5192b1 933
291e94df
RL		 934# Make sure build_scheme is consistent.
935$target{build_scheme} = [ $target{build_scheme} ]
936 if ref($target{build_scheme}) ne "ARRAY";
937
ddf1847d
RL		 938my ($builder, $builder_platform, @builder_opts) =
939 @{$target{build_scheme}};
940
488e2b0f
RL		 941push @{$config{defines}}, "NDEBUG" if $config{build_type} eq "release";
942
68ab559a 943if ($target =~ /^mingw/ && `$target{cc} --target-help 2>&1` =~ m/-mno-cygwin/m)
cbecd29a 944 {
68ab559a 945 $config{cflags} .= " -mno-cygwin";
2952b9b8 946 $config{shared_ldflag} .= " -mno-cygwin";
cbecd29a
AP		 947 }
948
00b0d663 949if ($target =~ /linux.*-mips/ && !$disabled{asm} && $user_cflags !~ /-m(ips|arch=)/) {
63d8834c 950 # minimally required architecture flags for assembly modules
107b5792
RL		 951 $config{cflags}="-mips2 $config{cflags}" if ($target =~ /mips32/);
952 $config{cflags}="-mips3 $config{cflags}" if ($target =~ /mips64/);
63d8834c
AP		 953}
954
2964ba8c 955my $no_shared_warn=0;
14bcdb08 956my $no_user_cflags=0;
bcb1977b 957my $no_user_defines=0;
2964ba8c 958
bc2aadad
GT		 959# The DSO code currently always implements all functions so that no
960# applications will have to worry about that from a compilation point
961# of view. However, the "method"s may return zero unless that platform
962# has support compiled in for them. Currently each method is enabled
963# by a define "DSO_<name>" ... we translate the "dso_scheme" config
964# string entry into using the following logic;
721f9058 965if (!$disabled{dso} && $target{dso_scheme} ne "")
bc2aadad 966 {
291e94df
RL		 967 $target{dso_scheme} =~ tr/[a-z]/[A-Z]/;
968 if ($target{dso_scheme} eq "DLFCN")
bc2aadad 969 {
2952b9b8 970 unshift @{$config{defines}}, "DSO_DLFCN", "HAVE_DLFCN_H";
bc2aadad 971 }
291e94df 972 elsif ($target{dso_scheme} eq "DLFCN_NO_H")
bc2aadad 973 {
2952b9b8 974 unshift @{$config{defines}}, "DSO_DLFCN";
bc2aadad
GT		 975 }
976 else
977 {
2952b9b8 978 unshift @{$config{defines}}, "DSO_$target{dso_scheme}";
bc2aadad
GT		 979 }
980 }
9ec0126e 981
1740c162 982$config{ex_libs}="$libs$config{ex_libs}" if ($libs ne "");
d02b48c6 983
00b0d663 984if ($disabled{asm})
dfeab068 985 {
2952b9b8
RL		 986 if ($config{fips})
987 {
988 @{$config{defines}} = grep !/^[BL]_ENDIAN$/, @{$config{defines}};
989 @{$target{defines}} = grep !/^[BL]_ENDIAN$/, @{$target{defines}};
990 }
dfeab068 991 }
6f7ac8e1 992
9c62a279
RL		 993# If threads aren't disabled, check how possible they are
994unless ($disabled{threads}) {
995 if ($auto_threads) {
996 # Enabled by default, disable it forcibly if unavailable
997 if ($target{thread_scheme} eq "(unknown)") {
998 $disabled{threads} = "unavailable";
999 }
1000 } else {
8483a003 1001 # The user chose to enable threads explicitly, let's see
9c62a279
RL		 1002 # if there's a chance that's possible
1003 if ($target{thread_scheme} eq "(unknown)") {
1004 # If the user asked for "threads" and we don't have internal
1005 # knowledge how to do it, [s]he is expected to provide any
1006 # system-dependent compiler options that are necessary. We
1007 # can't truly check that the given options are correct, but
1008 # we expect the user to know what [s]He is doing.
1009 if ($no_user_cflags && $no_user_defines) {
1010 die "You asked for multi-threading support, but didn't\n"
1011 ,"provide any system-specific compiler options\n";
1012 }
1013 }
1014 }
1015}
1016
1017# If threads still aren't disabled, add a C macro to ensure the source
1018# code knows about it. Any other flag is taken care of by the configs.
1019unless($disabled{threads}) {
1020 foreach (("defines", "openssl_thread_defines")) {
1021 push @{$config{$_}}, "OPENSSL_THREADS";
1022 }
1023}
e452de9d 1024
98186eb4
VD		 1025# With "deprecated" disable all deprecated features.
1026if (defined($disabled{"deprecated"})) {
107b5792 1027 $config{api} = $maxapi;
98186eb4 1028}
07c4c14c 1029
291e94df 1030if ($target{shared_target} eq "")
6f7ac8e1 1031 {
ae48242c 1032 $no_shared_warn = 1
84af1bae 1033 if ((!$disabled{shared} || !$disabled{"dynamic-engine"})
ae48242c 1034 && !$config{fips});
84af1bae 1035 $disabled{shared} = "no-shared-target";
ae48242c
RL		 1036 $disabled{pic} = $disabled{shared} = $disabled{"dynamic-engine"} =
1037 "no-shared-target";
6f7ac8e1 1038 }
b436a982 1039
19ab5790 1040if ($disabled{"dynamic-engine"}) {
343ec2b0
RL		 1041 push @{$config{defines}}, "OPENSSL_NO_DYNAMIC_ENGINE";
1042 $config{dynamic_engines} = 0;
19ab5790
RL		 1043} else {
1044 push @{$config{defines}}, "OPENSSL_NO_STATIC_ENGINE";
1045 $config{dynamic_engines} = 1;
343ec2b0 1046}
ecd45314 1047
f59d0131 1048unless ($disabled{"fuzz-libfuzzer"}) {
c38bb727
BL		 1049 $config{cflags} .= "-fsanitize-coverage=edge,indirect-calls ";
1050}
1051
1052unless ($disabled{asan}) {
1053 $config{cflags} .= "-fsanitize=address ";
1054}
1055
1056unless ($disabled{ubsan}) {
f430ba31 1057 # -DPEDANTIC or -fnosanitize=alignment may also be required on some
c38bb727
BL		 1058 # platforms.
1059 $config{cflags} .= "-fsanitize=undefined -fno-sanitize-recover=all ";
1060}
1061
65cc6d5c
RL		 1062unless ($disabled{"fuzz-libfuzzer"} && $disabled{"fuzz-afl"}
1063 && $disabled{asan} && $disabled{ubsan}) {
c38bb727
BL		 1064 $config{cflags} .= "-fno-omit-frame-pointer -g ";
1065}
c313e32a
AP		 1066#
1067# Platform fix-ups
1068#
ae48242c
RL		 1069
1070# This saves the build files from having to check
1071if ($disabled{pic})
1072 {
1073 $target{shared_cflag} = $target{shared_ldflag} =
1074 $target{shared_rcflag} = "";
1075 }
4f16039e
RL		 1076else
1077 {
1078 push @{$config{defines}}, "OPENSSL_PIC";
1079 }
ae48242c 1080
291e94df 1081if ($target{sys_id} ne "")
cf1b7d96 1082 {
642a6138 1083 push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
cf1b7d96
RL		 1084 }
1085
00b0d663 1086unless ($disabled{asm}) {
d2b2221a 1087 $target{cpuid_asm_src}=$table{DEFAULTS}->{cpuid_asm_src} if ($config{processor} eq "386");
9fe2bb77 1088 $target{bn_asm_src} =~ s/\w+-gf2m.c// if (defined($disabled{ec2m}));
f8c469de 1089
9e0724a1 1090 # bn-586 is the only one implementing bn_*_part_words
bcb1977b
RL		 1091 push @{$config{defines}}, "OPENSSL_BN_ASM_PART_WORDS" if ($target{bn_asm_src} =~ /bn-586/);
1092 push @{$config{defines}}, "OPENSSL_IA32_SSE2" if (!$no_sse2 && $target{bn_asm_src} =~ /86/);
dfeab068 1093
bcb1977b
RL		 1094 push @{$config{defines}}, "OPENSSL_BN_ASM_MONT" if ($target{bn_asm_src} =~ /-mont/);
1095 push @{$config{defines}}, "OPENSSL_BN_ASM_MONT5" if ($target{bn_asm_src} =~ /-mont5/);
1096 push @{$config{defines}}, "OPENSSL_BN_ASM_GF2m" if ($target{bn_asm_src} =~ /-gf2m/);
5ac7bde7 1097
107b5792 1098 if ($config{fips}) {
7d130f68 1099 push @{$config{openssl_other_defines}}, "OPENSSL_FIPS";
9e0724a1 1100 }
1ab2f7f1 1101
9fe2bb77 1102 if ($target{sha1_asm_src}) {
bcb1977b
RL		 1103 push @{$config{defines}}, "SHA1_ASM" if ($target{sha1_asm_src} =~ /sx86/ || $target{sha1_asm_src} =~ /sha1/);
1104 push @{$config{defines}}, "SHA256_ASM" if ($target{sha1_asm_src} =~ /sha256/);
1105 push @{$config{defines}}, "SHA512_ASM" if ($target{sha1_asm_src} =~ /sha512/);
9e0724a1 1106 }
9fe2bb77 1107 if ($target{md5_asm_src}) {
bcb1977b 1108 push @{$config{defines}}, "MD5_ASM";
9e0724a1 1109 }
d2b2221a 1110 $target{cast_asm_src}=$table{DEFAULTS}->{cast_asm_src} unless $disabled{pic}; # CAST assembler is not PIC
9fe2bb77 1111 if ($target{rmd160_asm_src}) {
bcb1977b 1112 push @{$config{defines}}, "RMD160_ASM";
9e0724a1 1113 }
9fe2bb77 1114 if ($target{aes_asm_src}) {
bcb1977b 1115 push @{$config{defines}}, "AES_ASM" if ($target{aes_asm_src} =~ m/\baes-/);;
9fe2bb77 1116 # aes-ctr.fake is not a real file, only indication that assembler
874a3757 1117 # module implements AES_ctr32_encrypt...
bcb1977b 1118 push @{$config{defines}}, "AES_CTR_ASM" if ($target{aes_asm_src} =~ s/\s*aes-ctr\.fake//);
9fe2bb77 1119 # aes-xts.fake indicates presence of AES_xts_[en|de]crypt...
bcb1977b 1120 push @{$config{defines}}, "AES_XTS_ASM" if ($target{aes_asm_src} =~ s/\s*aes-xts\.fake//);
9fe2bb77 1121 $target{aes_asm_src} =~ s/\s*(vpaes|aesni)-x86\.s//g if ($no_sse2);
bcb1977b
RL		 1122 push @{$config{defines}}, "VPAES_ASM" if ($target{aes_asm_src} =~ m/vpaes/);
1123 push @{$config{defines}}, "BSAES_ASM" if ($target{aes_asm_src} =~ m/bsaes/);
9e0724a1 1124 }
9fe2bb77 1125 if ($target{wp_asm_src} =~ /mmx/) {
46d4d865 1126 if ($config{processor} eq "386") {
d2b2221a 1127 $target{wp_asm_src}=$table{DEFAULTS}->{wp_asm_src};
46d4d865 1128 } elsif (!$disabled{"whirlpool"}) {
2952b9b8 1129 push @{$config{defines}}, "WHIRLPOOL_ASM";
46d4d865 1130 }
9e0724a1 1131 }
9fe2bb77 1132 if ($target{modes_asm_src} =~ /ghash-/) {
bcb1977b 1133 push @{$config{defines}}, "GHASH_ASM";
9e0724a1 1134 }
9fe2bb77 1135 if ($target{ec_asm_src} =~ /ecp_nistz256/) {
bcb1977b 1136 push @{$config{defines}}, "ECP_NISTZ256_ASM";
9e0724a1 1137 }
9fe2bb77 1138 if ($target{poly1305_asm_src} ne "") {
bcb1977b 1139 push @{$config{defines}}, "POLY1305_ASM";
9e0724a1
RL		 1140 }
1141}
d02b48c6 1142
8ed40b83 1143my $ecc = $target{cc};
09aa263a 1144if ($^O ne "VMS" && !$disabled{makedepend}) {
a583fc45
RL		 1145 # Is the compiler gcc or clang? $ecc is used below to see if
1146 # error-checking can be turned on.
1147 my $ccpcc = "$config{cross_compile_prefix}$target{cc}";
d0db7ee0
AP		 1148 open(PIPE, "$ccpcc --version 2>&1 |");
1149 my $lines = 2;
a583fc45 1150 while ( <PIPE> ) {
30752dd7
RL		 1151 # Find the version number and save the major.
1152 m|(?:.*)\b(\d+)\.\d+\.\d+\b(?:.*)|;
39affe19 1153 my $compiler_major = $1;
30752dd7
RL		 1154 # We know that GNU C version 3 and up as well as all clang
1155 # versions support dependency generation
39affe19 1156 $config{makedepprog} = $ccpcc
d0db7ee0 1157 if (/clang/ || (/gcc/ && $compiler_major > 3));
a583fc45
RL		 1158 $ecc = "clang" if /clang/;
1159 $ecc = "gcc" if /gcc/;
d0db7ee0 1160 last if ($config{makedepprog} || !$lines--);
a583fc45
RL		 1161 }
1162 close(PIPE);
09aa263a 1163
656bbdc6 1164 $config{makedepprog} = which('makedepend') unless $config{makedepprog};
09aa263a 1165 $disabled{makedepend} = "unavailable" unless $config{makedepprog};
f1f07a23 1166}
8ed40b83 1167
7d130f68 1168
09aa263a 1169
7d130f68
RL		 1170# Deal with bn_ops ###################################################
1171
7d130f68 1172$config{bn_ll} =0;
7d130f68
RL		 1173$config{export_var_as_fn} =0;
1174my $def_int="unsigned int";
1175$config{rc4_int} =$def_int;
b4f35e5e 1176($config{b64l},$config{b64},$config{b32})=(0,0,1);
7d130f68 1177
94af0cd7 1178my $count = 0;
7d130f68 1179foreach (sort split(/\s+/,$target{bn_ops})) {
94af0cd7
RS		 1180 $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1181 $config{export_var_as_fn}=1 if $_ eq 'EXPORT_VAR_AS_FN';
1182 $config{bn_ll}=1 if $_ eq 'BN_LLONG';
1183 $config{rc4_int}="unsigned char" if $_ eq 'RC4_CHAR';
1184 ($config{b64l},$config{b64},$config{b32})
1185 =(0,1,0) if $_ eq 'SIXTY_FOUR_BIT';
1186 ($config{b64l},$config{b64},$config{b32})
1187 =(1,0,0) if $_ eq 'SIXTY_FOUR_BIT_LONG';
1188 ($config{b64l},$config{b64},$config{b32})
1189 =(0,0,1) if $_ eq 'THIRTY_TWO_BIT';
7d130f68 1190}
94af0cd7
RS		 1191die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1192 if $count > 1;
7d130f68
RL		 1193
1194
1195# Hack cflags for better warnings (dev option) #######################
1196
1ed0c662
RL		 1197# "Stringify" the C flags string. This permits it to be made part of a string
1198# and works as well on command lines.
01d99976 1199$config{cflags} =~ s/([\\\"])/\\$1/g;
b436a982 1200
107b5792
RL		 1201if (defined($config{api})) {
1202 $config{openssl_api_defines} = [ "OPENSSL_MIN_API=".$apitable->{$config{api}} ];
bcb1977b 1203 my $apiflag = sprintf("OPENSSL_API_COMPAT=%s", $apitable->{$config{api}});
bcb1977b 1204 push @{$config{defines}}, $apiflag;
98186eb4
VD		 1205}
1206
0c28f277
DSH		 1207if ($strict_warnings)
1208 {
1209 my $wopt;
f1f07a23
RS		 1210 die "ERROR --strict-warnings requires gcc or clang"
1211 unless $ecc eq 'gcc' || $ecc eq 'clang';
0c28f277
DSH		 1212 foreach $wopt (split /\s+/, $gcc_devteam_warn)
1213 {
d918f9cb 1214 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
0c28f277 1215 }
190c8c60
BL		 1216 if ($ecc eq "clang")
1217 {
1218 foreach $wopt (split /\s+/, $clang_devteam_warn)
1219 {
d918f9cb 1220 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
190c8c60
BL		 1221 }
1222 }
ef8ca6bd
RL		 1223 }
1224
1225unless ($disabled{"crypto-mdebug-backtrace"})
1226 {
1227 foreach my $wopt (split /\s+/, $memleak_devteam_backtrace)
a1d3f3d1 1228 {
d918f9cb 1229 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
ef8ca6bd
RL		 1230 }
1231 if ($target =~ /^BSD-/)
1232 {
1233 $config{ex_libs} .= " -lexecinfo";
291e94df 1234 }
0c28f277
DSH		 1235 }
1236
63994098
RL		 1237if ($user_cflags ne "") { $config{cflags}="$config{cflags}$user_cflags"; }
1238else { $no_user_cflags=1; }
1239if (@user_defines) { $config{defines}=[ @{$config{defines}}, @user_defines ]; }
1240else { $no_user_defines=1; }
1241
1242# ALL MODIFICATIONS TO %config and %target MUST BE DONE FROM HERE ON
1243
c91a0a83
EK		 1244unless ($disabled{afalgeng}) {
1245 $config{afalgeng}="";
79fff39d
RL		 1246 if ($target =~ m/^linux/) {
1247 my $minver = 4*10000 + 1*100 + 0;
1248 if ($config{cross_compile_prefix} eq "") {
1249 my $verstr = `uname -r`;
1250 my ($ma, $mi1, $mi2) = split("\\.", $verstr);
1251 ($mi2) = $mi2 =~ /(\d+)/;
1252 my $ver = $ma*10000 + $mi1*100 + $mi2;
1253 if ($ver < $minver) {
c91a0a83 1254 $disabled{afalgeng} = "too-old-kernel";
79fff39d
RL		 1255 } else {
1256 push @{$config{engdirs}}, "afalg";
1257 }
68dc37c1
MC		 1258 } else {
1259 $disabled{afalgeng} = "cross-compiling";
6cba4a66 1260 }
79fff39d 1261 } else {
c91a0a83 1262 $disabled{afalgeng} = "not-linux";
7f458a48 1263 }
1264}
8da00a38 1265
c91a0a83 1266push @{$config{openssl_other_defines}}, "OPENSSL_NO_AFALGENG" if ($disabled{afalgeng});
7f458a48 1267
9fe2bb77
RL		 1268# If we use the unified build, collect information from build.info files
1269my %unified_info = ();
1270
2b6b606c 1271my $buildinfo_debug = defined($ENV{CONFIGURE_DEBUG_BUILDINFO});
ddf1847d
RL		 1272if ($builder eq "unified") {
1273 # Store the name of the template file we will build the build file from
1274 # in %config. This may be useful for the build file itself.
38add230
RL		 1275 my $build_file_template;
1276
1277 for my $filename (( $builder_platform."-".$target{build_file}.".tmpl",
1278 $target{build_file}.".tmpl" )) {
1279 if (defined $ENV{$local_config_envname}) {
1280 if ($^O eq 'VMS') {
1281 # VMS environment variables are logical names,
1282 # which can be used as is
1283 $build_file_template = $local_config_envname . ':' . $filename;
1284 } else {
1285 $build_file_template = catfile($ENV{$local_config_envname},
1286 $filename);
1287 }
1288 }
1289
1290 last if -f $build_file_template;
1291
1292 $build_file_template = catfile($srcdir, "Configurations", $filename);
1293
1294 last if -f $build_file_template;
1295 }
ddf1847d
RL		 1296 $config{build_file_template} = $build_file_template;
1297
9fe2bb77
RL		 1298 use lib catdir(dirname(__FILE__),"util");
1299 use with_fallback qw(Text::Template);
1300
9fe2bb77 1301 sub cleandir {
2e963849 1302 my $base = shift;
9fe2bb77 1303 my $dir = shift;
2e963849
RL		 1304 my $relativeto = shift || ".";
1305
1306 $dir = catdir($base,$dir) unless isabsolute($dir);
9fe2bb77 1307
ec182ef0
RL		 1308 # Make sure the directories we're building in exists
1309 mkpath($dir);
1310
2e963849 1311 my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
9fe2bb77
RL		 1312 #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1313 return $res;
1314 }
1315
1316 sub cleanfile {
2e963849 1317 my $base = shift;
9fe2bb77 1318 my $file = shift;
2e963849
RL		 1319 my $relativeto = shift || ".";
1320
1321 $file = catfile($base,$file) unless isabsolute($file);
1322
9fe2bb77
RL		 1323 my $d = dirname($file);
1324 my $f = basename($file);
1325
ec182ef0
RL		 1326 # Make sure the directories we're building in exists
1327 mkpath($d);
1328
2e963849 1329 my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
9fe2bb77
RL		 1330 #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1331 return $res;
1332 }
1333
1334 my @build_infos = ( [ ".", "build.info" ] );
90d28f05
BL		 1335 push @build_infos, [ "fuzz", "build.info.fuzz" ]
1336 unless $disabled{"fuzz-afl"} && $disabled{"fuzz-libfuzzer"};
1337
9fe2bb77
RL		 1338 foreach (@{$config{dirs}}) {
1339 push @build_infos, [ $_, "build.info" ]
1340 if (-f catfile($srcdir, $_, "build.info"));
1341 }
1342 foreach (@{$config{sdirs}}) {
1343 push @build_infos, [ catdir("crypto", $_), "build.info" ]
1344 if (-f catfile($srcdir, "crypto", $_, "build.info"));
1345 }
1346 foreach (@{$config{engdirs}}) {
1347 push @build_infos, [ catdir("engines", $_), "build.info" ]
1348 if (-f catfile($srcdir, "engines", $_, "build.info"));
1349 }
1350
2e0956ba
RL		 1351 $config{build_infos} = [ ];
1352
9fe2bb77
RL		 1353 foreach (@build_infos) {
1354 my $sourced = catdir($srcdir, $_->[0]);
1355 my $buildd = catdir($blddir, $_->[0]);
1356
dca99383 1357 mkpath($buildd);
9fe2bb77
RL		 1358
1359 my $f = $_->[1];
1360 # The basic things we're trying to build
1361 my @programs = ();
1362 my @libraries = ();
1363 my @engines = ();
1364 my @scripts = ();
1365 my @extra = ();
8a67946e 1366 my @overrides = ();
9fe2bb77
RL		 1367 my @intermediates = ();
1368 my @rawlines = ();
1369
1370 my %ordinals = ();
1371 my %sources = ();
2a08d1a0 1372 my %shared_sources = ();
9fe2bb77
RL		 1373 my %includes = ();
1374 my %depends = ();
1375 my %renames = ();
1376 my %sharednames = ();
ae4c7450 1377 my %generate = ();
9fe2bb77 1378
2e0956ba 1379 push @{$config{build_infos}}, catfile(abs2rel($sourced, $blddir), $f);
9fe2bb77
RL		 1380 my $template = Text::Template->new(TYPE => 'FILE',
1381 SOURCE => catfile($sourced, $f));
1382 die "Something went wrong with $sourced/$f: $!\n" unless $template;
1383 my @text =
1384 split /^/m,
1385 $template->fill_in(HASH => { config => \%config,
1386 target => \%target,
9e04edf2 1387 disabled => \%disabled,
f59d0131 1388 withargs => \%withargs,
9fe2bb77
RL		 1389 builddir => abs2rel($buildd, $blddir),
1390 sourcedir => abs2rel($sourced, $blddir),
1391 buildtop => abs2rel($blddir, $blddir),
1392 sourcetop => abs2rel($srcdir, $blddir) },
1393 DELIMITERS => [ "{-", "-}" ]);
1394
1395 # The top item of this stack has the following values
1396 # -2 positive already run and we found ELSE (following ELSIF should fail)
1397 # -1 positive already run (skip until ENDIF)
1398 # 0 negatives so far (if we're at a condition, check it)
1399 # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
1400 # 2 positive ELSE (following ELSIF should fail)
1401 my @skip = ();
1402 collect_information(
1403 collect_from_array([ @text ],
1404 qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
1405 $l1 =~ s/\\$//; $l1.$l2 }),
1406 # Info we're looking for
1407 qr/^\s*IF\[((?:\\.|[^\\\]])*)\]\s*$/
635bd409 1408 => sub {
c5798e0e 1409 if (! @skip || $skip[$#skip] > 0) {
635bd409
RL		 1410 push @skip, !! $1;
1411 } else {
1412 push @skip, -1;
1413 }
1414 },
9fe2bb77
RL		 1415 qr/^\s*ELSIF\[((?:\\.|[^\\\]])*)\]\s*$/
1416 => sub { die "ELSIF out of scope" if ! @skip;
1417 die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
1418 $skip[$#skip] = -1 if $skip[$#skip] != 0;
1419 $skip[$#skip] = !! $1
1420 if $skip[$#skip] == 0; },
1421 qr/^\s*ELSE\s*$/
1422 => sub { die "ELSE out of scope" if ! @skip;
1423 $skip[$#skip] = -2 if $skip[$#skip] != 0;
1424 $skip[$#skip] = 2 if $skip[$#skip] == 0; },
1425 qr/^\s*ENDIF\s*$/
1426 => sub { die "ENDIF out of scope" if ! @skip;
1427 pop @skip; },
1428 qr/^\s*PROGRAMS\s*=\s*(.*)\s*$/
ce959812 1429 => sub { push @programs, tokenize($1)
9fe2bb77
RL		 1430 if !@skip || $skip[$#skip] > 0 },
1431 qr/^\s*LIBS\s*=\s*(.*)\s*$/
ce959812 1432 => sub { push @libraries, tokenize($1)
9fe2bb77
RL		 1433 if !@skip || $skip[$#skip] > 0 },
1434 qr/^\s*ENGINES\s*=\s*(.*)\s*$/
ce959812 1435 => sub { push @engines, tokenize($1)
9fe2bb77
RL		 1436 if !@skip || $skip[$#skip] > 0 },
1437 qr/^\s*SCRIPTS\s*=\s*(.*)\s*$/
ce959812 1438 => sub { push @scripts, tokenize($1)
9fe2bb77
RL		 1439 if !@skip || $skip[$#skip] > 0 },
1440 qr/^\s*EXTRA\s*=\s*(.*)\s*$/
ce959812 1441 => sub { push @extra, tokenize($1)
9fe2bb77 1442 if !@skip || $skip[$#skip] > 0 },
8a67946e 1443 qr/^\s*OVERRIDES\s*=\s*(.*)\s*$/
ce959812 1444 => sub { push @overrides, tokenize($1)
8a67946e 1445 if !@skip || $skip[$#skip] > 0 },
9fe2bb77
RL		 1446
1447 qr/^\s*ORDINALS\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/,
ce959812 1448 => sub { push @{$ordinals{$1}}, tokenize($2)
9fe2bb77
RL		 1449 if !@skip || $skip[$#skip] > 0 },
1450 qr/^\s*SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1451 => sub { push @{$sources{$1}}, tokenize($2)
9fe2bb77 1452 if !@skip || $skip[$#skip] > 0 },
2a08d1a0 1453 qr/^\s*SHARED_SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1454 => sub { push @{$shared_sources{$1}}, tokenize($2)
2a08d1a0 1455 if !@skip || $skip[$#skip] > 0 },
9fe2bb77 1456 qr/^\s*INCLUDE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1457 => sub { push @{$includes{$1}}, tokenize($2)
9fe2bb77 1458 if !@skip || $skip[$#skip] > 0 },
4f858293 1459 qr/^\s*DEPEND\[((?:\\.|[^\\\]])*)\]\s*=\s*(.*)\s*$/
ce959812 1460 => sub { push @{$depends{$1}}, tokenize($2)
9fe2bb77 1461 if !@skip || $skip[$#skip] > 0 },
ae4c7450
RL		 1462 qr/^\s*GENERATE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1463 => sub { push @{$generate{$1}}, $2
1464 if !@skip || $skip[$#skip] > 0 },
9fe2bb77 1465 qr/^\s*RENAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1466 => sub { push @{$renames{$1}}, tokenize($2)
9fe2bb77
RL		 1467 if !@skip || $skip[$#skip] > 0 },
1468 qr/^\s*SHARED_NAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1469 => sub { push @{$sharednames{$1}}, tokenize($2)
9fe2bb77
RL		 1470 if !@skip || $skip[$#skip] > 0 },
1471 qr/^\s*BEGINRAW\[((?:\\.|[^\\\]])+)\]\s*$/
1472 => sub {
1473 my $lineiterator = shift;
1474 my $target_kind = $1;
1475 while (defined $lineiterator->()) {
04f171c0 1476 s|\R$||;
9fe2bb77
RL		 1477 if (/^\s*ENDRAW\[((?:\\.|[^\\\]])+)\]\s*$/) {
1478 die "ENDRAW doesn't match BEGINRAW"
1479 if $1 ne $target_kind;
1480 last;
1481 }
1482 next if @skip && $skip[$#skip] <= 0;
1483 push @rawlines, $_
1484 if ($target_kind eq $target{build_file}
ddf1847d 1485 || $target_kind eq $target{build_file}."(".$builder_platform.")");
9fe2bb77
RL		 1486 }
1487 },
1488 qr/^(?:#.*|\s*)$/ => sub { },
2b6b606c
RL		 1489 "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" },
1490 "BEFORE" => sub {
1491 if ($buildinfo_debug) {
1492 print STDERR "DEBUG: Parsing ",join(" ", @_),"\n";
1493 print STDERR "DEBUG: ... before parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1494 }
1495 },
1496 "AFTER" => sub {
1497 if ($buildinfo_debug) {
1498 print STDERR "DEBUG: .... after parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1499 }
1500 },
9fe2bb77
RL		 1501 );
1502 die "runaway IF?" if (@skip);
1503
1504 foreach (keys %renames) {
1505 die "$_ renamed to more than one thing: "
1506 ,join(" ", @{$renames{$_}}),"\n"
1507 if scalar @{$renames{$_}} > 1;
2e963849
RL		 1508 my $dest = cleanfile($buildd, $_, $blddir);
1509 my $to = cleanfile($buildd, $renames{$_}->[0], $blddir);
9fe2bb77
RL		 1510 die "$dest renamed to more than one thing: "
1511 ,$unified_info{rename}->{$dest}, $to
1512 unless !defined($unified_info{rename}->{$dest})
1513 or $unified_info{rename}->{$dest} eq $to;
1514 $unified_info{rename}->{$dest} = $to;
1515 }
1516
1517 foreach (@programs) {
2e963849 1518 my $program = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1519 if ($unified_info{rename}->{$program}) {
1520 $program = $unified_info{rename}->{$program};
1521 }
1522 $unified_info{programs}->{$program} = 1;
1523 }
1524
1525 foreach (@libraries) {
2e963849 1526 my $library = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1527 if ($unified_info{rename}->{$library}) {
1528 $library = $unified_info{rename}->{$library};
1529 }
1530 $unified_info{libraries}->{$library} = 1;
1531 }
1532
343ec2b0 1533 die <<"EOF" if scalar @engines and !$config{dynamic_engines};
19ab5790 1534ENGINES can only be used if configured with 'dynamic-engine'.
9fe2bb77
RL		 1535This is usually a fault in a build.info file.
1536EOF
1537 foreach (@engines) {
2e963849 1538 my $library = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1539 if ($unified_info{rename}->{$library}) {
1540 $library = $unified_info{rename}->{$library};
1541 }
1542 $unified_info{engines}->{$library} = 1;
1543 }
1544
1545 foreach (@scripts) {
2e963849 1546 my $script = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1547 if ($unified_info{rename}->{$script}) {
1548 $script = $unified_info{rename}->{$script};
1549 }
1550 $unified_info{scripts}->{$script} = 1;
1551 }
1552
1553 foreach (@extra) {
2e963849 1554 my $extra = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1555 $unified_info{extra}->{$extra} = 1;
1556 }
1557
8a67946e
RL		 1558 foreach (@overrides) {
1559 my $override = cleanfile($buildd, $_, $blddir);
1560 $unified_info{overrides}->{$override} = 1;
1561 }
1562
9fe2bb77
RL		 1563 push @{$unified_info{rawlines}}, @rawlines;
1564
84af1bae 1565 unless ($disabled{shared}) {
9fe2bb77
RL		 1566 # Check sharednames.
1567 foreach (keys %sharednames) {
2e963849 1568 my $dest = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1569 if ($unified_info{rename}->{$dest}) {
1570 $dest = $unified_info{rename}->{$dest};
1571 }
1572 die "shared_name for $dest with multiple values: "
1573 ,join(" ", @{$sharednames{$_}}),"\n"
1574 if scalar @{$sharednames{$_}} > 1;
2e963849 1575 my $to = cleanfile($buildd, $sharednames{$_}->[0], $blddir);
9fe2bb77
RL		 1576 die "shared_name found for a library $dest that isn't defined\n"
1577 unless $unified_info{libraries}->{$dest};
1578 die "shared_name for $dest with multiple values: "
1579 ,$unified_info{sharednames}->{$dest}, ", ", $to
1580 unless !defined($unified_info{sharednames}->{$dest})
1581 or $unified_info{sharednames}->{$dest} eq $to;
1582 $unified_info{sharednames}->{$dest} = $to;
1583 }
1584
1585 # Additionally, we set up sharednames for libraries that don't
1586 # have any, as themselves.
1587 foreach (keys %{$unified_info{libraries}}) {
1588 if (!defined $unified_info{sharednames}->{$_}) {
1589 $unified_info{sharednames}->{$_} = $_
1590 }
1591 }
1592 }
1593
1594 foreach (keys %ordinals) {
1595 my $dest = $_;
2e963849 1596 my $ddest = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1597 if ($unified_info{rename}->{$ddest}) {
1598 $ddest = $unified_info{rename}->{$ddest};
1599 }
1600 foreach (@{$ordinals{$dest}}) {
1601 my %known_ordinals =
1602 (
1603 crypto =>
6928b617 1604 cleanfile($sourced, catfile("util", "libcrypto.num"), $blddir),
9fe2bb77 1605 ssl =>
6928b617 1606 cleanfile($sourced, catfile("util", "libssl.num"), $blddir)
9fe2bb77
RL		 1607 );
1608 my $o = $known_ordinals{$_};
1609 die "Ordinals for $ddest defined more than once\n"
1610 if $unified_info{ordinals}->{$ddest};
1611 $unified_info{ordinals}->{$ddest} = [ $_, $o ];
1612 }
1613 }
1614
1615 foreach (keys %sources) {
1616 my $dest = $_;
2e963849 1617 my $ddest = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1618 if ($unified_info{rename}->{$ddest}) {
1619 $ddest = $unified_info{rename}->{$ddest};
1620 }
1621 foreach (@{$sources{$dest}}) {
2e963849 1622 my $s = cleanfile($sourced, $_, $blddir);
9fe2bb77
RL		 1623
1624 # If it isn't in the source tree, we assume it's generated
1625 # in the build tree
1626 if (! -f $s) {
2e963849 1627 $s = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1628 }
1629 # We recognise C and asm files
1630 if ($s =~ /\.[csS]\b$/) {
1631 (my $o = $_) =~ s/\.[csS]\b$/.o/;
2e963849 1632 $o = cleanfile($buildd, $o, $blddir);
9fe2bb77
RL		 1633 $unified_info{sources}->{$ddest}->{$o} = 1;
1634 $unified_info{sources}->{$o}->{$s} = 1;
1635 } else {
1636 $unified_info{sources}->{$ddest}->{$s} = 1;
1637 }
1638 }
1639 }
1640
2a08d1a0
RL		 1641 foreach (keys %shared_sources) {
1642 my $dest = $_;
1643 my $ddest = cleanfile($buildd, $_, $blddir);
1644 if ($unified_info{rename}->{$ddest}) {
1645 $ddest = $unified_info{rename}->{$ddest};
1646 }
1647 foreach (@{$shared_sources{$dest}}) {
1648 my $s = cleanfile($sourced, $_, $blddir);
1649
1650 # If it isn't in the source tree, we assume it's generated
1651 # in the build tree
1652 if (! -f $s) {
1653 $s = cleanfile($buildd, $_, $blddir);
1654 }
1655 # We recognise C and asm files
1656 if ($s =~ /\.[csS]\b$/) {
1657 (my $o = $_) =~ s/\.[csS]\b$/.o/;
1658 $o = cleanfile($buildd, $o, $blddir);
1659 $unified_info{shared_sources}->{$ddest}->{$o} = 1;
1660 $unified_info{sources}->{$o}->{$s} = 1;
1661 } else {
1662 die "unrecognised source file type for shared library: $s\n";
1663 }
1664 }
1665 }
1666
ae4c7450
RL		 1667 foreach (keys %generate) {
1668 my $dest = $_;
1669 my $ddest = cleanfile($buildd, $_, $blddir);
1670 if ($unified_info{rename}->{$ddest}) {
1671 $ddest = $unified_info{rename}->{$ddest};
1672 }
1673 die "more than one generator for $dest: "
1674 ,join(" ", @{$generate{$_}}),"\n"
1675 if scalar @{$generate{$_}} > 1;
1676 my @generator = split /\s+/, $generate{$dest}->[0];
1677 $generator[0] = cleanfile($sourced, $generator[0], $blddir),
1678 $unified_info{generate}->{$ddest} = [ @generator ];
1679 }
1680
9fe2bb77
RL		 1681 foreach (keys %depends) {
1682 my $dest = $_;
4f858293 1683 my $ddest = $dest eq "" ? "" : cleanfile($sourced, $_, $blddir);
8d34daf0
RL		 1684
1685 # If the destination doesn't exist in source, it can only be
1686 # a generated file in the build tree.
4f858293 1687 if ($ddest ne "" && ! -f $ddest) {
8d34daf0
RL		 1688 $ddest = cleanfile($buildd, $_, $blddir);
1689 if ($unified_info{rename}->{$ddest}) {
1690 $ddest = $unified_info{rename}->{$ddest};
1691 }
9fe2bb77
RL		 1692 }
1693 foreach (@{$depends{$dest}}) {
2e963849 1694 my $d = cleanfile($sourced, $_, $blddir);
9fe2bb77 1695
e737d7b1
RL		 1696 # If we know it's generated, or assume it is because we can't
1697 # find it in the source tree, we set file we depend on to be
1698 # in the build tree rather than the source tree, and assume
1699 # and that there are lines to build it in a BEGINRAW..ENDRAW
1700 # section or in the Makefile template.
1701 if (! -f $d
da1f2104
RL		 1702 || (grep { $d eq $_ }
1703 map { cleanfile($srcdir, $_, $blddir) }
4f858293 1704 grep { /\.h$/ } keys %{$unified_info{generate}})) {
2e963849 1705 $d = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1706 }
1707 # Take note if the file to depend on is being renamed
1708 if ($unified_info{rename}->{$d}) {
1709 $d = $unified_info{rename}->{$d};
1710 }
1711 $unified_info{depends}->{$ddest}->{$d} = 1;
8d34daf0
RL		 1712 # If we depend on a header file or a perl module, let's make
1713 # sure it can get included
4f858293 1714 if ($dest ne "" && $d =~ /\.(h|pm)$/) {
9fe2bb77
RL		 1715 my $i = dirname($d);
1716 push @{$unified_info{includes}->{$ddest}}, $i
1717 unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}};
1718 }
1719 }
1720 }
1721
1722 foreach (keys %includes) {
1723 my $dest = $_;
8d34daf0
RL		 1724 my $ddest = cleanfile($sourced, $_, $blddir);
1725
1726 # If the destination doesn't exist in source, it can only be
1727 # a generated file in the build tree.
1728 if (! -f $ddest) {
1729 $ddest = cleanfile($buildd, $_, $blddir);
1730 if ($unified_info{rename}->{$ddest}) {
1731 $ddest = $unified_info{rename}->{$ddest};
1732 }
9fe2bb77
RL		 1733 }
1734 foreach (@{$includes{$dest}}) {
2e963849 1735 my $i = cleandir($sourced, $_, $blddir);
9fe2bb77
RL		 1736 push @{$unified_info{includes}->{$ddest}}, $i
1737 unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}};
1738 }
1739 }
1740 }
1741
1742 ### Make unified_info a bit more efficient
1743 # One level structures
8a67946e 1744 foreach (("programs", "libraries", "engines", "scripts", "extra", "overrides")) {
9fe2bb77
RL		 1745 $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
1746 }
1747 # Two level structures
2a08d1a0 1748 foreach my $l1 (("sources", "shared_sources", "ldadd", "depends")) {
9fe2bb77
RL		 1749 foreach my $l2 (sort keys %{$unified_info{$l1}}) {
1750 $unified_info{$l1}->{$l2} =
1751 [ sort keys %{$unified_info{$l1}->{$l2}} ];
1752 }
1753 }
1754}
1755
1756# For the schemes that need it, we provide the old *_obj configs
1757# from the *_asm_obj ones
3a55c92b 1758foreach (grep /_(asm|aux)_src$/, keys %target) {
9fe2bb77 1759 my $src = $_;
3a55c92b 1760 (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
9fe2bb77
RL		 1761 ($target{$obj} = $target{$src}) =~ s/\.[csS]\b/.o/g;
1762}
1763
291e94df
RL		 1764# Write down our configuration where it fits #########################
1765
1766open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
1767print OUT <<"EOF";
1768package configdata;
1769
1770use strict;
1771use warnings;
1772
1773use Exporter;
1774#use vars qw(\@ISA \@EXPORT);
1775our \@ISA = qw(Exporter);
3850f8cb 1776our \@EXPORT = qw(\%config \%target \%disabled \%withargs \%unified_info \@disablables);
291e94df
RL		 1777
1778EOF
1779print OUT "our %config = (\n";
1780foreach (sort keys %config) {
1781 if (ref($config{$_}) eq "ARRAY") {
1782 print OUT " ", $_, " => [ ", join(", ",
1783 map { quotify("perl", $_) }
1784 @{$config{$_}}), " ],\n";
1785 } else {
1786 print OUT " ", $_, " => ", quotify("perl", $config{$_}), ",\n"
1787 }
1788}
1789print OUT <<"EOF";
1790);
1791
1792EOF
1793print OUT "our %target = (\n";
1794foreach (sort keys %target) {
1795 if (ref($target{$_}) eq "ARRAY") {
1796 print OUT " ", $_, " => [ ", join(", ",
1797 map { quotify("perl", $_) }
1798 @{$target{$_}}), " ],\n";
1799 } else {
1800 print OUT " ", $_, " => ", quotify("perl", $target{$_}), ",\n"
1801 }
1802}
1803print OUT <<"EOF";
1804);
1805
96d2d7bc
RL		 1806EOF
1807print OUT "our \%available_protocols = (\n";
1808print OUT " tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n";
1809print OUT " dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n";
1810print OUT <<"EOF";
1811);
1812
3850f8cb
RL		 1813EOF
1814print OUT "our \@disablables = (\n";
1815foreach (@disablables) {
1816 print OUT " ", quotify("perl", $_), ",\n";
1817}
1818print OUT <<"EOF";
1819);
1820
96d2d7bc
RL		 1821EOF
1822print OUT "our \%disabled = (\n";
1823foreach (sort keys %disabled) {
1824 print OUT " ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n";
1825}
1826print OUT <<"EOF";
1827);
1828
291e94df 1829EOF
107b5792
RL		 1830print OUT "our %withargs = (\n";
1831foreach (sort keys %withargs) {
1832 if (ref($withargs{$_}) eq "ARRAY") {
1833 print OUT " ", $_, " => [ ", join(", ",
1834 map { quotify("perl", $_) }
1835 @{$withargs{$_}}), " ],\n";
1836 } else {
1837 print OUT " ", $_, " => ", quotify("perl", $withargs{$_}), ",\n"
1838 }
1839}
1840print OUT <<"EOF";
1841);
edd4d402 1842
107b5792 1843EOF
ddf1847d 1844if ($builder eq "unified") {
9fe2bb77
RL		 1845 my $recurse;
1846 $recurse = sub {
1847 my $indent = shift;
1848 foreach (@_) {
1849 if (ref $_ eq "ARRAY") {
1850 print OUT " "x$indent, "[\n";
1851 foreach (@$_) {
1852 $recurse->($indent + 4, $_);
1853 }
1854 print OUT " "x$indent, "],\n";
1855 } elsif (ref $_ eq "HASH") {
1856 my %h = %$_;
1857 print OUT " "x$indent, "{\n";
1858 foreach (sort keys %h) {
1859 if (ref $h{$_} eq "") {
1860 print OUT " "x($indent + 4), quotify("perl", $_), " => ", quotify("perl", $h{$_}), ",\n";
1861 } else {
1862 print OUT " "x($indent + 4), quotify("perl", $_), " =>\n";
1863 $recurse->($indent + 8, $h{$_});
1864 }
1865 }
1866 print OUT " "x$indent, "},\n";
1867 } else {
1868 print OUT " "x$indent, quotify("perl", $_), ",\n";
1869 }
1870 }
1871 };
1872 print OUT "our %unified_info = (\n";
1873 foreach (sort keys %unified_info) {
1874 if (ref $unified_info{$_} eq "") {
1875 print OUT " "x4, quotify("perl", $_), " => ", quotify("perl", $unified_info{$_}), ",\n";
1876 } else {
1877 print OUT " "x4, quotify("perl", $_), " =>\n";
1878 $recurse->(8, $unified_info{$_});
1879 }
1880 }
1881 print OUT <<"EOF";
1882);
1883
1884EOF
1885}
1886print OUT "1;\n";
d02b48c6 1887close(OUT);
f2d4be3b 1888
9fe2bb77 1889
f58a0acb 1890print "CC =$config{cross_compile_prefix}$target{cc}\n";
2952b9b8 1891print "CFLAG =$target{cflags} $config{cflags}\n";
63ee7129 1892print "SHARED_CFLAG =$target{shared_cflag}\n";
2952b9b8 1893print "DEFINES =",join(" ", @{$target{defines}}, @{$config{defines}}),"\n";
940a09ba
RL		 1894print "LFLAG =$target{lflags}\n";
1895print "PLIB_LFLAG =$target{plib_lflags}\n";
2952b9b8 1896print "EX_LIBS =$target{ex_libs} $config{ex_libs}\n";
b756967d 1897print "APPS_OBJ =$target{apps_obj}\n";
291e94df 1898print "CPUID_OBJ =$target{cpuid_obj}\n";
b756967d 1899print "UPLINK_OBJ =$target{uplink_obj}\n";
291e94df
RL		 1900print "BN_ASM =$target{bn_obj}\n";
1901print "EC_ASM =$target{ec_obj}\n";
1902print "DES_ENC =$target{des_obj}\n";
1903print "AES_ENC =$target{aes_obj}\n";
1904print "BF_ENC =$target{bf_obj}\n";
1905print "CAST_ENC =$target{cast_obj}\n";
1906print "RC4_ENC =$target{rc4_obj}\n";
1907print "RC5_ENC =$target{rc5_obj}\n";
1908print "MD5_OBJ_ASM =$target{md5_obj}\n";
1909print "SHA1_OBJ_ASM =$target{sha1_obj}\n";
1910print "RMD160_OBJ_ASM=$target{rmd160_obj}\n";
1911print "CMLL_ENC =$target{cmll_obj}\n";
1912print "MODES_OBJ =$target{modes_obj}\n";
f0bd4686 1913print "PADLOCK_OBJ =$target{padlock_obj}\n";
291e94df
RL		 1914print "CHACHA_ENC =$target{chacha_obj}\n";
1915print "POLY1305_OBJ =$target{poly1305_obj}\n";
2d0b4412 1916print "BLAKE2_OBJ =$target{blake2_obj}\n";
7d130f68 1917print "PROCESSOR =$config{processor}\n";
f58a0acb
AP		 1918print "RANLIB =", $target{ranlib} eq '$(CROSS_COMPILE)ranlib' ?
1919 "$config{cross_compile_prefix}ranlib" :
1920 "$target{ranlib}", "\n";
291e94df
RL		 1921print "ARFLAGS =$target{arflags}\n";
1922print "PERL =$config{perl}\n";
f0bd4686 1923print "\n";
7d130f68
RL		 1924print "SIXTY_FOUR_BIT_LONG mode\n" if $config{b64l};
1925print "SIXTY_FOUR_BIT mode\n" if $config{b64};
1926print "THIRTY_TWO_BIT mode\n" if $config{b32};
7d130f68 1927print "BN_LLONG mode\n" if $config{bn_ll};
01d99976 1928print "RC4 uses $config{rc4_int}\n" if $config{rc4_int} ne $def_int;
cba5068d 1929
88087414 1930my %builders = (
9fe2bb77 1931 unified => sub {
ddf1847d
RL		 1932 run_dofile(catfile($blddir, $target{build_file}),
1933 $config{build_file_template},
1934 catfile($srcdir, "Configurations", "common.tmpl"));
9fe2bb77 1935 },
88087414
RL		 1936 );
1937
ddf1847d 1938$builders{$builder}->($builder_platform, @builder_opts);
fce0ba5f 1939
76ffb43d 1940print <<"EOF";
63d3f44a 1941
89ec98e0 1942Configured for $target.
63d3f44a 1943EOF
5f8d5c96 1944
9c62a279 1945print <<"EOF" if ($disabled{threads} eq "unavailable");
5f8d5c96
BM		 1946
1947The library could not be configured for supporting multi-threaded
1948applications as the compiler options required on this system are not known.
ff1b7e09 1949See file INSTALL for details if you need multi-threading.
ec577822
BM		 1950EOF
1951
76ffb43d 1952print <<"EOF" if ($no_shared_warn);
2964ba8c 1953
ae48242c
RL		 1954The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
1955platform, so we will pretend you gave the option 'no-pic', which also disables
1956'shared' and 'dynamic-engine'. If you know how to implement shared libraries
1957or position independent code, please let us know (but please first make sure
1958you have tried with a current version of OpenSSL).
2e31ef03
RS		 1959EOF
1960
ddc606c9
RL		 1961print <<"EOF" if (-f catfile($srcdir, "configdata.pm") && $srcdir ne $blddir);
1962
1963WARNING: there are indications that another build was made in the source
1964directory. This build may have picked up artifacts from that build, the
1965safest course of action is to clean the source directory and redo this
1966configuration.
1967EOF
1968
d02b48c6
RE		 1969exit(0);
1970
bd5192b1
RL		 1971######################################################################
1972#
1973# Helpers and utility functions
1974#
1975
1976# Configuration file reading #########################################
1977
1f2e1cd5
RL		 1978# Note: All of the helper functions are for lazy evaluation. They all
1979# return a CODE ref, which will return the intended value when evaluated.
1980# Thus, whenever there's mention of a returned value, it's about that
1981# intended value.
1982
bd5192b1 1983# Helper function to implement conditional inheritance depending on the
00b0d663 1984# value of $disabled{asm}. Used in inherit_from values as follows:
bd5192b1
RL		 1985#
1986# inherit_from => [ "template", asm("asm_tmpl") ]
1987#
1988sub asm {
1989 my @x = @_;
1990 sub {
00b0d663 1991 $disabled{asm} ? () : @x;
bd5192b1
RL		 1992 }
1993}
1994
1f2e1cd5
RL		 1995# Helper function to implement conditional value variants, with a default
1996# plus additional values based on the value of $config{build_type}.
1997# Arguments are given in hash table form:
1998#
1999# picker(default => "Basic string: ",
2000# debug => "debug",
2001# release => "release")
2002#
2003# When configuring with --debug, the resulting string will be
2004# "Basic string: debug", and when not, it will be "Basic string: release"
2005#
2006# This can be used to create variants of sets of flags according to the
2007# build type:
2008#
2009# cflags => picker(default => "-Wall",
2010# debug => "-g -O0",
2011# release => "-O3")
2012#
2013sub picker {
2014 my %opts = @_;
2015 return sub { add($opts{default} || (),
2016 $opts{$config{build_type}} || ())->(); }
2017}
2018
2019# Helper function to combine several values of different types into one.
2020# This is useful if you want to combine a string with the result of a
2021# lazy function, such as:
2022#
2023# cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
2024#
2025sub combine {
2026 my @stuff = @_;
2027 return sub { add(@stuff)->(); }
2028}
2029
2030# Helper function to implement conditional values depending on the value
2031# of $disabled{threads}. Can be used as follows:
2032#
2033# cflags => combine("-Wall", threads("-pthread"))
2034#
2035sub threads {
2036 my @flags = @_;
2037 return sub { add($disabled{threads} ? () : @flags)->(); }
2038}
2039
2040
2041
9c62a279 2042our $add_called = 0;
88087414
RL		 2043# Helper function to implement adding values to already existing configuration
2044# values. It handles elements that are ARRAYs, CODEs and scalars
2045sub _add {
2046 my $separator = shift;
2047
bcb1977b
RL		 2048 # If there's any ARRAY in the collection of values OR the separator
2049 # is undef, we will return an ARRAY of combined values, otherwise a
2050 # string of joined values with $separator as the separator.
2051 my $found_array = !defined($separator);
88087414
RL		 2052
2053 my @values =
2054 map {
b0b92a5b
RL		 2055 my $res = $_;
2056 while (ref($res) eq "CODE") {
2057 $res = $res->();
2058 }
2059 if (defined($res)) {
2060 if (ref($res) eq "ARRAY") {
2061 $found_array = 1;
2062 @$res;
2063 } else {
2064 $res;
2065 }
88087414 2066 } else {
b0b92a5b 2067 ();
88087414
RL		 2068 }
2069 } (@_);
2070
9c62a279
RL		 2071 $add_called = 1;
2072
88087414
RL		 2073 if ($found_array) {
2074 [ @values ];
2075 } else {
b0b92a5b 2076 join($separator, grep { defined($_) && $_ ne "" } @values);
88087414
RL		 2077 }
2078}
2079sub add_before {
bdcd83e1
RL		 2080 my $separator = " ";
2081 if (ref($_[$#_]) eq "HASH") {
2082 my $opts = pop;
2083 $separator = $opts->{separator};
2084 }
88087414
RL		 2085 my @x = @_;
2086 sub { _add($separator, @x, @_) };
2087}
2088sub add {
bdcd83e1
RL		 2089 my $separator = " ";
2090 if (ref($_[$#_]) eq "HASH") {
2091 my $opts = pop;
2092 $separator = $opts->{separator};
2093 }
88087414
RL		 2094 my @x = @_;
2095 sub { _add($separator, @_, @x) };
2096}
2097
bd5192b1
RL		 2098# configuration reader, evaluates the input file as a perl script and expects
2099# it to fill %targets with target configurations. Those are then added to
2100# %table.
2101sub read_config {
2102 my $fname = shift;
2103 open(CONFFILE, "< $fname")
2104 or die "Can't open configuration file '$fname'!\n";
2105 my $x = $/;
2106 undef $/;
2107 my $content = <CONFFILE>;
2108 $/ = $x;
2109 close(CONFFILE);
2110 my %targets = ();
2111 {
2112 local %table = %::table; # Protect %table from tampering
2113
2114 eval $content;
2115 warn $@ if $@;
2116 }
2117
2118 # For each target, check that it's configured with a hash table.
2119 foreach (keys %targets) {
2120 if (ref($targets{$_}) ne "HASH") {
2121 if (ref($targets{$_}) eq "") {
2122 warn "Deprecated target configuration for $_, ignoring...\n";
2123 } else {
2124 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
2125 }
2126 delete $targets{$_};
2127 }
2128 }
2129
2130 %table = (%table, %targets);
2131
2132}
2133
8483a003
F		 2134# configuration resolver. Will only resolve all the lazy evaluation
2135# codeblocks for the chosen target and all those it inherits from,
bd5192b1
RL		 2136# recursively
2137sub resolve_config {
2138 my $target = shift;
2139 my @breadcrumbs = @_;
2140
c4718849 2141# my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
9c62a279 2142
bd5192b1
RL		 2143 if (grep { $_ eq $target } @breadcrumbs) {
2144 die "inherit_from loop! target backtrace:\n "
2145 ,$target,"\n ",join("\n ", @breadcrumbs),"\n";
2146 }
2147
2148 if (!defined($table{$target})) {
2149 warn "Warning! target $target doesn't exist!\n";
2150 return ();
2151 }
2152 # Recurse through all inheritances. They will be resolved on the
2153 # fly, so when this operation is done, they will all just be a
2154 # bunch of attributes with string values.
2155 # What we get here, though, are keys with references to lists of
2156 # the combined values of them all. We will deal with lists after
2157 # this stage is done.
2158 my %combined_inheritance = ();
2159 if ($table{$target}->{inherit_from}) {
2160 my @inherit_from =
2161 map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
2162 foreach (@inherit_from) {
2163 my %inherited_config = resolve_config($_, $target, @breadcrumbs);
2164
2165 # 'template' is a marker that's considered private to
2166 # the config that had it.
2167 delete $inherited_config{template};
2168
2110febb 2169 foreach (keys %inherited_config) {
bd5192b1
RL		 2170 if (!$combined_inheritance{$_}) {
2171 $combined_inheritance{$_} = [];
2172 }
2173 push @{$combined_inheritance{$_}}, $inherited_config{$_};
2110febb 2174 }
bd5192b1
RL		 2175 }
2176 }
2177
2178 # We won't need inherit_from in this target any more, since we've
2179 # resolved all the inheritances that lead to this
2180 delete $table{$target}->{inherit_from};
2181
2182 # Now is the time to deal with those lists. Here's the place to
2183 # decide what shall be done with those lists, all based on the
2184 # values of the target we're currently dealing with.
2185 # - If a value is a coderef, it will be executed with the list of
2186 # inherited values as arguments.
2187 # - If the corresponding key doesn't have a value at all or is the
8483a003 2188 # empty string, the inherited value list will be run through the
bd5192b1
RL		 2189 # default combiner (below), and the result becomes this target's
2190 # value.
2191 # - Otherwise, this target's value is assumed to be a string that
2192 # will simply override the inherited list of values.
a26d8be9 2193 my $default_combiner = add();
bd5192b1
RL		 2194
2195 my %all_keys =
2196 map { $_ => 1 } (keys %combined_inheritance,
2197 keys %{$table{$target}});
b0b92a5b
RL		 2198
2199 sub process_values {
2200 my $object = shift;
2201 my $inherited = shift; # Always a [ list ]
2202 my $target = shift;
2203 my $entry = shift;
2204
9c62a279
RL		 2205 $add_called = 0;
2206
b0b92a5b
RL		 2207 while(ref($object) eq "CODE") {
2208 $object = $object->(@$inherited);
2209 }
2210 if (!defined($object)) {
2211 return ();
2212 }
2213 elsif (ref($object) eq "ARRAY") {
9c62a279 2214 local $add_called; # To make sure recursive calls don't affect it
b0b92a5b
RL		 2215 return [ map { process_values($_, $inherited, $target, $entry) }
2216 @$object ];
2217 } elsif (ref($object) eq "") {
2218 return $object;
2219 } else {
2220 die "cannot handle reference type ",ref($object)
2221 ," found in target ",$target," -> ",$entry,"\n";
2222 }
2223 }
2224
bd5192b1 2225 foreach (sort keys %all_keys) {
9c62a279 2226 my $previous = $combined_inheritance{$_};
bd5192b1
RL		 2227
2228 # Current target doesn't have a value for the current key?
2229 # Assign it the default combiner, the rest of this loop body
2230 # will handle it just like any other coderef.
2231 if (!exists $table{$target}->{$_}) {
2232 $table{$target}->{$_} = $default_combiner;
2233 }
2234
b0b92a5b
RL		 2235 $table{$target}->{$_} = process_values($table{$target}->{$_},
2236 $combined_inheritance{$_},
2237 $target, $_);
2238 unless(defined($table{$target}->{$_})) {
2239 delete $table{$target}->{$_};
2240 }
c4718849
RL		 2241# if ($extra_checks &&
2242# $previous && !($add_called || $previous ~~ $table{$target}->{$_})) {
2243# warn "$_ got replaced in $target\n";
2244# }
bd5192b1
RL		 2245 }
2246
2247 # Finally done, return the result.
2248 return %{$table{$target}};
2249}
2250
462ba4f6 2251sub usage
d02b48c6 2252 {
462ba4f6 2253 print STDERR $usage;
10a926c1 2254 print STDERR "\npick os/compiler from:\n";
1641cb60 2255 my $j=0;
6457ad15 2256 my $i;
10a926c1 2257 my $k=0;
6457ad15 2258 foreach $i (sort keys %table)
d02b48c6 2259 {
bd5192b1 2260 next if $table{$i}->{template};
462ba4f6 2261 next if $i =~ /^debug/;
10a926c1
UM		 2262 $k += length($i) + 1;
2263 if ($k > 78)
2264 {
2265 print STDERR "\n";
2266 $k=length($i);
2267 }
2268 print STDERR $i . " ";
462ba4f6
UM		 2269 }
2270 foreach $i (sort keys %table)
2271 {
bd5192b1 2272 next if $table{$i}->{template};
462ba4f6 2273 next if $i !~ /^debug/;
10a926c1
UM		 2274 $k += length($i) + 1;
2275 if ($k > 78)
2276 {
2277 print STDERR "\n";
2278 $k=length($i);
2279 }
2280 print STDERR $i . " ";
d02b48c6 2281 }
10a926c1 2282 print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
462ba4f6 2283 exit(1);
d02b48c6
RE		 2284 }
2285
01d99976 2286sub run_dofile
107b5792 2287{
107b5792 2288 my $out = shift;
9fe2bb77 2289 my @templates = @_;
107b5792 2290
ced2c2c5
RS		 2291 unlink $out || warn "Can't remove $out, $!"
2292 if -f $out;
9fe2bb77
RL		 2293 foreach (@templates) {
2294 die "Can't open $_, $!" unless -f $_;
2295 }
a3a08f81 2296 my $cmd = "$config{perl} \"-I.\" \"-Mconfigdata\" \"$dofile\" -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\"";
9fe2bb77
RL		 2297 #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
2298 system($cmd);
107b5792
RL		 2299 exit 1 if $? != 0;
2300 rename("$out.new", $out) || die "Can't rename $out.new, $!";
2301}
2302
656bbdc6
AP		 2303sub which
2304{
2305 my ($name)=@_;
2306
2307 if (eval { require IPC::Cmd; 1; }) {
2308 IPC::Cmd->import();
2309 return scalar IPC::Cmd::can_run($name);
2310 } else {
2311 # if there is $directories component in splitpath,
2312 # then it's not something to test with $PATH...
2313 return $name if (File::Spec->splitpath($name))[1];
2314
2315 foreach (File::Spec->path()) {
2316 my $fullpath = catfile($_, "$name$target{exe_extension}");
2317 if (-f $fullpath and -x $fullpath) {
2318 return $fullpath;
2319 }
2320 }
2321 }
2322}
2323
00ae96ca
RL		 2324# Configuration printer ##############################################
2325
2326sub print_table_entry
2327{
2328 my $target = shift;
2329 my %target = resolve_config($target);
2330 my $type = shift;
2331
2332 # Don't print the templates
2333 return if $target{template};
2334
2335 my @sequence = (
f0bd4686 2336 "sys_id",
00ae96ca
RL		 2337 "cc",
2338 "cflags",
bcb1977b 2339 "defines",
f0bd4686
RL		 2340 "unistd",
2341 "ld",
00ae96ca 2342 "lflags",
c86ddbe6 2343 "plib_lflags",
1740c162 2344 "ex_libs",
00ae96ca
RL		 2345 "bn_ops",
2346 "cpuid_obj",
2347 "bn_obj",
2348 "ec_obj",
2349 "des_obj",
2350 "aes_obj",
2351 "bf_obj",
2352 "md5_obj",
2353 "sha1_obj",
2354 "cast_obj",
2355 "rc4_obj",
2356 "rmd160_obj",
2357 "rc5_obj",
2358 "wp_obj",
2359 "cmll_obj",
2360 "modes_obj",
f0bd4686 2361 "padlock_obj",
9c62a279 2362 "thread_scheme",
00ae96ca
RL		 2363 "perlasm_scheme",
2364 "dso_scheme",
2365 "shared_target",
2366 "shared_cflag",
2367 "shared_ldflag",
64c443e3 2368 "shared_rcflag",
00ae96ca 2369 "shared_extension",
e987f9f2
RL		 2370 "shared_extension_simple",
2371 "shared_import_extension",
2372 "dso_extension",
f0bd4686
RL		 2373 "obj_extension",
2374 "exe_extension",
00ae96ca 2375 "ranlib",
f0bd4686 2376 "ar",
00ae96ca
RL		 2377 "arflags",
2378 "multilib",
f0bd4686 2379 "build_scheme",
00ae96ca
RL		 2380 );
2381
2382 if ($type eq "TABLE") {
2383 print "\n";
2384 print "*** $target\n";
cb212f23
RL		 2385 foreach (@sequence) {
2386 if (ref($target{$_}) eq "ARRAY") {
2387 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
2388 } else {
2389 printf "\$%-12s = %s\n", $_, $target{$_};
2390 }
2391 }
00ae96ca
RL		 2392 } elsif ($type eq "HASH") {
2393 my $largest =
2394 length((sort { length($a) <=> length($b) } @sequence)[-1]);
2395 print " '$target' => {\n";
2396 foreach (@sequence) {
2397 if ($target{$_}) {
cb212f23
RL		 2398 if (ref($target{$_}) eq "ARRAY") {
2399 print " '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
2400 } else {
2401 print " '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
2402 }
00ae96ca
RL		 2403 }
2404 }
2405 print " },\n";
2406 }
2407}
2408
2409# Utility routines ###################################################
2410
2e963849
RL		 2411# On VMS, if the given file is a logical name, File::Spec::Functions
2412# will consider it an absolute path. There are cases when we want a
2413# purely syntactic check without checking the environment.
2414sub isabsolute {
2415 my $file = shift;
2416
2417 # On non-platforms, we just use file_name_is_absolute().
2418 return file_name_is_absolute($file) unless $^O eq "VMS";
2419
2420 # If the file spec includes a device or a directpry spec,
2421 # file_name_is_absolute() is perfectly safe.
2422 return file_name_is_absolute($file) if $file =~ m|[:\[]|;
2423
2424 # Here, we know the given file spec isn't absolute
2425 return 0;
2426}
2427
ec182ef0
RL		 2428# Makes a directory absolute and cleans out /../ in paths like foo/../bar
2429# On some platforms, this uses rel2abs(), while on others, realpath() is used.
2430# realpath() requires that at least all path components except the last is an
2431# existing directory. On VMS, the last component of the directory spec must
2432# exist.
2433sub absolutedir {
2434 my $dir = shift;
2435
2436 # realpath() is quite buggy on VMS. It uses LIB$FID_TO_NAME, which
2437 # will return the volume name for the device, no matter what. Also,
2438 # it will return an incorrect directory spec if the argument is a
2439 # directory that doesn't exist.
2440 if ($^O eq "VMS") {
2441 return rel2abs($dir);
2442 }
2443
2444 # We use realpath() on Unix, since no other will properly clean out
2445 # a directory spec.
2446 use Cwd qw/realpath/;
2447
2448 return realpath($dir);
2449}
2450
fe05264e
RL		 2451sub quotify {
2452 my %processors = (
2453 perl => sub { my $x = shift;
2454 $x =~ s/([\\\$\@"])/\\$1/g;
2455 return '"'.$x.'"'; },
2456 );
2457 my $for = shift;
2458 my $processor =
2459 defined($processors{$for}) ? $processors{$for} : sub { shift; };
2460
2110febb 2461 return map { $processor->($_); } @_;
fe05264e 2462}
107b5792 2463
9fe2bb77
RL		 2464# collect_from_file($filename, $line_concat_cond_re, $line_concat)
2465# $filename is a file name to read from
2466# $line_concat_cond_re is a regexp detecting a line continuation ending
2467# $line_concat is a CODEref that takes care of concatenating two lines
2468sub collect_from_file {
2469 my $filename = shift;
2470 my $line_concat_cond_re = shift;
2471 my $line_concat = shift;
2472
2473 open my $fh, $filename || die "unable to read $filename: $!\n";
2474 return sub {
2475 my $saved_line = "";
2476 $_ = "";
2477 while (<$fh>) {
04f171c0 2478 s|\R$||;
9fe2bb77
RL		 2479 if (defined $line_concat) {
2480 $_ = $line_concat->($saved_line, $_);
2481 $saved_line = "";
2482 }
2483 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2484 $saved_line = $_;
2485 next;
2486 }
2487 return $_;
2488 }
2489 die "$filename ending with continuation line\n" if $_;
2490 close $fh;
2491 return undef;
2492 }
2493}
2494
2495# collect_from_array($array, $line_concat_cond_re, $line_concat)
2496# $array is an ARRAYref of lines
2497# $line_concat_cond_re is a regexp detecting a line continuation ending
2498# $line_concat is a CODEref that takes care of concatenating two lines
2499sub collect_from_array {
2500 my $array = shift;
2501 my $line_concat_cond_re = shift;
2502 my $line_concat = shift;
2503 my @array = (@$array);
2504
2505 return sub {
2506 my $saved_line = "";
2507 $_ = "";
2508 while (defined($_ = shift @array)) {
04f171c0 2509 s|\R$||;
9fe2bb77
RL		 2510 if (defined $line_concat) {
2511 $_ = $line_concat->($saved_line, $_);
2512 $saved_line = "";
2513 }
2514 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2515 $saved_line = $_;
2516 next;
2517 }
2518 return $_;
2519 }
2520 die "input text ending with continuation line\n" if $_;
2521 return undef;
2522 }
2523}
2524
2525# collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
2526# $lineiterator is a CODEref that delivers one line at a time.
107b5792
RL		 2527# All following arguments are regex/CODEref pairs, where the regexp detects a
2528# line and the CODEref does something with the result of the regexp.
2529sub collect_information {
9fe2bb77 2530 my $lineiterator = shift;
107b5792
RL		 2531 my %collectors = @_;
2532
9fe2bb77 2533 while(defined($_ = $lineiterator->())) {
04f171c0 2534 s|\R$||;
9fe2bb77 2535 my $found = 0;
2b6b606c
RL		 2536 if ($collectors{"BEFORE"}) {
2537 $collectors{"BEFORE"}->($_);
2538 }
9fe2bb77 2539 foreach my $re (keys %collectors) {
2b6b606c 2540 if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
9fe2bb77
RL		 2541 $collectors{$re}->($lineiterator);
2542 $found = 1;
2543 };
2544 }
2545 if ($collectors{"OTHERWISE"}) {
2546 $collectors{"OTHERWISE"}->($lineiterator, $_)
2547 unless $found || !defined $collectors{"OTHERWISE"};
2548 }
2b6b606c
RL		 2549 if ($collectors{"AFTER"}) {
2550 $collectors{"AFTER"}->($_);
2551 }
107b5792 2552 }
107b5792 2553}
ce959812
RL		 2554
2555# tokenize($line)
2556# $line is a line of text to split up into tokens
2557# returns a list of tokens
2558#
2559# Tokens are divided by spaces. If the tokens include spaces, they
2560# have to be quoted with single or double quotes. Double quotes
2561# inside a double quoted token must be escaped. Escaping is done
2562# with backslash.
2563# Basically, the same quoting rules apply for " and ' as in any
2564# Unix shell.
2565sub tokenize {
2566 my $line = my $debug_line = shift;
2567 my @result = ();
2568
2569 while ($line =~ s|^\s+||, $line ne "") {
2570 my $token = "";
2571 while ($line ne "" && $line !~ m|^\s|) {
2572 if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
2573 $token .= $1;
2574 $line = $';
2575 } elsif ($line =~ m/^'([^']*)'/) {
2576 $token .= $1;
2577 $line = $';
2578 } elsif ($line =~ m/^(\S+)/) {
2579 $token .= $1;
2580 $line = $';
2581 }
2582 }
2583 push @result, $token;
2584 }
2585
2586 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
2587 print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
2588 print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";
2589 }
2590 return @result;
2591}
A mirror of the official openssl repository