]> 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
segmentation fault with 'openssl s_client -prexit -keymatexport'
[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
90 # is not strictly standard-compliant and/or implementation-specifc,
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
VD		 146#
147# API compability name to version number mapping.
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
248$config{dirs} = [ "crypto", "ssl", "engines", "apps", "test", "tools" ];
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"}) {
c145d197 1049 push @{$config{dirs}}, "fuzz";
c38bb727
BL		 1050 $config{cflags} .= "-fsanitize-coverage=edge,indirect-calls ";
1051}
1052
f59d0131
KR		 1053unless ($disabled{"fuzz-afl"}) {
1054 push @{$config{dirs}}, "fuzz";
1055}
1056
c38bb727
BL		 1057unless ($disabled{asan}) {
1058 $config{cflags} .= "-fsanitize=address ";
1059}
1060
1061unless ($disabled{ubsan}) {
1062 # -DPEDANTIC or -fnosanitize=aligmnent may also be required on some
1063 # platforms.
1064 $config{cflags} .= "-fsanitize=undefined -fno-sanitize-recover=all ";
1065}
1066
65cc6d5c
RL		 1067unless ($disabled{"fuzz-libfuzzer"} && $disabled{"fuzz-afl"}
1068 && $disabled{asan} && $disabled{ubsan}) {
c38bb727
BL		 1069 $config{cflags} .= "-fno-omit-frame-pointer -g ";
1070}
c313e32a
AP		 1071#
1072# Platform fix-ups
1073#
ae48242c
RL		 1074
1075# This saves the build files from having to check
1076if ($disabled{pic})
1077 {
1078 $target{shared_cflag} = $target{shared_ldflag} =
1079 $target{shared_rcflag} = "";
1080 }
4f16039e
RL		 1081else
1082 {
1083 push @{$config{defines}}, "OPENSSL_PIC";
1084 }
ae48242c 1085
291e94df 1086if ($target{sys_id} ne "")
cf1b7d96 1087 {
642a6138 1088 push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
cf1b7d96
RL		 1089 }
1090
00b0d663 1091unless ($disabled{asm}) {
d2b2221a 1092 $target{cpuid_asm_src}=$table{DEFAULTS}->{cpuid_asm_src} if ($config{processor} eq "386");
9fe2bb77 1093 $target{bn_asm_src} =~ s/\w+-gf2m.c// if (defined($disabled{ec2m}));
f8c469de 1094
9e0724a1 1095 # bn-586 is the only one implementing bn_*_part_words
bcb1977b
RL		 1096 push @{$config{defines}}, "OPENSSL_BN_ASM_PART_WORDS" if ($target{bn_asm_src} =~ /bn-586/);
1097 push @{$config{defines}}, "OPENSSL_IA32_SSE2" if (!$no_sse2 && $target{bn_asm_src} =~ /86/);
dfeab068 1098
bcb1977b
RL		 1099 push @{$config{defines}}, "OPENSSL_BN_ASM_MONT" if ($target{bn_asm_src} =~ /-mont/);
1100 push @{$config{defines}}, "OPENSSL_BN_ASM_MONT5" if ($target{bn_asm_src} =~ /-mont5/);
1101 push @{$config{defines}}, "OPENSSL_BN_ASM_GF2m" if ($target{bn_asm_src} =~ /-gf2m/);
5ac7bde7 1102
107b5792 1103 if ($config{fips}) {
7d130f68 1104 push @{$config{openssl_other_defines}}, "OPENSSL_FIPS";
9e0724a1 1105 }
1ab2f7f1 1106
9fe2bb77 1107 if ($target{sha1_asm_src}) {
bcb1977b
RL		 1108 push @{$config{defines}}, "SHA1_ASM" if ($target{sha1_asm_src} =~ /sx86/ || $target{sha1_asm_src} =~ /sha1/);
1109 push @{$config{defines}}, "SHA256_ASM" if ($target{sha1_asm_src} =~ /sha256/);
1110 push @{$config{defines}}, "SHA512_ASM" if ($target{sha1_asm_src} =~ /sha512/);
9e0724a1 1111 }
9fe2bb77 1112 if ($target{md5_asm_src}) {
bcb1977b 1113 push @{$config{defines}}, "MD5_ASM";
9e0724a1 1114 }
d2b2221a 1115 $target{cast_asm_src}=$table{DEFAULTS}->{cast_asm_src} unless $disabled{pic}; # CAST assembler is not PIC
9fe2bb77 1116 if ($target{rmd160_asm_src}) {
bcb1977b 1117 push @{$config{defines}}, "RMD160_ASM";
9e0724a1 1118 }
9fe2bb77 1119 if ($target{aes_asm_src}) {
bcb1977b 1120 push @{$config{defines}}, "AES_ASM" if ($target{aes_asm_src} =~ m/\baes-/);;
9fe2bb77 1121 # aes-ctr.fake is not a real file, only indication that assembler
874a3757 1122 # module implements AES_ctr32_encrypt...
bcb1977b 1123 push @{$config{defines}}, "AES_CTR_ASM" if ($target{aes_asm_src} =~ s/\s*aes-ctr\.fake//);
9fe2bb77 1124 # aes-xts.fake indicates presence of AES_xts_[en|de]crypt...
bcb1977b 1125 push @{$config{defines}}, "AES_XTS_ASM" if ($target{aes_asm_src} =~ s/\s*aes-xts\.fake//);
9fe2bb77 1126 $target{aes_asm_src} =~ s/\s*(vpaes|aesni)-x86\.s//g if ($no_sse2);
bcb1977b
RL		 1127 push @{$config{defines}}, "VPAES_ASM" if ($target{aes_asm_src} =~ m/vpaes/);
1128 push @{$config{defines}}, "BSAES_ASM" if ($target{aes_asm_src} =~ m/bsaes/);
9e0724a1 1129 }
9fe2bb77 1130 if ($target{wp_asm_src} =~ /mmx/) {
46d4d865 1131 if ($config{processor} eq "386") {
d2b2221a 1132 $target{wp_asm_src}=$table{DEFAULTS}->{wp_asm_src};
46d4d865 1133 } elsif (!$disabled{"whirlpool"}) {
2952b9b8 1134 push @{$config{defines}}, "WHIRLPOOL_ASM";
46d4d865 1135 }
9e0724a1 1136 }
9fe2bb77 1137 if ($target{modes_asm_src} =~ /ghash-/) {
bcb1977b 1138 push @{$config{defines}}, "GHASH_ASM";
9e0724a1 1139 }
9fe2bb77 1140 if ($target{ec_asm_src} =~ /ecp_nistz256/) {
bcb1977b 1141 push @{$config{defines}}, "ECP_NISTZ256_ASM";
9e0724a1 1142 }
9fe2bb77 1143 if ($target{poly1305_asm_src} ne "") {
bcb1977b 1144 push @{$config{defines}}, "POLY1305_ASM";
9e0724a1
RL		 1145 }
1146}
d02b48c6 1147
8ed40b83 1148my $ecc = $target{cc};
09aa263a 1149if ($^O ne "VMS" && !$disabled{makedepend}) {
a583fc45
RL		 1150 # Is the compiler gcc or clang? $ecc is used below to see if
1151 # error-checking can be turned on.
1152 my $ccpcc = "$config{cross_compile_prefix}$target{cc}";
d0db7ee0
AP		 1153 open(PIPE, "$ccpcc --version 2>&1 |");
1154 my $lines = 2;
a583fc45 1155 while ( <PIPE> ) {
30752dd7
RL		 1156 # Find the version number and save the major.
1157 m|(?:.*)\b(\d+)\.\d+\.\d+\b(?:.*)|;
39affe19 1158 my $compiler_major = $1;
30752dd7
RL		 1159 # We know that GNU C version 3 and up as well as all clang
1160 # versions support dependency generation
39affe19 1161 $config{makedepprog} = $ccpcc
d0db7ee0 1162 if (/clang/ || (/gcc/ && $compiler_major > 3));
a583fc45
RL		 1163 $ecc = "clang" if /clang/;
1164 $ecc = "gcc" if /gcc/;
d0db7ee0 1165 last if ($config{makedepprog} || !$lines--);
a583fc45
RL		 1166 }
1167 close(PIPE);
09aa263a 1168
656bbdc6 1169 $config{makedepprog} = which('makedepend') unless $config{makedepprog};
09aa263a 1170 $disabled{makedepend} = "unavailable" unless $config{makedepprog};
f1f07a23 1171}
8ed40b83 1172
7d130f68 1173
09aa263a 1174
7d130f68
RL		 1175# Deal with bn_ops ###################################################
1176
7d130f68 1177$config{bn_ll} =0;
7d130f68
RL		 1178$config{export_var_as_fn} =0;
1179my $def_int="unsigned int";
1180$config{rc4_int} =$def_int;
b4f35e5e 1181($config{b64l},$config{b64},$config{b32})=(0,0,1);
7d130f68 1182
94af0cd7 1183my $count = 0;
7d130f68 1184foreach (sort split(/\s+/,$target{bn_ops})) {
94af0cd7
RS		 1185 $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1186 $config{export_var_as_fn}=1 if $_ eq 'EXPORT_VAR_AS_FN';
1187 $config{bn_ll}=1 if $_ eq 'BN_LLONG';
1188 $config{rc4_int}="unsigned char" if $_ eq 'RC4_CHAR';
1189 ($config{b64l},$config{b64},$config{b32})
1190 =(0,1,0) if $_ eq 'SIXTY_FOUR_BIT';
1191 ($config{b64l},$config{b64},$config{b32})
1192 =(1,0,0) if $_ eq 'SIXTY_FOUR_BIT_LONG';
1193 ($config{b64l},$config{b64},$config{b32})
1194 =(0,0,1) if $_ eq 'THIRTY_TWO_BIT';
7d130f68 1195}
94af0cd7
RS		 1196die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1197 if $count > 1;
7d130f68
RL		 1198
1199
1200# Hack cflags for better warnings (dev option) #######################
1201
1ed0c662
RL		 1202# "Stringify" the C flags string. This permits it to be made part of a string
1203# and works as well on command lines.
01d99976 1204$config{cflags} =~ s/([\\\"])/\\$1/g;
b436a982 1205
107b5792
RL		 1206if (defined($config{api})) {
1207 $config{openssl_api_defines} = [ "OPENSSL_MIN_API=".$apitable->{$config{api}} ];
bcb1977b 1208 my $apiflag = sprintf("OPENSSL_API_COMPAT=%s", $apitable->{$config{api}});
bcb1977b 1209 push @{$config{defines}}, $apiflag;
98186eb4
VD		 1210}
1211
0c28f277
DSH		 1212if ($strict_warnings)
1213 {
1214 my $wopt;
f1f07a23
RS		 1215 die "ERROR --strict-warnings requires gcc or clang"
1216 unless $ecc eq 'gcc' || $ecc eq 'clang';
0c28f277
DSH		 1217 foreach $wopt (split /\s+/, $gcc_devteam_warn)
1218 {
d918f9cb 1219 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
0c28f277 1220 }
190c8c60
BL		 1221 if ($ecc eq "clang")
1222 {
1223 foreach $wopt (split /\s+/, $clang_devteam_warn)
1224 {
d918f9cb 1225 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
190c8c60
BL		 1226 }
1227 }
ef8ca6bd
RL		 1228 }
1229
1230unless ($disabled{"crypto-mdebug-backtrace"})
1231 {
1232 foreach my $wopt (split /\s+/, $memleak_devteam_backtrace)
a1d3f3d1 1233 {
d918f9cb 1234 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
ef8ca6bd
RL		 1235 }
1236 if ($target =~ /^BSD-/)
1237 {
1238 $config{ex_libs} .= " -lexecinfo";
291e94df 1239 }
0c28f277
DSH		 1240 }
1241
63994098
RL		 1242if ($user_cflags ne "") { $config{cflags}="$config{cflags}$user_cflags"; }
1243else { $no_user_cflags=1; }
1244if (@user_defines) { $config{defines}=[ @{$config{defines}}, @user_defines ]; }
1245else { $no_user_defines=1; }
1246
1247# ALL MODIFICATIONS TO %config and %target MUST BE DONE FROM HERE ON
1248
c91a0a83
EK		 1249unless ($disabled{afalgeng}) {
1250 $config{afalgeng}="";
79fff39d
RL		 1251 if ($target =~ m/^linux/) {
1252 my $minver = 4*10000 + 1*100 + 0;
1253 if ($config{cross_compile_prefix} eq "") {
1254 my $verstr = `uname -r`;
1255 my ($ma, $mi1, $mi2) = split("\\.", $verstr);
1256 ($mi2) = $mi2 =~ /(\d+)/;
1257 my $ver = $ma*10000 + $mi1*100 + $mi2;
1258 if ($ver < $minver) {
c91a0a83 1259 $disabled{afalgeng} = "too-old-kernel";
79fff39d
RL		 1260 } else {
1261 push @{$config{engdirs}}, "afalg";
1262 }
68dc37c1
MC		 1263 } else {
1264 $disabled{afalgeng} = "cross-compiling";
6cba4a66 1265 }
79fff39d 1266 } else {
c91a0a83 1267 $disabled{afalgeng} = "not-linux";
7f458a48 1268 }
1269}
8da00a38 1270
c91a0a83 1271push @{$config{openssl_other_defines}}, "OPENSSL_NO_AFALGENG" if ($disabled{afalgeng});
7f458a48 1272
9fe2bb77
RL		 1273# If we use the unified build, collect information from build.info files
1274my %unified_info = ();
1275
2b6b606c 1276my $buildinfo_debug = defined($ENV{CONFIGURE_DEBUG_BUILDINFO});
ddf1847d
RL		 1277if ($builder eq "unified") {
1278 # Store the name of the template file we will build the build file from
1279 # in %config. This may be useful for the build file itself.
38add230
RL		 1280 my $build_file_template;
1281
1282 for my $filename (( $builder_platform."-".$target{build_file}.".tmpl",
1283 $target{build_file}.".tmpl" )) {
1284 if (defined $ENV{$local_config_envname}) {
1285 if ($^O eq 'VMS') {
1286 # VMS environment variables are logical names,
1287 # which can be used as is
1288 $build_file_template = $local_config_envname . ':' . $filename;
1289 } else {
1290 $build_file_template = catfile($ENV{$local_config_envname},
1291 $filename);
1292 }
1293 }
1294
1295 last if -f $build_file_template;
1296
1297 $build_file_template = catfile($srcdir, "Configurations", $filename);
1298
1299 last if -f $build_file_template;
1300 }
ddf1847d
RL		 1301 $config{build_file_template} = $build_file_template;
1302
9fe2bb77
RL		 1303 use lib catdir(dirname(__FILE__),"util");
1304 use with_fallback qw(Text::Template);
1305
9fe2bb77 1306 sub cleandir {
2e963849 1307 my $base = shift;
9fe2bb77 1308 my $dir = shift;
2e963849
RL		 1309 my $relativeto = shift || ".";
1310
1311 $dir = catdir($base,$dir) unless isabsolute($dir);
9fe2bb77 1312
ec182ef0
RL		 1313 # Make sure the directories we're building in exists
1314 mkpath($dir);
1315
2e963849 1316 my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
9fe2bb77
RL		 1317 #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1318 return $res;
1319 }
1320
1321 sub cleanfile {
2e963849 1322 my $base = shift;
9fe2bb77 1323 my $file = shift;
2e963849
RL		 1324 my $relativeto = shift || ".";
1325
1326 $file = catfile($base,$file) unless isabsolute($file);
1327
9fe2bb77
RL		 1328 my $d = dirname($file);
1329 my $f = basename($file);
1330
ec182ef0
RL		 1331 # Make sure the directories we're building in exists
1332 mkpath($d);
1333
2e963849 1334 my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
9fe2bb77
RL		 1335 #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1336 return $res;
1337 }
1338
1339 my @build_infos = ( [ ".", "build.info" ] );
1340 foreach (@{$config{dirs}}) {
1341 push @build_infos, [ $_, "build.info" ]
1342 if (-f catfile($srcdir, $_, "build.info"));
1343 }
1344 foreach (@{$config{sdirs}}) {
1345 push @build_infos, [ catdir("crypto", $_), "build.info" ]
1346 if (-f catfile($srcdir, "crypto", $_, "build.info"));
1347 }
1348 foreach (@{$config{engdirs}}) {
1349 push @build_infos, [ catdir("engines", $_), "build.info" ]
1350 if (-f catfile($srcdir, "engines", $_, "build.info"));
1351 }
1352
2e0956ba
RL		 1353 $config{build_infos} = [ ];
1354
9fe2bb77
RL		 1355 foreach (@build_infos) {
1356 my $sourced = catdir($srcdir, $_->[0]);
1357 my $buildd = catdir($blddir, $_->[0]);
1358
dca99383 1359 mkpath($buildd);
9fe2bb77
RL		 1360
1361 my $f = $_->[1];
1362 # The basic things we're trying to build
1363 my @programs = ();
1364 my @libraries = ();
1365 my @engines = ();
1366 my @scripts = ();
1367 my @extra = ();
8a67946e 1368 my @overrides = ();
9fe2bb77
RL		 1369 my @intermediates = ();
1370 my @rawlines = ();
1371
1372 my %ordinals = ();
1373 my %sources = ();
2a08d1a0 1374 my %shared_sources = ();
9fe2bb77
RL		 1375 my %includes = ();
1376 my %depends = ();
1377 my %renames = ();
1378 my %sharednames = ();
ae4c7450 1379 my %generate = ();
9fe2bb77 1380
2e0956ba 1381 push @{$config{build_infos}}, catfile(abs2rel($sourced, $blddir), $f);
9fe2bb77
RL		 1382 my $template = Text::Template->new(TYPE => 'FILE',
1383 SOURCE => catfile($sourced, $f));
1384 die "Something went wrong with $sourced/$f: $!\n" unless $template;
1385 my @text =
1386 split /^/m,
1387 $template->fill_in(HASH => { config => \%config,
1388 target => \%target,
9e04edf2 1389 disabled => \%disabled,
f59d0131 1390 withargs => \%withargs,
9fe2bb77
RL		 1391 builddir => abs2rel($buildd, $blddir),
1392 sourcedir => abs2rel($sourced, $blddir),
1393 buildtop => abs2rel($blddir, $blddir),
1394 sourcetop => abs2rel($srcdir, $blddir) },
1395 DELIMITERS => [ "{-", "-}" ]);
1396
1397 # The top item of this stack has the following values
1398 # -2 positive already run and we found ELSE (following ELSIF should fail)
1399 # -1 positive already run (skip until ENDIF)
1400 # 0 negatives so far (if we're at a condition, check it)
1401 # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
1402 # 2 positive ELSE (following ELSIF should fail)
1403 my @skip = ();
1404 collect_information(
1405 collect_from_array([ @text ],
1406 qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
1407 $l1 =~ s/\\$//; $l1.$l2 }),
1408 # Info we're looking for
1409 qr/^\s*IF\[((?:\\.|[^\\\]])*)\]\s*$/
635bd409 1410 => sub {
c5798e0e 1411 if (! @skip || $skip[$#skip] > 0) {
635bd409
RL		 1412 push @skip, !! $1;
1413 } else {
1414 push @skip, -1;
1415 }
1416 },
9fe2bb77
RL		 1417 qr/^\s*ELSIF\[((?:\\.|[^\\\]])*)\]\s*$/
1418 => sub { die "ELSIF out of scope" if ! @skip;
1419 die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
1420 $skip[$#skip] = -1 if $skip[$#skip] != 0;
1421 $skip[$#skip] = !! $1
1422 if $skip[$#skip] == 0; },
1423 qr/^\s*ELSE\s*$/
1424 => sub { die "ELSE out of scope" if ! @skip;
1425 $skip[$#skip] = -2 if $skip[$#skip] != 0;
1426 $skip[$#skip] = 2 if $skip[$#skip] == 0; },
1427 qr/^\s*ENDIF\s*$/
1428 => sub { die "ENDIF out of scope" if ! @skip;
1429 pop @skip; },
1430 qr/^\s*PROGRAMS\s*=\s*(.*)\s*$/
ce959812 1431 => sub { push @programs, tokenize($1)
9fe2bb77
RL		 1432 if !@skip || $skip[$#skip] > 0 },
1433 qr/^\s*LIBS\s*=\s*(.*)\s*$/
ce959812 1434 => sub { push @libraries, tokenize($1)
9fe2bb77
RL		 1435 if !@skip || $skip[$#skip] > 0 },
1436 qr/^\s*ENGINES\s*=\s*(.*)\s*$/
ce959812 1437 => sub { push @engines, tokenize($1)
9fe2bb77
RL		 1438 if !@skip || $skip[$#skip] > 0 },
1439 qr/^\s*SCRIPTS\s*=\s*(.*)\s*$/
ce959812 1440 => sub { push @scripts, tokenize($1)
9fe2bb77
RL		 1441 if !@skip || $skip[$#skip] > 0 },
1442 qr/^\s*EXTRA\s*=\s*(.*)\s*$/
ce959812 1443 => sub { push @extra, tokenize($1)
9fe2bb77 1444 if !@skip || $skip[$#skip] > 0 },
8a67946e 1445 qr/^\s*OVERRIDES\s*=\s*(.*)\s*$/
ce959812 1446 => sub { push @overrides, tokenize($1)
8a67946e 1447 if !@skip || $skip[$#skip] > 0 },
9fe2bb77
RL		 1448
1449 qr/^\s*ORDINALS\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/,
ce959812 1450 => sub { push @{$ordinals{$1}}, tokenize($2)
9fe2bb77
RL		 1451 if !@skip || $skip[$#skip] > 0 },
1452 qr/^\s*SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1453 => sub { push @{$sources{$1}}, tokenize($2)
9fe2bb77 1454 if !@skip || $skip[$#skip] > 0 },
2a08d1a0 1455 qr/^\s*SHARED_SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1456 => sub { push @{$shared_sources{$1}}, tokenize($2)
2a08d1a0 1457 if !@skip || $skip[$#skip] > 0 },
9fe2bb77 1458 qr/^\s*INCLUDE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1459 => sub { push @{$includes{$1}}, tokenize($2)
9fe2bb77 1460 if !@skip || $skip[$#skip] > 0 },
4f858293 1461 qr/^\s*DEPEND\[((?:\\.|[^\\\]])*)\]\s*=\s*(.*)\s*$/
ce959812 1462 => sub { push @{$depends{$1}}, tokenize($2)
9fe2bb77 1463 if !@skip || $skip[$#skip] > 0 },
ae4c7450
RL		 1464 qr/^\s*GENERATE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1465 => sub { push @{$generate{$1}}, $2
1466 if !@skip || $skip[$#skip] > 0 },
9fe2bb77 1467 qr/^\s*RENAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1468 => sub { push @{$renames{$1}}, tokenize($2)
9fe2bb77
RL		 1469 if !@skip || $skip[$#skip] > 0 },
1470 qr/^\s*SHARED_NAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1471 => sub { push @{$sharednames{$1}}, tokenize($2)
9fe2bb77
RL		 1472 if !@skip || $skip[$#skip] > 0 },
1473 qr/^\s*BEGINRAW\[((?:\\.|[^\\\]])+)\]\s*$/
1474 => sub {
1475 my $lineiterator = shift;
1476 my $target_kind = $1;
1477 while (defined $lineiterator->()) {
04f171c0 1478 s|\R$||;
9fe2bb77
RL		 1479 if (/^\s*ENDRAW\[((?:\\.|[^\\\]])+)\]\s*$/) {
1480 die "ENDRAW doesn't match BEGINRAW"
1481 if $1 ne $target_kind;
1482 last;
1483 }
1484 next if @skip && $skip[$#skip] <= 0;
1485 push @rawlines, $_
1486 if ($target_kind eq $target{build_file}
ddf1847d 1487 || $target_kind eq $target{build_file}."(".$builder_platform.")");
9fe2bb77
RL		 1488 }
1489 },
1490 qr/^(?:#.*|\s*)$/ => sub { },
2b6b606c
RL		 1491 "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" },
1492 "BEFORE" => sub {
1493 if ($buildinfo_debug) {
1494 print STDERR "DEBUG: Parsing ",join(" ", @_),"\n";
1495 print STDERR "DEBUG: ... before parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1496 }
1497 },
1498 "AFTER" => sub {
1499 if ($buildinfo_debug) {
1500 print STDERR "DEBUG: .... after parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1501 }
1502 },
9fe2bb77
RL		 1503 );
1504 die "runaway IF?" if (@skip);
1505
1506 foreach (keys %renames) {
1507 die "$_ renamed to more than one thing: "
1508 ,join(" ", @{$renames{$_}}),"\n"
1509 if scalar @{$renames{$_}} > 1;
2e963849
RL		 1510 my $dest = cleanfile($buildd, $_, $blddir);
1511 my $to = cleanfile($buildd, $renames{$_}->[0], $blddir);
9fe2bb77
RL		 1512 die "$dest renamed to more than one thing: "
1513 ,$unified_info{rename}->{$dest}, $to
1514 unless !defined($unified_info{rename}->{$dest})
1515 or $unified_info{rename}->{$dest} eq $to;
1516 $unified_info{rename}->{$dest} = $to;
1517 }
1518
1519 foreach (@programs) {
2e963849 1520 my $program = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1521 if ($unified_info{rename}->{$program}) {
1522 $program = $unified_info{rename}->{$program};
1523 }
1524 $unified_info{programs}->{$program} = 1;
1525 }
1526
1527 foreach (@libraries) {
2e963849 1528 my $library = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1529 if ($unified_info{rename}->{$library}) {
1530 $library = $unified_info{rename}->{$library};
1531 }
1532 $unified_info{libraries}->{$library} = 1;
1533 }
1534
343ec2b0 1535 die <<"EOF" if scalar @engines and !$config{dynamic_engines};
19ab5790 1536ENGINES can only be used if configured with 'dynamic-engine'.
9fe2bb77
RL		 1537This is usually a fault in a build.info file.
1538EOF
1539 foreach (@engines) {
2e963849 1540 my $library = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1541 if ($unified_info{rename}->{$library}) {
1542 $library = $unified_info{rename}->{$library};
1543 }
1544 $unified_info{engines}->{$library} = 1;
1545 }
1546
1547 foreach (@scripts) {
2e963849 1548 my $script = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1549 if ($unified_info{rename}->{$script}) {
1550 $script = $unified_info{rename}->{$script};
1551 }
1552 $unified_info{scripts}->{$script} = 1;
1553 }
1554
1555 foreach (@extra) {
2e963849 1556 my $extra = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1557 $unified_info{extra}->{$extra} = 1;
1558 }
1559
8a67946e
RL		 1560 foreach (@overrides) {
1561 my $override = cleanfile($buildd, $_, $blddir);
1562 $unified_info{overrides}->{$override} = 1;
1563 }
1564
9fe2bb77
RL		 1565 push @{$unified_info{rawlines}}, @rawlines;
1566
84af1bae 1567 unless ($disabled{shared}) {
9fe2bb77
RL		 1568 # Check sharednames.
1569 foreach (keys %sharednames) {
2e963849 1570 my $dest = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1571 if ($unified_info{rename}->{$dest}) {
1572 $dest = $unified_info{rename}->{$dest};
1573 }
1574 die "shared_name for $dest with multiple values: "
1575 ,join(" ", @{$sharednames{$_}}),"\n"
1576 if scalar @{$sharednames{$_}} > 1;
2e963849 1577 my $to = cleanfile($buildd, $sharednames{$_}->[0], $blddir);
9fe2bb77
RL		 1578 die "shared_name found for a library $dest that isn't defined\n"
1579 unless $unified_info{libraries}->{$dest};
1580 die "shared_name for $dest with multiple values: "
1581 ,$unified_info{sharednames}->{$dest}, ", ", $to
1582 unless !defined($unified_info{sharednames}->{$dest})
1583 or $unified_info{sharednames}->{$dest} eq $to;
1584 $unified_info{sharednames}->{$dest} = $to;
1585 }
1586
1587 # Additionally, we set up sharednames for libraries that don't
1588 # have any, as themselves.
1589 foreach (keys %{$unified_info{libraries}}) {
1590 if (!defined $unified_info{sharednames}->{$_}) {
1591 $unified_info{sharednames}->{$_} = $_
1592 }
1593 }
1594 }
1595
1596 foreach (keys %ordinals) {
1597 my $dest = $_;
2e963849 1598 my $ddest = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1599 if ($unified_info{rename}->{$ddest}) {
1600 $ddest = $unified_info{rename}->{$ddest};
1601 }
1602 foreach (@{$ordinals{$dest}}) {
1603 my %known_ordinals =
1604 (
1605 crypto =>
6928b617 1606 cleanfile($sourced, catfile("util", "libcrypto.num"), $blddir),
9fe2bb77 1607 ssl =>
6928b617 1608 cleanfile($sourced, catfile("util", "libssl.num"), $blddir)
9fe2bb77
RL		 1609 );
1610 my $o = $known_ordinals{$_};
1611 die "Ordinals for $ddest defined more than once\n"
1612 if $unified_info{ordinals}->{$ddest};
1613 $unified_info{ordinals}->{$ddest} = [ $_, $o ];
1614 }
1615 }
1616
1617 foreach (keys %sources) {
1618 my $dest = $_;
2e963849 1619 my $ddest = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1620 if ($unified_info{rename}->{$ddest}) {
1621 $ddest = $unified_info{rename}->{$ddest};
1622 }
1623 foreach (@{$sources{$dest}}) {
2e963849 1624 my $s = cleanfile($sourced, $_, $blddir);
9fe2bb77
RL		 1625
1626 # If it isn't in the source tree, we assume it's generated
1627 # in the build tree
1628 if (! -f $s) {
2e963849 1629 $s = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1630 }
1631 # We recognise C and asm files
1632 if ($s =~ /\.[csS]\b$/) {
1633 (my $o = $_) =~ s/\.[csS]\b$/.o/;
2e963849 1634 $o = cleanfile($buildd, $o, $blddir);
9fe2bb77
RL		 1635 $unified_info{sources}->{$ddest}->{$o} = 1;
1636 $unified_info{sources}->{$o}->{$s} = 1;
1637 } else {
1638 $unified_info{sources}->{$ddest}->{$s} = 1;
1639 }
1640 }
1641 }
1642
2a08d1a0
RL		 1643 foreach (keys %shared_sources) {
1644 my $dest = $_;
1645 my $ddest = cleanfile($buildd, $_, $blddir);
1646 if ($unified_info{rename}->{$ddest}) {
1647 $ddest = $unified_info{rename}->{$ddest};
1648 }
1649 foreach (@{$shared_sources{$dest}}) {
1650 my $s = cleanfile($sourced, $_, $blddir);
1651
1652 # If it isn't in the source tree, we assume it's generated
1653 # in the build tree
1654 if (! -f $s) {
1655 $s = cleanfile($buildd, $_, $blddir);
1656 }
1657 # We recognise C and asm files
1658 if ($s =~ /\.[csS]\b$/) {
1659 (my $o = $_) =~ s/\.[csS]\b$/.o/;
1660 $o = cleanfile($buildd, $o, $blddir);
1661 $unified_info{shared_sources}->{$ddest}->{$o} = 1;
1662 $unified_info{sources}->{$o}->{$s} = 1;
1663 } else {
1664 die "unrecognised source file type for shared library: $s\n";
1665 }
1666 }
1667 }
1668
ae4c7450
RL		 1669 foreach (keys %generate) {
1670 my $dest = $_;
1671 my $ddest = cleanfile($buildd, $_, $blddir);
1672 if ($unified_info{rename}->{$ddest}) {
1673 $ddest = $unified_info{rename}->{$ddest};
1674 }
1675 die "more than one generator for $dest: "
1676 ,join(" ", @{$generate{$_}}),"\n"
1677 if scalar @{$generate{$_}} > 1;
1678 my @generator = split /\s+/, $generate{$dest}->[0];
1679 $generator[0] = cleanfile($sourced, $generator[0], $blddir),
1680 $unified_info{generate}->{$ddest} = [ @generator ];
1681 }
1682
9fe2bb77
RL		 1683 foreach (keys %depends) {
1684 my $dest = $_;
4f858293 1685 my $ddest = $dest eq "" ? "" : cleanfile($sourced, $_, $blddir);
8d34daf0
RL		 1686
1687 # If the destination doesn't exist in source, it can only be
1688 # a generated file in the build tree.
4f858293 1689 if ($ddest ne "" && ! -f $ddest) {
8d34daf0
RL		 1690 $ddest = cleanfile($buildd, $_, $blddir);
1691 if ($unified_info{rename}->{$ddest}) {
1692 $ddest = $unified_info{rename}->{$ddest};
1693 }
9fe2bb77
RL		 1694 }
1695 foreach (@{$depends{$dest}}) {
2e963849 1696 my $d = cleanfile($sourced, $_, $blddir);
9fe2bb77 1697
e737d7b1
RL		 1698 # If we know it's generated, or assume it is because we can't
1699 # find it in the source tree, we set file we depend on to be
1700 # in the build tree rather than the source tree, and assume
1701 # and that there are lines to build it in a BEGINRAW..ENDRAW
1702 # section or in the Makefile template.
1703 if (! -f $d
da1f2104
RL		 1704 || (grep { $d eq $_ }
1705 map { cleanfile($srcdir, $_, $blddir) }
4f858293 1706 grep { /\.h$/ } keys %{$unified_info{generate}})) {
2e963849 1707 $d = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1708 }
1709 # Take note if the file to depend on is being renamed
1710 if ($unified_info{rename}->{$d}) {
1711 $d = $unified_info{rename}->{$d};
1712 }
1713 $unified_info{depends}->{$ddest}->{$d} = 1;
8d34daf0
RL		 1714 # If we depend on a header file or a perl module, let's make
1715 # sure it can get included
4f858293 1716 if ($dest ne "" && $d =~ /\.(h|pm)$/) {
9fe2bb77
RL		 1717 my $i = dirname($d);
1718 push @{$unified_info{includes}->{$ddest}}, $i
1719 unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}};
1720 }
1721 }
1722 }
1723
1724 foreach (keys %includes) {
1725 my $dest = $_;
8d34daf0
RL		 1726 my $ddest = cleanfile($sourced, $_, $blddir);
1727
1728 # If the destination doesn't exist in source, it can only be
1729 # a generated file in the build tree.
1730 if (! -f $ddest) {
1731 $ddest = cleanfile($buildd, $_, $blddir);
1732 if ($unified_info{rename}->{$ddest}) {
1733 $ddest = $unified_info{rename}->{$ddest};
1734 }
9fe2bb77
RL		 1735 }
1736 foreach (@{$includes{$dest}}) {
2e963849 1737 my $i = cleandir($sourced, $_, $blddir);
9fe2bb77
RL		 1738 push @{$unified_info{includes}->{$ddest}}, $i
1739 unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}};
1740 }
1741 }
1742 }
1743
1744 ### Make unified_info a bit more efficient
1745 # One level structures
8a67946e 1746 foreach (("programs", "libraries", "engines", "scripts", "extra", "overrides")) {
9fe2bb77
RL		 1747 $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
1748 }
1749 # Two level structures
2a08d1a0 1750 foreach my $l1 (("sources", "shared_sources", "ldadd", "depends")) {
9fe2bb77
RL		 1751 foreach my $l2 (sort keys %{$unified_info{$l1}}) {
1752 $unified_info{$l1}->{$l2} =
1753 [ sort keys %{$unified_info{$l1}->{$l2}} ];
1754 }
1755 }
1756}
1757
1758# For the schemes that need it, we provide the old *_obj configs
1759# from the *_asm_obj ones
3a55c92b 1760foreach (grep /_(asm|aux)_src$/, keys %target) {
9fe2bb77 1761 my $src = $_;
3a55c92b 1762 (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
9fe2bb77
RL		 1763 ($target{$obj} = $target{$src}) =~ s/\.[csS]\b/.o/g;
1764}
1765
291e94df
RL		 1766# Write down our configuration where it fits #########################
1767
1768open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
1769print OUT <<"EOF";
1770package configdata;
1771
1772use strict;
1773use warnings;
1774
1775use Exporter;
1776#use vars qw(\@ISA \@EXPORT);
1777our \@ISA = qw(Exporter);
3850f8cb 1778our \@EXPORT = qw(\%config \%target \%disabled \%withargs \%unified_info \@disablables);
291e94df
RL		 1779
1780EOF
1781print OUT "our %config = (\n";
1782foreach (sort keys %config) {
1783 if (ref($config{$_}) eq "ARRAY") {
1784 print OUT " ", $_, " => [ ", join(", ",
1785 map { quotify("perl", $_) }
1786 @{$config{$_}}), " ],\n";
1787 } else {
1788 print OUT " ", $_, " => ", quotify("perl", $config{$_}), ",\n"
1789 }
1790}
1791print OUT <<"EOF";
1792);
1793
1794EOF
1795print OUT "our %target = (\n";
1796foreach (sort keys %target) {
1797 if (ref($target{$_}) eq "ARRAY") {
1798 print OUT " ", $_, " => [ ", join(", ",
1799 map { quotify("perl", $_) }
1800 @{$target{$_}}), " ],\n";
1801 } else {
1802 print OUT " ", $_, " => ", quotify("perl", $target{$_}), ",\n"
1803 }
1804}
1805print OUT <<"EOF";
1806);
1807
96d2d7bc
RL		 1808EOF
1809print OUT "our \%available_protocols = (\n";
1810print OUT " tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n";
1811print OUT " dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n";
1812print OUT <<"EOF";
1813);
1814
3850f8cb
RL		 1815EOF
1816print OUT "our \@disablables = (\n";
1817foreach (@disablables) {
1818 print OUT " ", quotify("perl", $_), ",\n";
1819}
1820print OUT <<"EOF";
1821);
1822
96d2d7bc
RL		 1823EOF
1824print OUT "our \%disabled = (\n";
1825foreach (sort keys %disabled) {
1826 print OUT " ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n";
1827}
1828print OUT <<"EOF";
1829);
1830
291e94df 1831EOF
107b5792
RL		 1832print OUT "our %withargs = (\n";
1833foreach (sort keys %withargs) {
1834 if (ref($withargs{$_}) eq "ARRAY") {
1835 print OUT " ", $_, " => [ ", join(", ",
1836 map { quotify("perl", $_) }
1837 @{$withargs{$_}}), " ],\n";
1838 } else {
1839 print OUT " ", $_, " => ", quotify("perl", $withargs{$_}), ",\n"
1840 }
1841}
1842print OUT <<"EOF";
1843);
edd4d402 1844
107b5792 1845EOF
ddf1847d 1846if ($builder eq "unified") {
9fe2bb77
RL		 1847 my $recurse;
1848 $recurse = sub {
1849 my $indent = shift;
1850 foreach (@_) {
1851 if (ref $_ eq "ARRAY") {
1852 print OUT " "x$indent, "[\n";
1853 foreach (@$_) {
1854 $recurse->($indent + 4, $_);
1855 }
1856 print OUT " "x$indent, "],\n";
1857 } elsif (ref $_ eq "HASH") {
1858 my %h = %$_;
1859 print OUT " "x$indent, "{\n";
1860 foreach (sort keys %h) {
1861 if (ref $h{$_} eq "") {
1862 print OUT " "x($indent + 4), quotify("perl", $_), " => ", quotify("perl", $h{$_}), ",\n";
1863 } else {
1864 print OUT " "x($indent + 4), quotify("perl", $_), " =>\n";
1865 $recurse->($indent + 8, $h{$_});
1866 }
1867 }
1868 print OUT " "x$indent, "},\n";
1869 } else {
1870 print OUT " "x$indent, quotify("perl", $_), ",\n";
1871 }
1872 }
1873 };
1874 print OUT "our %unified_info = (\n";
1875 foreach (sort keys %unified_info) {
1876 if (ref $unified_info{$_} eq "") {
1877 print OUT " "x4, quotify("perl", $_), " => ", quotify("perl", $unified_info{$_}), ",\n";
1878 } else {
1879 print OUT " "x4, quotify("perl", $_), " =>\n";
1880 $recurse->(8, $unified_info{$_});
1881 }
1882 }
1883 print OUT <<"EOF";
1884);
1885
1886EOF
1887}
1888print OUT "1;\n";
d02b48c6 1889close(OUT);
f2d4be3b 1890
9fe2bb77 1891
f58a0acb 1892print "CC =$config{cross_compile_prefix}$target{cc}\n";
2952b9b8 1893print "CFLAG =$target{cflags} $config{cflags}\n";
63ee7129 1894print "SHARED_CFLAG =$target{shared_cflag}\n";
2952b9b8 1895print "DEFINES =",join(" ", @{$target{defines}}, @{$config{defines}}),"\n";
940a09ba
RL		 1896print "LFLAG =$target{lflags}\n";
1897print "PLIB_LFLAG =$target{plib_lflags}\n";
2952b9b8 1898print "EX_LIBS =$target{ex_libs} $config{ex_libs}\n";
b756967d 1899print "APPS_OBJ =$target{apps_obj}\n";
291e94df 1900print "CPUID_OBJ =$target{cpuid_obj}\n";
b756967d 1901print "UPLINK_OBJ =$target{uplink_obj}\n";
291e94df
RL		 1902print "BN_ASM =$target{bn_obj}\n";
1903print "EC_ASM =$target{ec_obj}\n";
1904print "DES_ENC =$target{des_obj}\n";
1905print "AES_ENC =$target{aes_obj}\n";
1906print "BF_ENC =$target{bf_obj}\n";
1907print "CAST_ENC =$target{cast_obj}\n";
1908print "RC4_ENC =$target{rc4_obj}\n";
1909print "RC5_ENC =$target{rc5_obj}\n";
1910print "MD5_OBJ_ASM =$target{md5_obj}\n";
1911print "SHA1_OBJ_ASM =$target{sha1_obj}\n";
1912print "RMD160_OBJ_ASM=$target{rmd160_obj}\n";
1913print "CMLL_ENC =$target{cmll_obj}\n";
1914print "MODES_OBJ =$target{modes_obj}\n";
f0bd4686 1915print "PADLOCK_OBJ =$target{padlock_obj}\n";
291e94df
RL		 1916print "CHACHA_ENC =$target{chacha_obj}\n";
1917print "POLY1305_OBJ =$target{poly1305_obj}\n";
2d0b4412 1918print "BLAKE2_OBJ =$target{blake2_obj}\n";
7d130f68 1919print "PROCESSOR =$config{processor}\n";
f58a0acb
AP		 1920print "RANLIB =", $target{ranlib} eq '$(CROSS_COMPILE)ranlib' ?
1921 "$config{cross_compile_prefix}ranlib" :
1922 "$target{ranlib}", "\n";
291e94df
RL		 1923print "ARFLAGS =$target{arflags}\n";
1924print "PERL =$config{perl}\n";
f0bd4686 1925print "\n";
7d130f68
RL		 1926print "SIXTY_FOUR_BIT_LONG mode\n" if $config{b64l};
1927print "SIXTY_FOUR_BIT mode\n" if $config{b64};
1928print "THIRTY_TWO_BIT mode\n" if $config{b32};
7d130f68 1929print "BN_LLONG mode\n" if $config{bn_ll};
01d99976 1930print "RC4 uses $config{rc4_int}\n" if $config{rc4_int} ne $def_int;
cba5068d 1931
88087414 1932my %builders = (
9fe2bb77 1933 unified => sub {
ddf1847d
RL		 1934 run_dofile(catfile($blddir, $target{build_file}),
1935 $config{build_file_template},
1936 catfile($srcdir, "Configurations", "common.tmpl"));
9fe2bb77 1937 },
88087414
RL		 1938 );
1939
ddf1847d 1940$builders{$builder}->($builder_platform, @builder_opts);
fce0ba5f 1941
76ffb43d 1942print <<"EOF";
63d3f44a 1943
89ec98e0 1944Configured for $target.
63d3f44a 1945EOF
5f8d5c96 1946
9c62a279 1947print <<"EOF" if ($disabled{threads} eq "unavailable");
5f8d5c96
BM		 1948
1949The library could not be configured for supporting multi-threaded
1950applications as the compiler options required on this system are not known.
ff1b7e09 1951See file INSTALL for details if you need multi-threading.
ec577822
BM		 1952EOF
1953
76ffb43d 1954print <<"EOF" if ($no_shared_warn);
2964ba8c 1955
ae48242c
RL		 1956The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
1957platform, so we will pretend you gave the option 'no-pic', which also disables
1958'shared' and 'dynamic-engine'. If you know how to implement shared libraries
1959or position independent code, please let us know (but please first make sure
1960you have tried with a current version of OpenSSL).
2e31ef03
RS		 1961EOF
1962
ddc606c9
RL		 1963print <<"EOF" if (-f catfile($srcdir, "configdata.pm") && $srcdir ne $blddir);
1964
1965WARNING: there are indications that another build was made in the source
1966directory. This build may have picked up artifacts from that build, the
1967safest course of action is to clean the source directory and redo this
1968configuration.
1969EOF
1970
d02b48c6
RE		 1971exit(0);
1972
bd5192b1
RL		 1973######################################################################
1974#
1975# Helpers and utility functions
1976#
1977
1978# Configuration file reading #########################################
1979
1f2e1cd5
RL		 1980# Note: All of the helper functions are for lazy evaluation. They all
1981# return a CODE ref, which will return the intended value when evaluated.
1982# Thus, whenever there's mention of a returned value, it's about that
1983# intended value.
1984
bd5192b1 1985# Helper function to implement conditional inheritance depending on the
00b0d663 1986# value of $disabled{asm}. Used in inherit_from values as follows:
bd5192b1
RL		 1987#
1988# inherit_from => [ "template", asm("asm_tmpl") ]
1989#
1990sub asm {
1991 my @x = @_;
1992 sub {
00b0d663 1993 $disabled{asm} ? () : @x;
bd5192b1
RL		 1994 }
1995}
1996
1f2e1cd5
RL		 1997# Helper function to implement conditional value variants, with a default
1998# plus additional values based on the value of $config{build_type}.
1999# Arguments are given in hash table form:
2000#
2001# picker(default => "Basic string: ",
2002# debug => "debug",
2003# release => "release")
2004#
2005# When configuring with --debug, the resulting string will be
2006# "Basic string: debug", and when not, it will be "Basic string: release"
2007#
2008# This can be used to create variants of sets of flags according to the
2009# build type:
2010#
2011# cflags => picker(default => "-Wall",
2012# debug => "-g -O0",
2013# release => "-O3")
2014#
2015sub picker {
2016 my %opts = @_;
2017 return sub { add($opts{default} || (),
2018 $opts{$config{build_type}} || ())->(); }
2019}
2020
2021# Helper function to combine several values of different types into one.
2022# This is useful if you want to combine a string with the result of a
2023# lazy function, such as:
2024#
2025# cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
2026#
2027sub combine {
2028 my @stuff = @_;
2029 return sub { add(@stuff)->(); }
2030}
2031
2032# Helper function to implement conditional values depending on the value
2033# of $disabled{threads}. Can be used as follows:
2034#
2035# cflags => combine("-Wall", threads("-pthread"))
2036#
2037sub threads {
2038 my @flags = @_;
2039 return sub { add($disabled{threads} ? () : @flags)->(); }
2040}
2041
2042
2043
9c62a279 2044our $add_called = 0;
88087414
RL		 2045# Helper function to implement adding values to already existing configuration
2046# values. It handles elements that are ARRAYs, CODEs and scalars
2047sub _add {
2048 my $separator = shift;
2049
bcb1977b
RL		 2050 # If there's any ARRAY in the collection of values OR the separator
2051 # is undef, we will return an ARRAY of combined values, otherwise a
2052 # string of joined values with $separator as the separator.
2053 my $found_array = !defined($separator);
88087414
RL		 2054
2055 my @values =
2056 map {
b0b92a5b
RL		 2057 my $res = $_;
2058 while (ref($res) eq "CODE") {
2059 $res = $res->();
2060 }
2061 if (defined($res)) {
2062 if (ref($res) eq "ARRAY") {
2063 $found_array = 1;
2064 @$res;
2065 } else {
2066 $res;
2067 }
88087414 2068 } else {
b0b92a5b 2069 ();
88087414
RL		 2070 }
2071 } (@_);
2072
9c62a279
RL		 2073 $add_called = 1;
2074
88087414
RL		 2075 if ($found_array) {
2076 [ @values ];
2077 } else {
b0b92a5b 2078 join($separator, grep { defined($_) && $_ ne "" } @values);
88087414
RL		 2079 }
2080}
2081sub add_before {
bdcd83e1
RL		 2082 my $separator = " ";
2083 if (ref($_[$#_]) eq "HASH") {
2084 my $opts = pop;
2085 $separator = $opts->{separator};
2086 }
88087414
RL		 2087 my @x = @_;
2088 sub { _add($separator, @x, @_) };
2089}
2090sub add {
bdcd83e1
RL		 2091 my $separator = " ";
2092 if (ref($_[$#_]) eq "HASH") {
2093 my $opts = pop;
2094 $separator = $opts->{separator};
2095 }
88087414
RL		 2096 my @x = @_;
2097 sub { _add($separator, @_, @x) };
2098}
2099
bd5192b1
RL		 2100# configuration reader, evaluates the input file as a perl script and expects
2101# it to fill %targets with target configurations. Those are then added to
2102# %table.
2103sub read_config {
2104 my $fname = shift;
2105 open(CONFFILE, "< $fname")
2106 or die "Can't open configuration file '$fname'!\n";
2107 my $x = $/;
2108 undef $/;
2109 my $content = <CONFFILE>;
2110 $/ = $x;
2111 close(CONFFILE);
2112 my %targets = ();
2113 {
2114 local %table = %::table; # Protect %table from tampering
2115
2116 eval $content;
2117 warn $@ if $@;
2118 }
2119
2120 # For each target, check that it's configured with a hash table.
2121 foreach (keys %targets) {
2122 if (ref($targets{$_}) ne "HASH") {
2123 if (ref($targets{$_}) eq "") {
2124 warn "Deprecated target configuration for $_, ignoring...\n";
2125 } else {
2126 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
2127 }
2128 delete $targets{$_};
2129 }
2130 }
2131
2132 %table = (%table, %targets);
2133
2134}
2135
8483a003
F		 2136# configuration resolver. Will only resolve all the lazy evaluation
2137# codeblocks for the chosen target and all those it inherits from,
bd5192b1
RL		 2138# recursively
2139sub resolve_config {
2140 my $target = shift;
2141 my @breadcrumbs = @_;
2142
c4718849 2143# my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
9c62a279 2144
bd5192b1
RL		 2145 if (grep { $_ eq $target } @breadcrumbs) {
2146 die "inherit_from loop! target backtrace:\n "
2147 ,$target,"\n ",join("\n ", @breadcrumbs),"\n";
2148 }
2149
2150 if (!defined($table{$target})) {
2151 warn "Warning! target $target doesn't exist!\n";
2152 return ();
2153 }
2154 # Recurse through all inheritances. They will be resolved on the
2155 # fly, so when this operation is done, they will all just be a
2156 # bunch of attributes with string values.
2157 # What we get here, though, are keys with references to lists of
2158 # the combined values of them all. We will deal with lists after
2159 # this stage is done.
2160 my %combined_inheritance = ();
2161 if ($table{$target}->{inherit_from}) {
2162 my @inherit_from =
2163 map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
2164 foreach (@inherit_from) {
2165 my %inherited_config = resolve_config($_, $target, @breadcrumbs);
2166
2167 # 'template' is a marker that's considered private to
2168 # the config that had it.
2169 delete $inherited_config{template};
2170
2110febb 2171 foreach (keys %inherited_config) {
bd5192b1
RL		 2172 if (!$combined_inheritance{$_}) {
2173 $combined_inheritance{$_} = [];
2174 }
2175 push @{$combined_inheritance{$_}}, $inherited_config{$_};
2110febb 2176 }
bd5192b1
RL		 2177 }
2178 }
2179
2180 # We won't need inherit_from in this target any more, since we've
2181 # resolved all the inheritances that lead to this
2182 delete $table{$target}->{inherit_from};
2183
2184 # Now is the time to deal with those lists. Here's the place to
2185 # decide what shall be done with those lists, all based on the
2186 # values of the target we're currently dealing with.
2187 # - If a value is a coderef, it will be executed with the list of
2188 # inherited values as arguments.
2189 # - If the corresponding key doesn't have a value at all or is the
8483a003 2190 # empty string, the inherited value list will be run through the
bd5192b1
RL		 2191 # default combiner (below), and the result becomes this target's
2192 # value.
2193 # - Otherwise, this target's value is assumed to be a string that
2194 # will simply override the inherited list of values.
a26d8be9 2195 my $default_combiner = add();
bd5192b1
RL		 2196
2197 my %all_keys =
2198 map { $_ => 1 } (keys %combined_inheritance,
2199 keys %{$table{$target}});
b0b92a5b
RL		 2200
2201 sub process_values {
2202 my $object = shift;
2203 my $inherited = shift; # Always a [ list ]
2204 my $target = shift;
2205 my $entry = shift;
2206
9c62a279
RL		 2207 $add_called = 0;
2208
b0b92a5b
RL		 2209 while(ref($object) eq "CODE") {
2210 $object = $object->(@$inherited);
2211 }
2212 if (!defined($object)) {
2213 return ();
2214 }
2215 elsif (ref($object) eq "ARRAY") {
9c62a279 2216 local $add_called; # To make sure recursive calls don't affect it
b0b92a5b
RL		 2217 return [ map { process_values($_, $inherited, $target, $entry) }
2218 @$object ];
2219 } elsif (ref($object) eq "") {
2220 return $object;
2221 } else {
2222 die "cannot handle reference type ",ref($object)
2223 ," found in target ",$target," -> ",$entry,"\n";
2224 }
2225 }
2226
bd5192b1 2227 foreach (sort keys %all_keys) {
9c62a279 2228 my $previous = $combined_inheritance{$_};
bd5192b1
RL		 2229
2230 # Current target doesn't have a value for the current key?
2231 # Assign it the default combiner, the rest of this loop body
2232 # will handle it just like any other coderef.
2233 if (!exists $table{$target}->{$_}) {
2234 $table{$target}->{$_} = $default_combiner;
2235 }
2236
b0b92a5b
RL		 2237 $table{$target}->{$_} = process_values($table{$target}->{$_},
2238 $combined_inheritance{$_},
2239 $target, $_);
2240 unless(defined($table{$target}->{$_})) {
2241 delete $table{$target}->{$_};
2242 }
c4718849
RL		 2243# if ($extra_checks &&
2244# $previous && !($add_called || $previous ~~ $table{$target}->{$_})) {
2245# warn "$_ got replaced in $target\n";
2246# }
bd5192b1
RL		 2247 }
2248
2249 # Finally done, return the result.
2250 return %{$table{$target}};
2251}
2252
462ba4f6 2253sub usage
d02b48c6 2254 {
462ba4f6 2255 print STDERR $usage;
10a926c1 2256 print STDERR "\npick os/compiler from:\n";
1641cb60 2257 my $j=0;
6457ad15 2258 my $i;
10a926c1 2259 my $k=0;
6457ad15 2260 foreach $i (sort keys %table)
d02b48c6 2261 {
bd5192b1 2262 next if $table{$i}->{template};
462ba4f6 2263 next if $i =~ /^debug/;
10a926c1
UM		 2264 $k += length($i) + 1;
2265 if ($k > 78)
2266 {
2267 print STDERR "\n";
2268 $k=length($i);
2269 }
2270 print STDERR $i . " ";
462ba4f6
UM		 2271 }
2272 foreach $i (sort keys %table)
2273 {
bd5192b1 2274 next if $table{$i}->{template};
462ba4f6 2275 next if $i !~ /^debug/;
10a926c1
UM		 2276 $k += length($i) + 1;
2277 if ($k > 78)
2278 {
2279 print STDERR "\n";
2280 $k=length($i);
2281 }
2282 print STDERR $i . " ";
d02b48c6 2283 }
10a926c1 2284 print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
462ba4f6 2285 exit(1);
d02b48c6
RE		 2286 }
2287
01d99976 2288sub run_dofile
107b5792 2289{
107b5792 2290 my $out = shift;
9fe2bb77 2291 my @templates = @_;
107b5792 2292
ced2c2c5
RS		 2293 unlink $out || warn "Can't remove $out, $!"
2294 if -f $out;
9fe2bb77
RL		 2295 foreach (@templates) {
2296 die "Can't open $_, $!" unless -f $_;
2297 }
a3a08f81 2298 my $cmd = "$config{perl} \"-I.\" \"-Mconfigdata\" \"$dofile\" -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\"";
9fe2bb77
RL		 2299 #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
2300 system($cmd);
107b5792
RL		 2301 exit 1 if $? != 0;
2302 rename("$out.new", $out) || die "Can't rename $out.new, $!";
2303}
2304
656bbdc6
AP		 2305sub which
2306{
2307 my ($name)=@_;
2308
2309 if (eval { require IPC::Cmd; 1; }) {
2310 IPC::Cmd->import();
2311 return scalar IPC::Cmd::can_run($name);
2312 } else {
2313 # if there is $directories component in splitpath,
2314 # then it's not something to test with $PATH...
2315 return $name if (File::Spec->splitpath($name))[1];
2316
2317 foreach (File::Spec->path()) {
2318 my $fullpath = catfile($_, "$name$target{exe_extension}");
2319 if (-f $fullpath and -x $fullpath) {
2320 return $fullpath;
2321 }
2322 }
2323 }
2324}
2325
00ae96ca
RL		 2326# Configuration printer ##############################################
2327
2328sub print_table_entry
2329{
2330 my $target = shift;
2331 my %target = resolve_config($target);
2332 my $type = shift;
2333
2334 # Don't print the templates
2335 return if $target{template};
2336
2337 my @sequence = (
f0bd4686 2338 "sys_id",
00ae96ca
RL		 2339 "cc",
2340 "cflags",
bcb1977b 2341 "defines",
f0bd4686
RL		 2342 "unistd",
2343 "ld",
00ae96ca 2344 "lflags",
c86ddbe6 2345 "plib_lflags",
1740c162 2346 "ex_libs",
00ae96ca
RL		 2347 "bn_ops",
2348 "cpuid_obj",
2349 "bn_obj",
2350 "ec_obj",
2351 "des_obj",
2352 "aes_obj",
2353 "bf_obj",
2354 "md5_obj",
2355 "sha1_obj",
2356 "cast_obj",
2357 "rc4_obj",
2358 "rmd160_obj",
2359 "rc5_obj",
2360 "wp_obj",
2361 "cmll_obj",
2362 "modes_obj",
f0bd4686 2363 "padlock_obj",
9c62a279 2364 "thread_scheme",
00ae96ca
RL		 2365 "perlasm_scheme",
2366 "dso_scheme",
2367 "shared_target",
2368 "shared_cflag",
2369 "shared_ldflag",
64c443e3 2370 "shared_rcflag",
00ae96ca 2371 "shared_extension",
e987f9f2
RL		 2372 "shared_extension_simple",
2373 "shared_import_extension",
2374 "dso_extension",
f0bd4686
RL		 2375 "obj_extension",
2376 "exe_extension",
00ae96ca 2377 "ranlib",
f0bd4686 2378 "ar",
00ae96ca
RL		 2379 "arflags",
2380 "multilib",
f0bd4686 2381 "build_scheme",
00ae96ca
RL		 2382 );
2383
2384 if ($type eq "TABLE") {
2385 print "\n";
2386 print "*** $target\n";
cb212f23
RL		 2387 foreach (@sequence) {
2388 if (ref($target{$_}) eq "ARRAY") {
2389 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
2390 } else {
2391 printf "\$%-12s = %s\n", $_, $target{$_};
2392 }
2393 }
00ae96ca
RL		 2394 } elsif ($type eq "HASH") {
2395 my $largest =
2396 length((sort { length($a) <=> length($b) } @sequence)[-1]);
2397 print " '$target' => {\n";
2398 foreach (@sequence) {
2399 if ($target{$_}) {
cb212f23
RL		 2400 if (ref($target{$_}) eq "ARRAY") {
2401 print " '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
2402 } else {
2403 print " '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
2404 }
00ae96ca
RL		 2405 }
2406 }
2407 print " },\n";
2408 }
2409}
2410
2411# Utility routines ###################################################
2412
2e963849
RL		 2413# On VMS, if the given file is a logical name, File::Spec::Functions
2414# will consider it an absolute path. There are cases when we want a
2415# purely syntactic check without checking the environment.
2416sub isabsolute {
2417 my $file = shift;
2418
2419 # On non-platforms, we just use file_name_is_absolute().
2420 return file_name_is_absolute($file) unless $^O eq "VMS";
2421
2422 # If the file spec includes a device or a directpry spec,
2423 # file_name_is_absolute() is perfectly safe.
2424 return file_name_is_absolute($file) if $file =~ m|[:\[]|;
2425
2426 # Here, we know the given file spec isn't absolute
2427 return 0;
2428}
2429
ec182ef0
RL		 2430# Makes a directory absolute and cleans out /../ in paths like foo/../bar
2431# On some platforms, this uses rel2abs(), while on others, realpath() is used.
2432# realpath() requires that at least all path components except the last is an
2433# existing directory. On VMS, the last component of the directory spec must
2434# exist.
2435sub absolutedir {
2436 my $dir = shift;
2437
2438 # realpath() is quite buggy on VMS. It uses LIB$FID_TO_NAME, which
2439 # will return the volume name for the device, no matter what. Also,
2440 # it will return an incorrect directory spec if the argument is a
2441 # directory that doesn't exist.
2442 if ($^O eq "VMS") {
2443 return rel2abs($dir);
2444 }
2445
2446 # We use realpath() on Unix, since no other will properly clean out
2447 # a directory spec.
2448 use Cwd qw/realpath/;
2449
2450 return realpath($dir);
2451}
2452
fe05264e
RL		 2453sub quotify {
2454 my %processors = (
2455 perl => sub { my $x = shift;
2456 $x =~ s/([\\\$\@"])/\\$1/g;
2457 return '"'.$x.'"'; },
2458 );
2459 my $for = shift;
2460 my $processor =
2461 defined($processors{$for}) ? $processors{$for} : sub { shift; };
2462
2110febb 2463 return map { $processor->($_); } @_;
fe05264e 2464}
107b5792 2465
9fe2bb77
RL		 2466# collect_from_file($filename, $line_concat_cond_re, $line_concat)
2467# $filename is a file name to read from
2468# $line_concat_cond_re is a regexp detecting a line continuation ending
2469# $line_concat is a CODEref that takes care of concatenating two lines
2470sub collect_from_file {
2471 my $filename = shift;
2472 my $line_concat_cond_re = shift;
2473 my $line_concat = shift;
2474
2475 open my $fh, $filename || die "unable to read $filename: $!\n";
2476 return sub {
2477 my $saved_line = "";
2478 $_ = "";
2479 while (<$fh>) {
04f171c0 2480 s|\R$||;
9fe2bb77
RL		 2481 if (defined $line_concat) {
2482 $_ = $line_concat->($saved_line, $_);
2483 $saved_line = "";
2484 }
2485 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2486 $saved_line = $_;
2487 next;
2488 }
2489 return $_;
2490 }
2491 die "$filename ending with continuation line\n" if $_;
2492 close $fh;
2493 return undef;
2494 }
2495}
2496
2497# collect_from_array($array, $line_concat_cond_re, $line_concat)
2498# $array is an ARRAYref of lines
2499# $line_concat_cond_re is a regexp detecting a line continuation ending
2500# $line_concat is a CODEref that takes care of concatenating two lines
2501sub collect_from_array {
2502 my $array = shift;
2503 my $line_concat_cond_re = shift;
2504 my $line_concat = shift;
2505 my @array = (@$array);
2506
2507 return sub {
2508 my $saved_line = "";
2509 $_ = "";
2510 while (defined($_ = shift @array)) {
04f171c0 2511 s|\R$||;
9fe2bb77
RL		 2512 if (defined $line_concat) {
2513 $_ = $line_concat->($saved_line, $_);
2514 $saved_line = "";
2515 }
2516 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2517 $saved_line = $_;
2518 next;
2519 }
2520 return $_;
2521 }
2522 die "input text ending with continuation line\n" if $_;
2523 return undef;
2524 }
2525}
2526
2527# collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
2528# $lineiterator is a CODEref that delivers one line at a time.
107b5792
RL		 2529# All following arguments are regex/CODEref pairs, where the regexp detects a
2530# line and the CODEref does something with the result of the regexp.
2531sub collect_information {
9fe2bb77 2532 my $lineiterator = shift;
107b5792
RL		 2533 my %collectors = @_;
2534
9fe2bb77 2535 while(defined($_ = $lineiterator->())) {
04f171c0 2536 s|\R$||;
9fe2bb77 2537 my $found = 0;
2b6b606c
RL		 2538 if ($collectors{"BEFORE"}) {
2539 $collectors{"BEFORE"}->($_);
2540 }
9fe2bb77 2541 foreach my $re (keys %collectors) {
2b6b606c 2542 if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
9fe2bb77
RL		 2543 $collectors{$re}->($lineiterator);
2544 $found = 1;
2545 };
2546 }
2547 if ($collectors{"OTHERWISE"}) {
2548 $collectors{"OTHERWISE"}->($lineiterator, $_)
2549 unless $found || !defined $collectors{"OTHERWISE"};
2550 }
2b6b606c
RL		 2551 if ($collectors{"AFTER"}) {
2552 $collectors{"AFTER"}->($_);
2553 }
107b5792 2554 }
107b5792 2555}
ce959812
RL		 2556
2557# tokenize($line)
2558# $line is a line of text to split up into tokens
2559# returns a list of tokens
2560#
2561# Tokens are divided by spaces. If the tokens include spaces, they
2562# have to be quoted with single or double quotes. Double quotes
2563# inside a double quoted token must be escaped. Escaping is done
2564# with backslash.
2565# Basically, the same quoting rules apply for " and ' as in any
2566# Unix shell.
2567sub tokenize {
2568 my $line = my $debug_line = shift;
2569 my @result = ();
2570
2571 while ($line =~ s|^\s+||, $line ne "") {
2572 my $token = "";
2573 while ($line ne "" && $line !~ m|^\s|) {
2574 if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
2575 $token .= $1;
2576 $line = $';
2577 } elsif ($line =~ m/^'([^']*)'/) {
2578 $token .= $1;
2579 $line = $';
2580 } elsif ($line =~ m/^(\S+)/) {
2581 $token .= $1;
2582 $line = $';
2583 }
2584 }
2585 push @result, $token;
2586 }
2587
2588 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
2589 print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
2590 print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";
2591 }
2592 return @result;
2593}
A mirror of the official openssl repository