]> git.ipfire.org Git - thirdparty/openssl.git/blame - Configure
projects / thirdparty / openssl.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix build break.
[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
82# AES_ASM ASE_[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",
1288f26f 327 "ripemd",
8b527be2 328 "rmd160",
8b527be2 329 "scrypt",
8b527be2
RL		 330 "sctp",
331 "seed",
8b527be2
RL		 332 "shared",
333 "sock",
334 "srp",
335 "srtp",
336 "sse2",
337 "ssl",
8b527be2
RL		 338 "ssl-trace",
339 "static-engine",
340 "stdio",
8b527be2
RL		 341 "threads",
342 "tls",
1288f26f 343 "ts",
c38bb727 344 "ubsan",
1288f26f 345 "ui",
8b527be2
RL		 346 "unit-test",
347 "whirlpool",
8b1a5af3 348 "weak-ssl-ciphers",
8b527be2
RL		 349 "zlib",
350 "zlib-dynamic",
351 );
6b01bed2
VD		 352foreach my $proto ((@tls, @dtls))
353 {
354 push(@disablables, $proto);
355 push(@disablables, "$proto-method");
356 }
8b527be2 357
e80381e1
RL		 358my @deprecated_disablables = (
359 "ssl2",
050a36a9 360 "buf-freelists",
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)-(.+)$/)
fe05264e
RL		 555 {
556 my $word = $2;
e80381e1
RL		 557 if (grep { $word =~ /^${_}$/ } @deprecated_disablables)
558 {
559 $deprecated_options{$_} = 1;
560 next;
561 }
562 elsif (!grep { $word =~ /^${_}$/ } @disablables)
8b527be2 563 {
fe05264e
RL		 564 $unsupported_options{$_} = 1;
565 next;
8b527be2 566 }
fe05264e
RL		 567 }
568 if (/^no-(.+)$/ || /^disable-(.+)$/)
569 {
e4ef2e25
RS		 570 foreach my $proto ((@tls, @dtls))
571 {
572 if ($1 eq "$proto-method")
573 {
574 $disabled{"$proto"} = "option($proto-method)";
575 last;
576 }
577 }
578 if ($1 eq "dtls")
579 {
580 foreach my $proto (@dtls)
581 {
582 $disabled{$proto} = "option(dtls)";
583 }
c5c7700c 584 $disabled{"dtls"} = "option(dtls)";
e4ef2e25
RS		 585 }
586 elsif ($1 eq "ssl")
587 {
588 # Last one of its kind
589 $disabled{"ssl3"} = "option(ssl)";
590 }
591 elsif ($1 eq "tls")
592 {
593 # XXX: Tests will fail if all SSL/TLS
594 # protocols are disabled.
595 foreach my $proto (@tls)
596 {
597 $disabled{$proto} = "option(tls)";
598 }
599 }
343ec2b0
RL		 600 elsif ($1 eq "static-engine")
601 {
19ab5790 602 delete $disabled{"dynamic-engine"};
343ec2b0
RL		 603 }
604 elsif ($1 eq "dynamic-engine")
605 {
19ab5790 606 $disabled{"dynamic-engine"} = "option";
343ec2b0 607 }
e4ef2e25
RS		 608 else
609 {
610 $disabled{$1} = "option";
611 }
9c62a279
RL		 612 # No longer an automatic choice
613 $auto_threads = 0 if ($1 eq "threads");
fe05264e 614 }
e4ef2e25 615 elsif (/^enable-(.+)$/)
fe05264e 616 {
343ec2b0
RL		 617 if ($1 eq "static-engine")
618 {
19ab5790 619 $disabled{"dynamic-engine"} = "option";
343ec2b0
RL		 620 }
621 elsif ($1 eq "dynamic-engine")
622 {
19ab5790 623 delete $disabled{"dynamic-engine"};
343ec2b0 624 }
25004db7
RL		 625 elsif ($1 eq "zlib-dynamic")
626 {
627 delete $disabled{"zlib"};
628 }
fe05264e 629 my $algo = $1;
fe05264e 630 delete $disabled{$algo};
c9a112f5 631
9c62a279
RL		 632 # No longer an automatic choice
633 $auto_threads = 0 if ($1 eq "threads");
fe05264e
RL		 634 }
635 elsif (/^--strict-warnings$/)
636 {
637 $strict_warnings = 1;
638 }
639 elsif (/^--debug$/)
640 {
8864f0de 641 $config{build_type} = "debug";
fe05264e
RL		 642 }
643 elsif (/^--release$/)
644 {
8864f0de 645 $config{build_type} = "release";
fe05264e
RL		 646 }
647 elsif (/^386$/)
7d130f68 648 { $config{processor}=386; }
fe05264e
RL		 649 elsif (/^fips$/)
650 {
107b5792 651 $config{fips}=1;
fe05264e
RL		 652 }
653 elsif (/^rsaref$/)
654 {
655 # No RSAref support any more since it's not needed.
656 # The check for the option is there so scripts aren't
657 # broken
658 }
659 elsif (/^nofipscanistercheck$/)
660 {
107b5792 661 $config{fips} = 1;
fe05264e
RL		 662 $nofipscanistercheck = 1;
663 }
664 elsif (/^[-+]/)
665 {
45c6e23c 666 if (/^--prefix=(.*)$/)
fe05264e 667 {
291e94df 668 $config{prefix}=$1;
5482dac9
RL		 669 die "Directory given with --prefix MUST be absolute\n"
670 unless file_name_is_absolute($config{prefix});
c9a112f5 671 }
fe05264e 672 elsif (/^--api=(.*)$/)
0c28f277 673 {
107b5792 674 $config{api}=$1;
0c28f277 675 }
fe05264e 676 elsif (/^--libdir=(.*)$/)
9e43c6b5 677 {
107b5792 678 $config{libdir}=$1;
9e43c6b5 679 }
fe05264e 680 elsif (/^--openssldir=(.*)$/)
9e43c6b5 681 {
291e94df 682 $config{openssldir}=$1;
9e43c6b5 683 }
fe05264e 684 elsif (/^--with-zlib-lib=(.*)$/)
9fdb2cc5 685 {
20a5819f 686 $withargs{zlib_lib}=$1;
7d8bb912 687 }
fe05264e 688 elsif (/^--with-zlib-include=(.*)$/)
3eb0ed6d 689 {
da430a55 690 $withargs{zlib_include}=$1;
462ba4f6 691 }
f59d0131
KR		 692 elsif (/^--with-fuzzer-lib=(.*)$/)
693 {
694 $withargs{fuzzer_lib}=$1;
695 }
696 elsif (/^--with-fuzzer-include=(.*)$/)
697 {
698 $withargs{fuzzer_include}=$1;
699 }
fe05264e 700 elsif (/^--with-fipslibdir=(.*)$/)
1ab2f7f1 701 {
107b5792 702 $config{fipslibdir}="$1/";
1ab2f7f1 703 }
fe05264e 704 elsif (/^--with-baseaddr=(.*)$/)
462ba4f6 705 {
107b5792 706 $config{baseaddr}="$1";
3eb0ed6d 707 }
fe05264e 708 elsif (/^--cross-compile-prefix=(.*)$/)
e5f3045f 709 {
642a6138 710 $config{cross_compile_prefix}=$1;
e5f3045f 711 }
fe05264e 712 elsif (/^--config=(.*)$/)
d02b48c6 713 {
fe05264e 714 read_config $1;
c59cb511 715 }
fe05264e 716 elsif (/^-[lL](.*)$/ or /^-Wl,/)
c9a112f5 717 {
fe05264e 718 $libs.=$_." ";
d02b48c6 719 }
bcb1977b
RL		 720 elsif (/^-D(.*)$/)
721 {
722 push @user_defines, $1;
723 }
fe05264e
RL		 724 else # common if (/^[-+]/), just pass down...
725 {
726 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
2b91ec75 727 $user_cflags.=" ".$_;
fe05264e
RL		 728 }
729 }
fe05264e
RL		 730 else
731 {
732 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
733 $target=$_;
734 }
735 unless ($_ eq $target || /^no-/ || /^disable-/)
736 {
737 # "no-..." follows later after implied disactivations
8483a003 738 # have been derived. (Don't take this too seriously,
fe05264e
RL		 739 # we really only write OPTIONS to the Makefile out of
740 # nostalgia.)
741
3fa04f0d
RL		 742 if ($config{options} eq "")
743 { $config{options} = $_; }
fe05264e 744 else
3fa04f0d 745 { $config{options} .= " ".$_; }
fbabb752 746 }
489eb740 747
107b5792
RL		 748 if (defined($config{api}) && !exists $apitable->{$config{api}}) {
749 die "***** Unsupported api compatibility level: $config{api}\n",
98186eb4
VD		 750 }
751
e80381e1
RL		 752 if (keys %deprecated_options)
753 {
754 warn "***** Deprecated options: ",
755 join(", ", keys %deprecated_options), "\n";
756 }
489eb740
RL		 757 if (keys %unsupported_options)
758 {
759 die "***** Unsupported options: ",
760 join(", ", keys %unsupported_options), "\n";
761 }
fbabb752 762 }
b6e4dac2 763
107b5792 764if ($config{fips})
a7a14a23 765 {
c569e206 766 delete $disabled{"shared"} if ($disabled{"shared"} =~ /^default/);
6b01bed2 767 }
107b5792
RL		 768else
769 {
770 @{$config{dirs}} = grep !/^fips$/, @{$config{dirs}};
771 }
c9a112f5 772
c569e206
RL		 773my @tocheckfor = (keys %disabled);
774while (@tocheckfor) {
775 my %new_tocheckfor = ();
776 my @cascade_copy = (@disable_cascades);
777 while (@cascade_copy) {
778 my ($test, $descendents) = (shift @cascade_copy, shift @cascade_copy);
779 if (ref($test) eq "CODE" ? $test->() : defined($disabled{$test})) {
2110febb 780 foreach(grep { !defined($disabled{$_}) } @$descendents) {
01d99976 781 $new_tocheckfor{$_} = 1; $disabled{$_} = "forced";
2110febb 782 }
ef236ec3 783 }
c569e206
RL		 784 }
785 @tocheckfor = (keys %new_tocheckfor);
786}
edc032b5 787
436a376b 788if ($target eq "TABLE") {
00ae96ca
RL		 789 foreach (sort keys %table) {
790 print_table_entry($_, "TABLE");
791 }
792 exit 0;
436a376b
BM		 793}
794
10a926c1 795if ($target eq "LIST") {
00ae96ca
RL		 796 foreach (sort keys %table) {
797 print $_,"\n" unless $table{$_}->{template};
798 }
799 exit 0;
10a926c1
UM		 800}
801
aaf878cc 802if ($target eq "HASH") {
00ae96ca
RL		 803 print "%table = (\n";
804 foreach (sort keys %table) {
805 print_table_entry($_, "HASH");
806 }
807 exit 0;
aaf878cc
RL		 808}
809
00ae96ca 810# Backward compatibility?
49e04548 811if ($target =~ m/^CygWin32(-.*)$/) {
00ae96ca 812 $target = "Cygwin".$1;
49e04548
RL		 813}
814
c9a112f5
BM		 815foreach (sort (keys %disabled))
816 {
3fa04f0d 817 $config{options} .= " no-$_";
c9a112f5
BM		 818
819 printf " no-%-12s %-10s", $_, "[$disabled{$_}]";
820
821 if (/^dso$/)
721f9058 822 { }
c9a112f5 823 elsif (/^threads$/)
22bfe05e 824 { }
c9a112f5 825 elsif (/^shared$/)
84af1bae 826 { }
ae48242c
RL		 827 elsif (/^pic$/)
828 { }
c9a112f5 829 elsif (/^zlib$/)
36a30909 830 { }
19ab5790 831 elsif (/^dynamic-engine$/)
fbf002bb 832 { }
09aa263a
RL		 833 elsif (/^makedepend$/)
834 { }
c9a112f5
BM		 835 elsif (/^zlib-dynamic$/)
836 { }
c9a112f5
BM		 837 elsif (/^sse2$/)
838 { $no_sse2 = 1; }
107b5792 839 elsif (/^engine$/)
1288f26f
RS		 840 {
841 @{$config{dirs}} = grep !/^engines$/, @{$config{dirs}};
842 @{$config{sdirs}} = grep !/^engine$/, @{$config{sdirs}};
843 push @{$config{openssl_other_defines}}, "OPENSSL_NO_ENGINE";
844 }
c9a112f5
BM		 845 else
846 {
847 my ($ALGO, $algo);
30fafdeb 848 ($ALGO = $algo = $_) =~ tr/[\-a-z]/[_A-Z]/;
c9a112f5 849
316fae2a 850 if (/^asm$/ || /^err$/ || /^hw$/ || /^hw-/ || /^async$/
498abff0 851 || /^autoalginit/ || /^autoerrinit/)
c9a112f5 852 {
7d130f68 853 push @{$config{openssl_other_defines}}, "OPENSSL_NO_$ALGO";
c9a112f5 854 print " OPENSSL_NO_$ALGO";
fce0ba5f 855
bcb1977b 856 if (/^err$/) { push @user_defines, "OPENSSL_NO_ERR"; }
c9a112f5
BM		 857 }
858 else
859 {
2a4af947
AP		 860 ($ALGO,$algo) = ("RMD160","rmd160") if ($algo eq "ripemd");
861
7d130f68 862 push @{$config{openssl_algorithm_defines}}, "OPENSSL_NO_$ALGO";
c9a112f5
BM		 863 print " OPENSSL_NO_$ALGO";
864
e36827f6 865 # fix-up crypto/directory name(s)
107b5792
RL		 866 $algo="whrlpool" if $algo eq "whirlpool";
867 $algo="ripemd" if $algo eq "rmd160";
868 @{$config{sdirs}} = grep { $_ ne $algo} @{$config{sdirs}};
2a4af947 869
e36827f6 870 print " (skip dir)";
c9a112f5
BM		 871 }
872 }
873
874 print "\n";
875 }
876
9e0724a1
RL		 877print "Configuring for $target\n";
878
879# Support for legacy targets having a name starting with 'debug-'
880my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
881if ($d) {
8864f0de 882 $config{build_type} = "debug";
9e0724a1
RL		 883
884 # If we do not find debug-foo in the table, the target is set to foo.
885 if (!$table{$target}) {
886 $target = $t;
887 }
888}
291e94df 889$config{target} = $target;
79302211 890my %target = resolve_config($target);
9e0724a1
RL		 891
892&usage if (!%target || $target{template});
893
d2b2221a 894%target = ( %{$table{DEFAULTS}}, %target );
79302211 895
107b5792 896$target{exe_extension}="";
f99f91f1
RL		 897$target{exe_extension}=".exe" if ($config{target} eq "DJGPP"
898 || $config{target} =~ /^(?:Cygwin|mingw)/);
107b5792 899$target{exe_extension}=".pm" if ($config{target} =~ /vos/);
462ba4f6 900
e987f9f2
RL		 901($target{shared_extension_simple}=$target{shared_extension})
902 =~ s|\.\$\(SHLIB_MAJOR\)\.\$\(SHLIB_MINOR\)||;
903$target{dso_extension}=$target{shared_extension_simple};
904($target{shared_import_extension}=$target{shared_extension_simple}.".a")
905 if ($config{target} =~ /^(?:Cygwin|mingw)/);
906
907
642a6138
RL		 908$config{cross_compile_prefix} = $ENV{'CROSS_COMPILE'}
909 if $config{cross_compile_prefix} eq "";
f99f41cf 910
b0a1e8bf 911# Allow overriding the names of some tools. USE WITH CARE
5902821d 912$config{perl} = $ENV{'PERL'} || ($^O ne "VMS" ? $^X : "perl");
b0a1e8bf 913$target{cc} = $ENV{'CC'} || $target{cc} || "cc";
f58a0acb 914$target{ranlib} = $ENV{'RANLIB'} || $target{ranlib} ||
656bbdc6 915 (which("$config{cross_compile_prefix}ranlib") ?
f58a0acb 916 "\$(CROSS_COMPILE)ranlib" : "true");
b0a1e8bf
RL		 917$target{ar} = $ENV{'AR'} || $target{ar} || "ar";
918$target{nm} = $ENV{'NM'} || $target{nm} || "nm";
8f41ff2d
RL		 919$target{rc} =
920 $ENV{'RC'} || $ENV{'WINDRES'} || $target{rc} || "windres";
aaf878cc 921
bcb1977b
RL		 922# For cflags, lflags, plib_lflags, ex_libs and defines, add the debug_
923# or release_ attributes.
aaf878cc 924# Do it in such a way that no spurious space is appended (hence the grep).
2952b9b8
RL		 925$config{defines} = [];
926$config{cflags} = "";
927$config{ex_libs} = "";
928$config{shared_ldflag} = "";
bd5192b1 929
291e94df
RL		 930# Make sure build_scheme is consistent.
931$target{build_scheme} = [ $target{build_scheme} ]
932 if ref($target{build_scheme}) ne "ARRAY";
933
ddf1847d
RL		 934my ($builder, $builder_platform, @builder_opts) =
935 @{$target{build_scheme}};
936
488e2b0f
RL		 937push @{$config{defines}}, "NDEBUG" if $config{build_type} eq "release";
938
68ab559a 939if ($target =~ /^mingw/ && `$target{cc} --target-help 2>&1` =~ m/-mno-cygwin/m)
cbecd29a 940 {
68ab559a 941 $config{cflags} .= " -mno-cygwin";
2952b9b8 942 $config{shared_ldflag} .= " -mno-cygwin";
cbecd29a
AP		 943 }
944
00b0d663 945if ($target =~ /linux.*-mips/ && !$disabled{asm} && $user_cflags !~ /-m(ips|arch=)/) {
63d8834c 946 # minimally required architecture flags for assembly modules
107b5792
RL		 947 $config{cflags}="-mips2 $config{cflags}" if ($target =~ /mips32/);
948 $config{cflags}="-mips3 $config{cflags}" if ($target =~ /mips64/);
63d8834c
AP		 949}
950
2964ba8c 951my $no_shared_warn=0;
14bcdb08 952my $no_user_cflags=0;
bcb1977b 953my $no_user_defines=0;
2964ba8c 954
bc2aadad
GT		 955# The DSO code currently always implements all functions so that no
956# applications will have to worry about that from a compilation point
957# of view. However, the "method"s may return zero unless that platform
958# has support compiled in for them. Currently each method is enabled
959# by a define "DSO_<name>" ... we translate the "dso_scheme" config
960# string entry into using the following logic;
721f9058 961if (!$disabled{dso} && $target{dso_scheme} ne "")
bc2aadad 962 {
291e94df
RL		 963 $target{dso_scheme} =~ tr/[a-z]/[A-Z]/;
964 if ($target{dso_scheme} eq "DLFCN")
bc2aadad 965 {
2952b9b8 966 unshift @{$config{defines}}, "DSO_DLFCN", "HAVE_DLFCN_H";
bc2aadad 967 }
291e94df 968 elsif ($target{dso_scheme} eq "DLFCN_NO_H")
bc2aadad 969 {
2952b9b8 970 unshift @{$config{defines}}, "DSO_DLFCN";
bc2aadad
GT		 971 }
972 else
973 {
2952b9b8 974 unshift @{$config{defines}}, "DSO_$target{dso_scheme}";
bc2aadad
GT		 975 }
976 }
9ec0126e 977
1740c162 978$config{ex_libs}="$libs$config{ex_libs}" if ($libs ne "");
d02b48c6 979
00b0d663 980if ($disabled{asm})
dfeab068 981 {
2952b9b8
RL		 982 if ($config{fips})
983 {
984 @{$config{defines}} = grep !/^[BL]_ENDIAN$/, @{$config{defines}};
985 @{$target{defines}} = grep !/^[BL]_ENDIAN$/, @{$target{defines}};
986 }
dfeab068 987 }
6f7ac8e1 988
9c62a279
RL		 989# If threads aren't disabled, check how possible they are
990unless ($disabled{threads}) {
991 if ($auto_threads) {
992 # Enabled by default, disable it forcibly if unavailable
993 if ($target{thread_scheme} eq "(unknown)") {
994 $disabled{threads} = "unavailable";
995 }
996 } else {
8483a003 997 # The user chose to enable threads explicitly, let's see
9c62a279
RL		 998 # if there's a chance that's possible
999 if ($target{thread_scheme} eq "(unknown)") {
1000 # If the user asked for "threads" and we don't have internal
1001 # knowledge how to do it, [s]he is expected to provide any
1002 # system-dependent compiler options that are necessary. We
1003 # can't truly check that the given options are correct, but
1004 # we expect the user to know what [s]He is doing.
1005 if ($no_user_cflags && $no_user_defines) {
1006 die "You asked for multi-threading support, but didn't\n"
1007 ,"provide any system-specific compiler options\n";
1008 }
1009 }
1010 }
1011}
1012
1013# If threads still aren't disabled, add a C macro to ensure the source
1014# code knows about it. Any other flag is taken care of by the configs.
1015unless($disabled{threads}) {
1016 foreach (("defines", "openssl_thread_defines")) {
1017 push @{$config{$_}}, "OPENSSL_THREADS";
1018 }
1019}
e452de9d 1020
98186eb4
VD		 1021# With "deprecated" disable all deprecated features.
1022if (defined($disabled{"deprecated"})) {
107b5792 1023 $config{api} = $maxapi;
98186eb4 1024}
07c4c14c 1025
291e94df 1026if ($target{shared_target} eq "")
6f7ac8e1 1027 {
ae48242c 1028 $no_shared_warn = 1
84af1bae 1029 if ((!$disabled{shared} || !$disabled{"dynamic-engine"})
ae48242c 1030 && !$config{fips});
84af1bae 1031 $disabled{shared} = "no-shared-target";
ae48242c
RL		 1032 $disabled{pic} = $disabled{shared} = $disabled{"dynamic-engine"} =
1033 "no-shared-target";
6f7ac8e1 1034 }
b436a982 1035
19ab5790 1036if ($disabled{"dynamic-engine"}) {
343ec2b0
RL		 1037 push @{$config{defines}}, "OPENSSL_NO_DYNAMIC_ENGINE";
1038 $config{dynamic_engines} = 0;
19ab5790
RL		 1039} else {
1040 push @{$config{defines}}, "OPENSSL_NO_STATIC_ENGINE";
1041 $config{dynamic_engines} = 1;
343ec2b0 1042}
ecd45314 1043
f59d0131 1044unless ($disabled{"fuzz-libfuzzer"}) {
c145d197 1045 push @{$config{dirs}}, "fuzz";
c38bb727
BL		 1046 $config{cflags} .= "-fsanitize-coverage=edge,indirect-calls ";
1047}
1048
f59d0131
KR		 1049unless ($disabled{"fuzz-afl"}) {
1050 push @{$config{dirs}}, "fuzz";
1051}
1052
c38bb727
BL		 1053unless ($disabled{asan}) {
1054 $config{cflags} .= "-fsanitize=address ";
1055}
1056
1057unless ($disabled{ubsan}) {
1058 # -DPEDANTIC or -fnosanitize=aligmnent may also be required on some
1059 # platforms.
1060 $config{cflags} .= "-fsanitize=undefined -fno-sanitize-recover=all ";
1061}
1062
65cc6d5c
RL		 1063unless ($disabled{"fuzz-libfuzzer"} && $disabled{"fuzz-afl"}
1064 && $disabled{asan} && $disabled{ubsan}) {
c38bb727
BL		 1065 $config{cflags} .= "-fno-omit-frame-pointer -g ";
1066}
c313e32a
AP		 1067#
1068# Platform fix-ups
1069#
ae48242c
RL		 1070
1071# This saves the build files from having to check
1072if ($disabled{pic})
1073 {
1074 $target{shared_cflag} = $target{shared_ldflag} =
1075 $target{shared_rcflag} = "";
1076 }
4f16039e
RL		 1077else
1078 {
1079 push @{$config{defines}}, "OPENSSL_PIC";
1080 }
ae48242c 1081
291e94df 1082if ($target{sys_id} ne "")
cf1b7d96 1083 {
642a6138 1084 push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
cf1b7d96
RL		 1085 }
1086
00b0d663 1087unless ($disabled{asm}) {
d2b2221a 1088 $target{cpuid_asm_src}=$table{DEFAULTS}->{cpuid_asm_src} if ($config{processor} eq "386");
9fe2bb77 1089 $target{bn_asm_src} =~ s/\w+-gf2m.c// if (defined($disabled{ec2m}));
f8c469de 1090
9e0724a1 1091 # bn-586 is the only one implementing bn_*_part_words
bcb1977b
RL		 1092 push @{$config{defines}}, "OPENSSL_BN_ASM_PART_WORDS" if ($target{bn_asm_src} =~ /bn-586/);
1093 push @{$config{defines}}, "OPENSSL_IA32_SSE2" if (!$no_sse2 && $target{bn_asm_src} =~ /86/);
dfeab068 1094
bcb1977b
RL		 1095 push @{$config{defines}}, "OPENSSL_BN_ASM_MONT" if ($target{bn_asm_src} =~ /-mont/);
1096 push @{$config{defines}}, "OPENSSL_BN_ASM_MONT5" if ($target{bn_asm_src} =~ /-mont5/);
1097 push @{$config{defines}}, "OPENSSL_BN_ASM_GF2m" if ($target{bn_asm_src} =~ /-gf2m/);
5ac7bde7 1098
107b5792 1099 if ($config{fips}) {
7d130f68 1100 push @{$config{openssl_other_defines}}, "OPENSSL_FIPS";
9e0724a1 1101 }
1ab2f7f1 1102
9fe2bb77 1103 if ($target{sha1_asm_src}) {
bcb1977b
RL		 1104 push @{$config{defines}}, "SHA1_ASM" if ($target{sha1_asm_src} =~ /sx86/ || $target{sha1_asm_src} =~ /sha1/);
1105 push @{$config{defines}}, "SHA256_ASM" if ($target{sha1_asm_src} =~ /sha256/);
1106 push @{$config{defines}}, "SHA512_ASM" if ($target{sha1_asm_src} =~ /sha512/);
9e0724a1 1107 }
9fe2bb77 1108 if ($target{md5_asm_src}) {
bcb1977b 1109 push @{$config{defines}}, "MD5_ASM";
9e0724a1 1110 }
d2b2221a 1111 $target{cast_asm_src}=$table{DEFAULTS}->{cast_asm_src} unless $disabled{pic}; # CAST assembler is not PIC
9fe2bb77 1112 if ($target{rmd160_asm_src}) {
bcb1977b 1113 push @{$config{defines}}, "RMD160_ASM";
9e0724a1 1114 }
9fe2bb77 1115 if ($target{aes_asm_src}) {
bcb1977b 1116 push @{$config{defines}}, "AES_ASM" if ($target{aes_asm_src} =~ m/\baes-/);;
9fe2bb77 1117 # aes-ctr.fake is not a real file, only indication that assembler
874a3757 1118 # module implements AES_ctr32_encrypt...
bcb1977b 1119 push @{$config{defines}}, "AES_CTR_ASM" if ($target{aes_asm_src} =~ s/\s*aes-ctr\.fake//);
9fe2bb77 1120 # aes-xts.fake indicates presence of AES_xts_[en|de]crypt...
bcb1977b 1121 push @{$config{defines}}, "AES_XTS_ASM" if ($target{aes_asm_src} =~ s/\s*aes-xts\.fake//);
9fe2bb77 1122 $target{aes_asm_src} =~ s/\s*(vpaes|aesni)-x86\.s//g if ($no_sse2);
bcb1977b
RL		 1123 push @{$config{defines}}, "VPAES_ASM" if ($target{aes_asm_src} =~ m/vpaes/);
1124 push @{$config{defines}}, "BSAES_ASM" if ($target{aes_asm_src} =~ m/bsaes/);
9e0724a1 1125 }
9fe2bb77 1126 if ($target{wp_asm_src} =~ /mmx/) {
46d4d865 1127 if ($config{processor} eq "386") {
d2b2221a 1128 $target{wp_asm_src}=$table{DEFAULTS}->{wp_asm_src};
46d4d865 1129 } elsif (!$disabled{"whirlpool"}) {
2952b9b8 1130 push @{$config{defines}}, "WHIRLPOOL_ASM";
46d4d865 1131 }
9e0724a1 1132 }
9fe2bb77 1133 if ($target{modes_asm_src} =~ /ghash-/) {
bcb1977b 1134 push @{$config{defines}}, "GHASH_ASM";
9e0724a1 1135 }
9fe2bb77 1136 if ($target{ec_asm_src} =~ /ecp_nistz256/) {
bcb1977b 1137 push @{$config{defines}}, "ECP_NISTZ256_ASM";
9e0724a1 1138 }
9fe2bb77 1139 if ($target{poly1305_asm_src} ne "") {
bcb1977b 1140 push @{$config{defines}}, "POLY1305_ASM";
9e0724a1
RL		 1141 }
1142}
d02b48c6 1143
8ed40b83 1144my $ecc = $target{cc};
09aa263a 1145if ($^O ne "VMS" && !$disabled{makedepend}) {
a583fc45
RL		 1146 # Is the compiler gcc or clang? $ecc is used below to see if
1147 # error-checking can be turned on.
1148 my $ccpcc = "$config{cross_compile_prefix}$target{cc}";
d0db7ee0
AP		 1149 open(PIPE, "$ccpcc --version 2>&1 |");
1150 my $lines = 2;
a583fc45 1151 while ( <PIPE> ) {
30752dd7
RL		 1152 # Find the version number and save the major.
1153 m|(?:.*)\b(\d+)\.\d+\.\d+\b(?:.*)|;
39affe19 1154 my $compiler_major = $1;
30752dd7
RL		 1155 # We know that GNU C version 3 and up as well as all clang
1156 # versions support dependency generation
39affe19 1157 $config{makedepprog} = $ccpcc
d0db7ee0 1158 if (/clang/ || (/gcc/ && $compiler_major > 3));
a583fc45
RL		 1159 $ecc = "clang" if /clang/;
1160 $ecc = "gcc" if /gcc/;
d0db7ee0 1161 last if ($config{makedepprog} || !$lines--);
a583fc45
RL		 1162 }
1163 close(PIPE);
09aa263a 1164
656bbdc6 1165 $config{makedepprog} = which('makedepend') unless $config{makedepprog};
09aa263a 1166 $disabled{makedepend} = "unavailable" unless $config{makedepprog};
f1f07a23 1167}
8ed40b83 1168
7d130f68 1169
09aa263a 1170
7d130f68
RL		 1171# Deal with bn_ops ###################################################
1172
7d130f68 1173$config{bn_ll} =0;
7d130f68
RL		 1174$config{export_var_as_fn} =0;
1175my $def_int="unsigned int";
1176$config{rc4_int} =$def_int;
b4f35e5e 1177($config{b64l},$config{b64},$config{b32})=(0,0,1);
7d130f68 1178
94af0cd7 1179my $count = 0;
7d130f68 1180foreach (sort split(/\s+/,$target{bn_ops})) {
94af0cd7
RS		 1181 $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1182 $config{export_var_as_fn}=1 if $_ eq 'EXPORT_VAR_AS_FN';
1183 $config{bn_ll}=1 if $_ eq 'BN_LLONG';
1184 $config{rc4_int}="unsigned char" if $_ eq 'RC4_CHAR';
1185 ($config{b64l},$config{b64},$config{b32})
1186 =(0,1,0) if $_ eq 'SIXTY_FOUR_BIT';
1187 ($config{b64l},$config{b64},$config{b32})
1188 =(1,0,0) if $_ eq 'SIXTY_FOUR_BIT_LONG';
1189 ($config{b64l},$config{b64},$config{b32})
1190 =(0,0,1) if $_ eq 'THIRTY_TWO_BIT';
7d130f68 1191}
94af0cd7
RS		 1192die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1193 if $count > 1;
7d130f68
RL		 1194
1195
1196# Hack cflags for better warnings (dev option) #######################
1197
1ed0c662
RL		 1198# "Stringify" the C flags string. This permits it to be made part of a string
1199# and works as well on command lines.
01d99976 1200$config{cflags} =~ s/([\\\"])/\\$1/g;
b436a982 1201
107b5792
RL		 1202if (defined($config{api})) {
1203 $config{openssl_api_defines} = [ "OPENSSL_MIN_API=".$apitable->{$config{api}} ];
bcb1977b 1204 my $apiflag = sprintf("OPENSSL_API_COMPAT=%s", $apitable->{$config{api}});
bcb1977b 1205 push @{$config{defines}}, $apiflag;
98186eb4
VD		 1206}
1207
0c28f277
DSH		 1208if ($strict_warnings)
1209 {
1210 my $wopt;
f1f07a23
RS		 1211 die "ERROR --strict-warnings requires gcc or clang"
1212 unless $ecc eq 'gcc' || $ecc eq 'clang';
0c28f277
DSH		 1213 foreach $wopt (split /\s+/, $gcc_devteam_warn)
1214 {
d918f9cb 1215 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
0c28f277 1216 }
190c8c60
BL		 1217 if ($ecc eq "clang")
1218 {
1219 foreach $wopt (split /\s+/, $clang_devteam_warn)
1220 {
d918f9cb 1221 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
190c8c60
BL		 1222 }
1223 }
ef8ca6bd
RL		 1224 }
1225
1226unless ($disabled{"crypto-mdebug-backtrace"})
1227 {
1228 foreach my $wopt (split /\s+/, $memleak_devteam_backtrace)
a1d3f3d1 1229 {
d918f9cb 1230 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
ef8ca6bd
RL		 1231 }
1232 if ($target =~ /^BSD-/)
1233 {
1234 $config{ex_libs} .= " -lexecinfo";
291e94df 1235 }
0c28f277
DSH		 1236 }
1237
63994098
RL		 1238if ($user_cflags ne "") { $config{cflags}="$config{cflags}$user_cflags"; }
1239else { $no_user_cflags=1; }
1240if (@user_defines) { $config{defines}=[ @{$config{defines}}, @user_defines ]; }
1241else { $no_user_defines=1; }
1242
1243# ALL MODIFICATIONS TO %config and %target MUST BE DONE FROM HERE ON
1244
c91a0a83
EK		 1245unless ($disabled{afalgeng}) {
1246 $config{afalgeng}="";
79fff39d
RL		 1247 if ($target =~ m/^linux/) {
1248 my $minver = 4*10000 + 1*100 + 0;
1249 if ($config{cross_compile_prefix} eq "") {
1250 my $verstr = `uname -r`;
1251 my ($ma, $mi1, $mi2) = split("\\.", $verstr);
1252 ($mi2) = $mi2 =~ /(\d+)/;
1253 my $ver = $ma*10000 + $mi1*100 + $mi2;
1254 if ($ver < $minver) {
c91a0a83 1255 $disabled{afalgeng} = "too-old-kernel";
79fff39d
RL		 1256 } else {
1257 push @{$config{engdirs}}, "afalg";
1258 }
68dc37c1
MC		 1259 } else {
1260 $disabled{afalgeng} = "cross-compiling";
6cba4a66 1261 }
79fff39d 1262 } else {
c91a0a83 1263 $disabled{afalgeng} = "not-linux";
7f458a48 1264 }
1265}
8da00a38 1266
c91a0a83 1267push @{$config{openssl_other_defines}}, "OPENSSL_NO_AFALGENG" if ($disabled{afalgeng});
7f458a48 1268
9fe2bb77
RL		 1269# If we use the unified build, collect information from build.info files
1270my %unified_info = ();
1271
2b6b606c 1272my $buildinfo_debug = defined($ENV{CONFIGURE_DEBUG_BUILDINFO});
ddf1847d
RL		 1273if ($builder eq "unified") {
1274 # Store the name of the template file we will build the build file from
1275 # in %config. This may be useful for the build file itself.
38add230
RL		 1276 my $build_file_template;
1277
1278 for my $filename (( $builder_platform."-".$target{build_file}.".tmpl",
1279 $target{build_file}.".tmpl" )) {
1280 if (defined $ENV{$local_config_envname}) {
1281 if ($^O eq 'VMS') {
1282 # VMS environment variables are logical names,
1283 # which can be used as is
1284 $build_file_template = $local_config_envname . ':' . $filename;
1285 } else {
1286 $build_file_template = catfile($ENV{$local_config_envname},
1287 $filename);
1288 }
1289 }
1290
1291 last if -f $build_file_template;
1292
1293 $build_file_template = catfile($srcdir, "Configurations", $filename);
1294
1295 last if -f $build_file_template;
1296 }
ddf1847d
RL		 1297 $config{build_file_template} = $build_file_template;
1298
9fe2bb77
RL		 1299 use lib catdir(dirname(__FILE__),"util");
1300 use with_fallback qw(Text::Template);
1301
9fe2bb77 1302 sub cleandir {
2e963849 1303 my $base = shift;
9fe2bb77 1304 my $dir = shift;
2e963849
RL		 1305 my $relativeto = shift || ".";
1306
1307 $dir = catdir($base,$dir) unless isabsolute($dir);
9fe2bb77 1308
ec182ef0
RL		 1309 # Make sure the directories we're building in exists
1310 mkpath($dir);
1311
2e963849 1312 my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
9fe2bb77
RL		 1313 #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1314 return $res;
1315 }
1316
1317 sub cleanfile {
2e963849 1318 my $base = shift;
9fe2bb77 1319 my $file = shift;
2e963849
RL		 1320 my $relativeto = shift || ".";
1321
1322 $file = catfile($base,$file) unless isabsolute($file);
1323
9fe2bb77
RL		 1324 my $d = dirname($file);
1325 my $f = basename($file);
1326
ec182ef0
RL		 1327 # Make sure the directories we're building in exists
1328 mkpath($d);
1329
2e963849 1330 my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
9fe2bb77
RL		 1331 #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1332 return $res;
1333 }
1334
1335 my @build_infos = ( [ ".", "build.info" ] );
1336 foreach (@{$config{dirs}}) {
1337 push @build_infos, [ $_, "build.info" ]
1338 if (-f catfile($srcdir, $_, "build.info"));
1339 }
1340 foreach (@{$config{sdirs}}) {
1341 push @build_infos, [ catdir("crypto", $_), "build.info" ]
1342 if (-f catfile($srcdir, "crypto", $_, "build.info"));
1343 }
1344 foreach (@{$config{engdirs}}) {
1345 push @build_infos, [ catdir("engines", $_), "build.info" ]
1346 if (-f catfile($srcdir, "engines", $_, "build.info"));
1347 }
1348
2e0956ba
RL		 1349 $config{build_infos} = [ ];
1350
9fe2bb77
RL		 1351 foreach (@build_infos) {
1352 my $sourced = catdir($srcdir, $_->[0]);
1353 my $buildd = catdir($blddir, $_->[0]);
1354
dca99383 1355 mkpath($buildd);
9fe2bb77
RL		 1356
1357 my $f = $_->[1];
1358 # The basic things we're trying to build
1359 my @programs = ();
1360 my @libraries = ();
1361 my @engines = ();
1362 my @scripts = ();
1363 my @extra = ();
8a67946e 1364 my @overrides = ();
9fe2bb77
RL		 1365 my @intermediates = ();
1366 my @rawlines = ();
1367
1368 my %ordinals = ();
1369 my %sources = ();
2a08d1a0 1370 my %shared_sources = ();
9fe2bb77
RL		 1371 my %includes = ();
1372 my %depends = ();
1373 my %renames = ();
1374 my %sharednames = ();
ae4c7450 1375 my %generate = ();
9fe2bb77 1376
2e0956ba 1377 push @{$config{build_infos}}, catfile(abs2rel($sourced, $blddir), $f);
9fe2bb77
RL		 1378 my $template = Text::Template->new(TYPE => 'FILE',
1379 SOURCE => catfile($sourced, $f));
1380 die "Something went wrong with $sourced/$f: $!\n" unless $template;
1381 my @text =
1382 split /^/m,
1383 $template->fill_in(HASH => { config => \%config,
1384 target => \%target,
9e04edf2 1385 disabled => \%disabled,
f59d0131 1386 withargs => \%withargs,
9fe2bb77
RL		 1387 builddir => abs2rel($buildd, $blddir),
1388 sourcedir => abs2rel($sourced, $blddir),
1389 buildtop => abs2rel($blddir, $blddir),
1390 sourcetop => abs2rel($srcdir, $blddir) },
1391 DELIMITERS => [ "{-", "-}" ]);
1392
1393 # The top item of this stack has the following values
1394 # -2 positive already run and we found ELSE (following ELSIF should fail)
1395 # -1 positive already run (skip until ENDIF)
1396 # 0 negatives so far (if we're at a condition, check it)
1397 # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
1398 # 2 positive ELSE (following ELSIF should fail)
1399 my @skip = ();
1400 collect_information(
1401 collect_from_array([ @text ],
1402 qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
1403 $l1 =~ s/\\$//; $l1.$l2 }),
1404 # Info we're looking for
1405 qr/^\s*IF\[((?:\\.|[^\\\]])*)\]\s*$/
635bd409 1406 => sub {
c5798e0e 1407 if (! @skip || $skip[$#skip] > 0) {
635bd409
RL		 1408 push @skip, !! $1;
1409 } else {
1410 push @skip, -1;
1411 }
1412 },
9fe2bb77
RL		 1413 qr/^\s*ELSIF\[((?:\\.|[^\\\]])*)\]\s*$/
1414 => sub { die "ELSIF out of scope" if ! @skip;
1415 die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
1416 $skip[$#skip] = -1 if $skip[$#skip] != 0;
1417 $skip[$#skip] = !! $1
1418 if $skip[$#skip] == 0; },
1419 qr/^\s*ELSE\s*$/
1420 => sub { die "ELSE out of scope" if ! @skip;
1421 $skip[$#skip] = -2 if $skip[$#skip] != 0;
1422 $skip[$#skip] = 2 if $skip[$#skip] == 0; },
1423 qr/^\s*ENDIF\s*$/
1424 => sub { die "ENDIF out of scope" if ! @skip;
1425 pop @skip; },
1426 qr/^\s*PROGRAMS\s*=\s*(.*)\s*$/
ce959812 1427 => sub { push @programs, tokenize($1)
9fe2bb77
RL		 1428 if !@skip || $skip[$#skip] > 0 },
1429 qr/^\s*LIBS\s*=\s*(.*)\s*$/
ce959812 1430 => sub { push @libraries, tokenize($1)
9fe2bb77
RL		 1431 if !@skip || $skip[$#skip] > 0 },
1432 qr/^\s*ENGINES\s*=\s*(.*)\s*$/
ce959812 1433 => sub { push @engines, tokenize($1)
9fe2bb77
RL		 1434 if !@skip || $skip[$#skip] > 0 },
1435 qr/^\s*SCRIPTS\s*=\s*(.*)\s*$/
ce959812 1436 => sub { push @scripts, tokenize($1)
9fe2bb77
RL		 1437 if !@skip || $skip[$#skip] > 0 },
1438 qr/^\s*EXTRA\s*=\s*(.*)\s*$/
ce959812 1439 => sub { push @extra, tokenize($1)
9fe2bb77 1440 if !@skip || $skip[$#skip] > 0 },
8a67946e 1441 qr/^\s*OVERRIDES\s*=\s*(.*)\s*$/
ce959812 1442 => sub { push @overrides, tokenize($1)
8a67946e 1443 if !@skip || $skip[$#skip] > 0 },
9fe2bb77
RL		 1444
1445 qr/^\s*ORDINALS\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/,
ce959812 1446 => sub { push @{$ordinals{$1}}, tokenize($2)
9fe2bb77
RL		 1447 if !@skip || $skip[$#skip] > 0 },
1448 qr/^\s*SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1449 => sub { push @{$sources{$1}}, tokenize($2)
9fe2bb77 1450 if !@skip || $skip[$#skip] > 0 },
2a08d1a0 1451 qr/^\s*SHARED_SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1452 => sub { push @{$shared_sources{$1}}, tokenize($2)
2a08d1a0 1453 if !@skip || $skip[$#skip] > 0 },
9fe2bb77 1454 qr/^\s*INCLUDE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1455 => sub { push @{$includes{$1}}, tokenize($2)
9fe2bb77 1456 if !@skip || $skip[$#skip] > 0 },
4f858293 1457 qr/^\s*DEPEND\[((?:\\.|[^\\\]])*)\]\s*=\s*(.*)\s*$/
ce959812 1458 => sub { push @{$depends{$1}}, tokenize($2)
9fe2bb77 1459 if !@skip || $skip[$#skip] > 0 },
ae4c7450
RL		 1460 qr/^\s*GENERATE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1461 => sub { push @{$generate{$1}}, $2
1462 if !@skip || $skip[$#skip] > 0 },
9fe2bb77 1463 qr/^\s*RENAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1464 => sub { push @{$renames{$1}}, tokenize($2)
9fe2bb77
RL		 1465 if !@skip || $skip[$#skip] > 0 },
1466 qr/^\s*SHARED_NAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1467 => sub { push @{$sharednames{$1}}, tokenize($2)
9fe2bb77
RL		 1468 if !@skip || $skip[$#skip] > 0 },
1469 qr/^\s*BEGINRAW\[((?:\\.|[^\\\]])+)\]\s*$/
1470 => sub {
1471 my $lineiterator = shift;
1472 my $target_kind = $1;
1473 while (defined $lineiterator->()) {
04f171c0 1474 s|\R$||;
9fe2bb77
RL		 1475 if (/^\s*ENDRAW\[((?:\\.|[^\\\]])+)\]\s*$/) {
1476 die "ENDRAW doesn't match BEGINRAW"
1477 if $1 ne $target_kind;
1478 last;
1479 }
1480 next if @skip && $skip[$#skip] <= 0;
1481 push @rawlines, $_
1482 if ($target_kind eq $target{build_file}
ddf1847d 1483 || $target_kind eq $target{build_file}."(".$builder_platform.")");
9fe2bb77
RL		 1484 }
1485 },
1486 qr/^(?:#.*|\s*)$/ => sub { },
2b6b606c
RL		 1487 "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" },
1488 "BEFORE" => sub {
1489 if ($buildinfo_debug) {
1490 print STDERR "DEBUG: Parsing ",join(" ", @_),"\n";
1491 print STDERR "DEBUG: ... before parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1492 }
1493 },
1494 "AFTER" => sub {
1495 if ($buildinfo_debug) {
1496 print STDERR "DEBUG: .... after parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1497 }
1498 },
9fe2bb77
RL		 1499 );
1500 die "runaway IF?" if (@skip);
1501
1502 foreach (keys %renames) {
1503 die "$_ renamed to more than one thing: "
1504 ,join(" ", @{$renames{$_}}),"\n"
1505 if scalar @{$renames{$_}} > 1;
2e963849
RL		 1506 my $dest = cleanfile($buildd, $_, $blddir);
1507 my $to = cleanfile($buildd, $renames{$_}->[0], $blddir);
9fe2bb77
RL		 1508 die "$dest renamed to more than one thing: "
1509 ,$unified_info{rename}->{$dest}, $to
1510 unless !defined($unified_info{rename}->{$dest})
1511 or $unified_info{rename}->{$dest} eq $to;
1512 $unified_info{rename}->{$dest} = $to;
1513 }
1514
1515 foreach (@programs) {
2e963849 1516 my $program = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1517 if ($unified_info{rename}->{$program}) {
1518 $program = $unified_info{rename}->{$program};
1519 }
1520 $unified_info{programs}->{$program} = 1;
1521 }
1522
1523 foreach (@libraries) {
2e963849 1524 my $library = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1525 if ($unified_info{rename}->{$library}) {
1526 $library = $unified_info{rename}->{$library};
1527 }
1528 $unified_info{libraries}->{$library} = 1;
1529 }
1530
343ec2b0 1531 die <<"EOF" if scalar @engines and !$config{dynamic_engines};
19ab5790 1532ENGINES can only be used if configured with 'dynamic-engine'.
9fe2bb77
RL		 1533This is usually a fault in a build.info file.
1534EOF
1535 foreach (@engines) {
2e963849 1536 my $library = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1537 if ($unified_info{rename}->{$library}) {
1538 $library = $unified_info{rename}->{$library};
1539 }
1540 $unified_info{engines}->{$library} = 1;
1541 }
1542
1543 foreach (@scripts) {
2e963849 1544 my $script = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1545 if ($unified_info{rename}->{$script}) {
1546 $script = $unified_info{rename}->{$script};
1547 }
1548 $unified_info{scripts}->{$script} = 1;
1549 }
1550
1551 foreach (@extra) {
2e963849 1552 my $extra = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1553 $unified_info{extra}->{$extra} = 1;
1554 }
1555
8a67946e
RL		 1556 foreach (@overrides) {
1557 my $override = cleanfile($buildd, $_, $blddir);
1558 $unified_info{overrides}->{$override} = 1;
1559 }
1560
9fe2bb77
RL		 1561 push @{$unified_info{rawlines}}, @rawlines;
1562
84af1bae 1563 unless ($disabled{shared}) {
9fe2bb77
RL		 1564 # Check sharednames.
1565 foreach (keys %sharednames) {
2e963849 1566 my $dest = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1567 if ($unified_info{rename}->{$dest}) {
1568 $dest = $unified_info{rename}->{$dest};
1569 }
1570 die "shared_name for $dest with multiple values: "
1571 ,join(" ", @{$sharednames{$_}}),"\n"
1572 if scalar @{$sharednames{$_}} > 1;
2e963849 1573 my $to = cleanfile($buildd, $sharednames{$_}->[0], $blddir);
9fe2bb77
RL		 1574 die "shared_name found for a library $dest that isn't defined\n"
1575 unless $unified_info{libraries}->{$dest};
1576 die "shared_name for $dest with multiple values: "
1577 ,$unified_info{sharednames}->{$dest}, ", ", $to
1578 unless !defined($unified_info{sharednames}->{$dest})
1579 or $unified_info{sharednames}->{$dest} eq $to;
1580 $unified_info{sharednames}->{$dest} = $to;
1581 }
1582
1583 # Additionally, we set up sharednames for libraries that don't
1584 # have any, as themselves.
1585 foreach (keys %{$unified_info{libraries}}) {
1586 if (!defined $unified_info{sharednames}->{$_}) {
1587 $unified_info{sharednames}->{$_} = $_
1588 }
1589 }
1590 }
1591
1592 foreach (keys %ordinals) {
1593 my $dest = $_;
2e963849 1594 my $ddest = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1595 if ($unified_info{rename}->{$ddest}) {
1596 $ddest = $unified_info{rename}->{$ddest};
1597 }
1598 foreach (@{$ordinals{$dest}}) {
1599 my %known_ordinals =
1600 (
1601 crypto =>
6928b617 1602 cleanfile($sourced, catfile("util", "libcrypto.num"), $blddir),
9fe2bb77 1603 ssl =>
6928b617 1604 cleanfile($sourced, catfile("util", "libssl.num"), $blddir)
9fe2bb77
RL		 1605 );
1606 my $o = $known_ordinals{$_};
1607 die "Ordinals for $ddest defined more than once\n"
1608 if $unified_info{ordinals}->{$ddest};
1609 $unified_info{ordinals}->{$ddest} = [ $_, $o ];
1610 }
1611 }
1612
1613 foreach (keys %sources) {
1614 my $dest = $_;
2e963849 1615 my $ddest = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1616 if ($unified_info{rename}->{$ddest}) {
1617 $ddest = $unified_info{rename}->{$ddest};
1618 }
1619 foreach (@{$sources{$dest}}) {
2e963849 1620 my $s = cleanfile($sourced, $_, $blddir);
9fe2bb77
RL		 1621
1622 # If it isn't in the source tree, we assume it's generated
1623 # in the build tree
1624 if (! -f $s) {
2e963849 1625 $s = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1626 }
1627 # We recognise C and asm files
1628 if ($s =~ /\.[csS]\b$/) {
1629 (my $o = $_) =~ s/\.[csS]\b$/.o/;
2e963849 1630 $o = cleanfile($buildd, $o, $blddir);
9fe2bb77
RL		 1631 $unified_info{sources}->{$ddest}->{$o} = 1;
1632 $unified_info{sources}->{$o}->{$s} = 1;
1633 } else {
1634 $unified_info{sources}->{$ddest}->{$s} = 1;
1635 }
1636 }
1637 }
1638
2a08d1a0
RL		 1639 foreach (keys %shared_sources) {
1640 my $dest = $_;
1641 my $ddest = cleanfile($buildd, $_, $blddir);
1642 if ($unified_info{rename}->{$ddest}) {
1643 $ddest = $unified_info{rename}->{$ddest};
1644 }
1645 foreach (@{$shared_sources{$dest}}) {
1646 my $s = cleanfile($sourced, $_, $blddir);
1647
1648 # If it isn't in the source tree, we assume it's generated
1649 # in the build tree
1650 if (! -f $s) {
1651 $s = cleanfile($buildd, $_, $blddir);
1652 }
1653 # We recognise C and asm files
1654 if ($s =~ /\.[csS]\b$/) {
1655 (my $o = $_) =~ s/\.[csS]\b$/.o/;
1656 $o = cleanfile($buildd, $o, $blddir);
1657 $unified_info{shared_sources}->{$ddest}->{$o} = 1;
1658 $unified_info{sources}->{$o}->{$s} = 1;
1659 } else {
1660 die "unrecognised source file type for shared library: $s\n";
1661 }
1662 }
1663 }
1664
ae4c7450
RL		 1665 foreach (keys %generate) {
1666 my $dest = $_;
1667 my $ddest = cleanfile($buildd, $_, $blddir);
1668 if ($unified_info{rename}->{$ddest}) {
1669 $ddest = $unified_info{rename}->{$ddest};
1670 }
1671 die "more than one generator for $dest: "
1672 ,join(" ", @{$generate{$_}}),"\n"
1673 if scalar @{$generate{$_}} > 1;
1674 my @generator = split /\s+/, $generate{$dest}->[0];
1675 $generator[0] = cleanfile($sourced, $generator[0], $blddir),
1676 $unified_info{generate}->{$ddest} = [ @generator ];
1677 }
1678
9fe2bb77
RL		 1679 foreach (keys %depends) {
1680 my $dest = $_;
4f858293 1681 my $ddest = $dest eq "" ? "" : cleanfile($sourced, $_, $blddir);
8d34daf0
RL		 1682
1683 # If the destination doesn't exist in source, it can only be
1684 # a generated file in the build tree.
4f858293 1685 if ($ddest ne "" && ! -f $ddest) {
8d34daf0
RL		 1686 $ddest = cleanfile($buildd, $_, $blddir);
1687 if ($unified_info{rename}->{$ddest}) {
1688 $ddest = $unified_info{rename}->{$ddest};
1689 }
9fe2bb77
RL		 1690 }
1691 foreach (@{$depends{$dest}}) {
2e963849 1692 my $d = cleanfile($sourced, $_, $blddir);
9fe2bb77 1693
e737d7b1
RL		 1694 # If we know it's generated, or assume it is because we can't
1695 # find it in the source tree, we set file we depend on to be
1696 # in the build tree rather than the source tree, and assume
1697 # and that there are lines to build it in a BEGINRAW..ENDRAW
1698 # section or in the Makefile template.
1699 if (! -f $d
da1f2104
RL		 1700 || (grep { $d eq $_ }
1701 map { cleanfile($srcdir, $_, $blddir) }
4f858293 1702 grep { /\.h$/ } keys %{$unified_info{generate}})) {
2e963849 1703 $d = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1704 }
1705 # Take note if the file to depend on is being renamed
1706 if ($unified_info{rename}->{$d}) {
1707 $d = $unified_info{rename}->{$d};
1708 }
1709 $unified_info{depends}->{$ddest}->{$d} = 1;
8d34daf0
RL		 1710 # If we depend on a header file or a perl module, let's make
1711 # sure it can get included
4f858293 1712 if ($dest ne "" && $d =~ /\.(h|pm)$/) {
9fe2bb77
RL		 1713 my $i = dirname($d);
1714 push @{$unified_info{includes}->{$ddest}}, $i
1715 unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}};
1716 }
1717 }
1718 }
1719
1720 foreach (keys %includes) {
1721 my $dest = $_;
8d34daf0
RL		 1722 my $ddest = cleanfile($sourced, $_, $blddir);
1723
1724 # If the destination doesn't exist in source, it can only be
1725 # a generated file in the build tree.
1726 if (! -f $ddest) {
1727 $ddest = cleanfile($buildd, $_, $blddir);
1728 if ($unified_info{rename}->{$ddest}) {
1729 $ddest = $unified_info{rename}->{$ddest};
1730 }
9fe2bb77
RL		 1731 }
1732 foreach (@{$includes{$dest}}) {
2e963849 1733 my $i = cleandir($sourced, $_, $blddir);
9fe2bb77
RL		 1734 push @{$unified_info{includes}->{$ddest}}, $i
1735 unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}};
1736 }
1737 }
1738 }
1739
1740 ### Make unified_info a bit more efficient
1741 # One level structures
8a67946e 1742 foreach (("programs", "libraries", "engines", "scripts", "extra", "overrides")) {
9fe2bb77
RL		 1743 $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
1744 }
1745 # Two level structures
2a08d1a0 1746 foreach my $l1 (("sources", "shared_sources", "ldadd", "depends")) {
9fe2bb77
RL		 1747 foreach my $l2 (sort keys %{$unified_info{$l1}}) {
1748 $unified_info{$l1}->{$l2} =
1749 [ sort keys %{$unified_info{$l1}->{$l2}} ];
1750 }
1751 }
1752}
1753
1754# For the schemes that need it, we provide the old *_obj configs
1755# from the *_asm_obj ones
3a55c92b 1756foreach (grep /_(asm|aux)_src$/, keys %target) {
9fe2bb77 1757 my $src = $_;
3a55c92b 1758 (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
9fe2bb77
RL		 1759 ($target{$obj} = $target{$src}) =~ s/\.[csS]\b/.o/g;
1760}
1761
291e94df
RL		 1762# Write down our configuration where it fits #########################
1763
1764open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
1765print OUT <<"EOF";
1766package configdata;
1767
1768use strict;
1769use warnings;
1770
1771use Exporter;
1772#use vars qw(\@ISA \@EXPORT);
1773our \@ISA = qw(Exporter);
3850f8cb 1774our \@EXPORT = qw(\%config \%target \%disabled \%withargs \%unified_info \@disablables);
291e94df
RL		 1775
1776EOF
1777print OUT "our %config = (\n";
1778foreach (sort keys %config) {
1779 if (ref($config{$_}) eq "ARRAY") {
1780 print OUT " ", $_, " => [ ", join(", ",
1781 map { quotify("perl", $_) }
1782 @{$config{$_}}), " ],\n";
1783 } else {
1784 print OUT " ", $_, " => ", quotify("perl", $config{$_}), ",\n"
1785 }
1786}
1787print OUT <<"EOF";
1788);
1789
1790EOF
1791print OUT "our %target = (\n";
1792foreach (sort keys %target) {
1793 if (ref($target{$_}) eq "ARRAY") {
1794 print OUT " ", $_, " => [ ", join(", ",
1795 map { quotify("perl", $_) }
1796 @{$target{$_}}), " ],\n";
1797 } else {
1798 print OUT " ", $_, " => ", quotify("perl", $target{$_}), ",\n"
1799 }
1800}
1801print OUT <<"EOF";
1802);
1803
96d2d7bc
RL		 1804EOF
1805print OUT "our \%available_protocols = (\n";
1806print OUT " tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n";
1807print OUT " dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n";
1808print OUT <<"EOF";
1809);
1810
3850f8cb
RL		 1811EOF
1812print OUT "our \@disablables = (\n";
1813foreach (@disablables) {
1814 print OUT " ", quotify("perl", $_), ",\n";
1815}
1816print OUT <<"EOF";
1817);
1818
96d2d7bc
RL		 1819EOF
1820print OUT "our \%disabled = (\n";
1821foreach (sort keys %disabled) {
1822 print OUT " ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n";
1823}
1824print OUT <<"EOF";
1825);
1826
291e94df 1827EOF
107b5792
RL		 1828print OUT "our %withargs = (\n";
1829foreach (sort keys %withargs) {
1830 if (ref($withargs{$_}) eq "ARRAY") {
1831 print OUT " ", $_, " => [ ", join(", ",
1832 map { quotify("perl", $_) }
1833 @{$withargs{$_}}), " ],\n";
1834 } else {
1835 print OUT " ", $_, " => ", quotify("perl", $withargs{$_}), ",\n"
1836 }
1837}
1838print OUT <<"EOF";
1839);
edd4d402 1840
107b5792 1841EOF
ddf1847d 1842if ($builder eq "unified") {
9fe2bb77
RL		 1843 my $recurse;
1844 $recurse = sub {
1845 my $indent = shift;
1846 foreach (@_) {
1847 if (ref $_ eq "ARRAY") {
1848 print OUT " "x$indent, "[\n";
1849 foreach (@$_) {
1850 $recurse->($indent + 4, $_);
1851 }
1852 print OUT " "x$indent, "],\n";
1853 } elsif (ref $_ eq "HASH") {
1854 my %h = %$_;
1855 print OUT " "x$indent, "{\n";
1856 foreach (sort keys %h) {
1857 if (ref $h{$_} eq "") {
1858 print OUT " "x($indent + 4), quotify("perl", $_), " => ", quotify("perl", $h{$_}), ",\n";
1859 } else {
1860 print OUT " "x($indent + 4), quotify("perl", $_), " =>\n";
1861 $recurse->($indent + 8, $h{$_});
1862 }
1863 }
1864 print OUT " "x$indent, "},\n";
1865 } else {
1866 print OUT " "x$indent, quotify("perl", $_), ",\n";
1867 }
1868 }
1869 };
1870 print OUT "our %unified_info = (\n";
1871 foreach (sort keys %unified_info) {
1872 if (ref $unified_info{$_} eq "") {
1873 print OUT " "x4, quotify("perl", $_), " => ", quotify("perl", $unified_info{$_}), ",\n";
1874 } else {
1875 print OUT " "x4, quotify("perl", $_), " =>\n";
1876 $recurse->(8, $unified_info{$_});
1877 }
1878 }
1879 print OUT <<"EOF";
1880);
1881
1882EOF
1883}
1884print OUT "1;\n";
d02b48c6 1885close(OUT);
f2d4be3b 1886
9fe2bb77 1887
f58a0acb 1888print "CC =$config{cross_compile_prefix}$target{cc}\n";
2952b9b8 1889print "CFLAG =$target{cflags} $config{cflags}\n";
63ee7129 1890print "SHARED_CFLAG =$target{shared_cflag}\n";
2952b9b8 1891print "DEFINES =",join(" ", @{$target{defines}}, @{$config{defines}}),"\n";
940a09ba
RL		 1892print "LFLAG =$target{lflags}\n";
1893print "PLIB_LFLAG =$target{plib_lflags}\n";
2952b9b8 1894print "EX_LIBS =$target{ex_libs} $config{ex_libs}\n";
b756967d 1895print "APPS_OBJ =$target{apps_obj}\n";
291e94df 1896print "CPUID_OBJ =$target{cpuid_obj}\n";
b756967d 1897print "UPLINK_OBJ =$target{uplink_obj}\n";
291e94df
RL		 1898print "BN_ASM =$target{bn_obj}\n";
1899print "EC_ASM =$target{ec_obj}\n";
1900print "DES_ENC =$target{des_obj}\n";
1901print "AES_ENC =$target{aes_obj}\n";
1902print "BF_ENC =$target{bf_obj}\n";
1903print "CAST_ENC =$target{cast_obj}\n";
1904print "RC4_ENC =$target{rc4_obj}\n";
1905print "RC5_ENC =$target{rc5_obj}\n";
1906print "MD5_OBJ_ASM =$target{md5_obj}\n";
1907print "SHA1_OBJ_ASM =$target{sha1_obj}\n";
1908print "RMD160_OBJ_ASM=$target{rmd160_obj}\n";
1909print "CMLL_ENC =$target{cmll_obj}\n";
1910print "MODES_OBJ =$target{modes_obj}\n";
f0bd4686 1911print "PADLOCK_OBJ =$target{padlock_obj}\n";
291e94df
RL		 1912print "CHACHA_ENC =$target{chacha_obj}\n";
1913print "POLY1305_OBJ =$target{poly1305_obj}\n";
2d0b4412 1914print "BLAKE2_OBJ =$target{blake2_obj}\n";
7d130f68 1915print "PROCESSOR =$config{processor}\n";
f58a0acb
AP		 1916print "RANLIB =", $target{ranlib} eq '$(CROSS_COMPILE)ranlib' ?
1917 "$config{cross_compile_prefix}ranlib" :
1918 "$target{ranlib}", "\n";
291e94df
RL		 1919print "ARFLAGS =$target{arflags}\n";
1920print "PERL =$config{perl}\n";
f0bd4686 1921print "\n";
7d130f68
RL		 1922print "SIXTY_FOUR_BIT_LONG mode\n" if $config{b64l};
1923print "SIXTY_FOUR_BIT mode\n" if $config{b64};
1924print "THIRTY_TWO_BIT mode\n" if $config{b32};
7d130f68 1925print "BN_LLONG mode\n" if $config{bn_ll};
01d99976 1926print "RC4 uses $config{rc4_int}\n" if $config{rc4_int} ne $def_int;
cba5068d 1927
88087414 1928my %builders = (
9fe2bb77 1929 unified => sub {
ddf1847d
RL		 1930 run_dofile(catfile($blddir, $target{build_file}),
1931 $config{build_file_template},
1932 catfile($srcdir, "Configurations", "common.tmpl"));
9fe2bb77 1933 },
88087414
RL		 1934 );
1935
ddf1847d 1936$builders{$builder}->($builder_platform, @builder_opts);
fce0ba5f 1937
76ffb43d 1938print <<"EOF";
63d3f44a 1939
89ec98e0 1940Configured for $target.
63d3f44a 1941EOF
5f8d5c96 1942
9c62a279 1943print <<"EOF" if ($disabled{threads} eq "unavailable");
5f8d5c96
BM		 1944
1945The library could not be configured for supporting multi-threaded
1946applications as the compiler options required on this system are not known.
ff1b7e09 1947See file INSTALL for details if you need multi-threading.
ec577822
BM		 1948EOF
1949
76ffb43d 1950print <<"EOF" if ($no_shared_warn);
2964ba8c 1951
ae48242c
RL		 1952The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
1953platform, so we will pretend you gave the option 'no-pic', which also disables
1954'shared' and 'dynamic-engine'. If you know how to implement shared libraries
1955or position independent code, please let us know (but please first make sure
1956you have tried with a current version of OpenSSL).
2e31ef03
RS		 1957EOF
1958
ddc606c9
RL		 1959print <<"EOF" if (-f catfile($srcdir, "configdata.pm") && $srcdir ne $blddir);
1960
1961WARNING: there are indications that another build was made in the source
1962directory. This build may have picked up artifacts from that build, the
1963safest course of action is to clean the source directory and redo this
1964configuration.
1965EOF
1966
d02b48c6
RE		 1967exit(0);
1968
bd5192b1
RL		 1969######################################################################
1970#
1971# Helpers and utility functions
1972#
1973
1974# Configuration file reading #########################################
1975
1f2e1cd5
RL		 1976# Note: All of the helper functions are for lazy evaluation. They all
1977# return a CODE ref, which will return the intended value when evaluated.
1978# Thus, whenever there's mention of a returned value, it's about that
1979# intended value.
1980
bd5192b1 1981# Helper function to implement conditional inheritance depending on the
00b0d663 1982# value of $disabled{asm}. Used in inherit_from values as follows:
bd5192b1
RL		 1983#
1984# inherit_from => [ "template", asm("asm_tmpl") ]
1985#
1986sub asm {
1987 my @x = @_;
1988 sub {
00b0d663 1989 $disabled{asm} ? () : @x;
bd5192b1
RL		 1990 }
1991}
1992
1f2e1cd5
RL		 1993# Helper function to implement conditional value variants, with a default
1994# plus additional values based on the value of $config{build_type}.
1995# Arguments are given in hash table form:
1996#
1997# picker(default => "Basic string: ",
1998# debug => "debug",
1999# release => "release")
2000#
2001# When configuring with --debug, the resulting string will be
2002# "Basic string: debug", and when not, it will be "Basic string: release"
2003#
2004# This can be used to create variants of sets of flags according to the
2005# build type:
2006#
2007# cflags => picker(default => "-Wall",
2008# debug => "-g -O0",
2009# release => "-O3")
2010#
2011sub picker {
2012 my %opts = @_;
2013 return sub { add($opts{default} || (),
2014 $opts{$config{build_type}} || ())->(); }
2015}
2016
2017# Helper function to combine several values of different types into one.
2018# This is useful if you want to combine a string with the result of a
2019# lazy function, such as:
2020#
2021# cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
2022#
2023sub combine {
2024 my @stuff = @_;
2025 return sub { add(@stuff)->(); }
2026}
2027
2028# Helper function to implement conditional values depending on the value
2029# of $disabled{threads}. Can be used as follows:
2030#
2031# cflags => combine("-Wall", threads("-pthread"))
2032#
2033sub threads {
2034 my @flags = @_;
2035 return sub { add($disabled{threads} ? () : @flags)->(); }
2036}
2037
2038
2039
9c62a279 2040our $add_called = 0;
88087414
RL		 2041# Helper function to implement adding values to already existing configuration
2042# values. It handles elements that are ARRAYs, CODEs and scalars
2043sub _add {
2044 my $separator = shift;
2045
bcb1977b
RL		 2046 # If there's any ARRAY in the collection of values OR the separator
2047 # is undef, we will return an ARRAY of combined values, otherwise a
2048 # string of joined values with $separator as the separator.
2049 my $found_array = !defined($separator);
88087414
RL		 2050
2051 my @values =
2052 map {
b0b92a5b
RL		 2053 my $res = $_;
2054 while (ref($res) eq "CODE") {
2055 $res = $res->();
2056 }
2057 if (defined($res)) {
2058 if (ref($res) eq "ARRAY") {
2059 $found_array = 1;
2060 @$res;
2061 } else {
2062 $res;
2063 }
88087414 2064 } else {
b0b92a5b 2065 ();
88087414
RL		 2066 }
2067 } (@_);
2068
9c62a279
RL		 2069 $add_called = 1;
2070
88087414
RL		 2071 if ($found_array) {
2072 [ @values ];
2073 } else {
b0b92a5b 2074 join($separator, grep { defined($_) && $_ ne "" } @values);
88087414
RL		 2075 }
2076}
2077sub add_before {
bdcd83e1
RL		 2078 my $separator = " ";
2079 if (ref($_[$#_]) eq "HASH") {
2080 my $opts = pop;
2081 $separator = $opts->{separator};
2082 }
88087414
RL		 2083 my @x = @_;
2084 sub { _add($separator, @x, @_) };
2085}
2086sub add {
bdcd83e1
RL		 2087 my $separator = " ";
2088 if (ref($_[$#_]) eq "HASH") {
2089 my $opts = pop;
2090 $separator = $opts->{separator};
2091 }
88087414
RL		 2092 my @x = @_;
2093 sub { _add($separator, @_, @x) };
2094}
2095
bd5192b1
RL		 2096# configuration reader, evaluates the input file as a perl script and expects
2097# it to fill %targets with target configurations. Those are then added to
2098# %table.
2099sub read_config {
2100 my $fname = shift;
2101 open(CONFFILE, "< $fname")
2102 or die "Can't open configuration file '$fname'!\n";
2103 my $x = $/;
2104 undef $/;
2105 my $content = <CONFFILE>;
2106 $/ = $x;
2107 close(CONFFILE);
2108 my %targets = ();
2109 {
2110 local %table = %::table; # Protect %table from tampering
2111
2112 eval $content;
2113 warn $@ if $@;
2114 }
2115
2116 # For each target, check that it's configured with a hash table.
2117 foreach (keys %targets) {
2118 if (ref($targets{$_}) ne "HASH") {
2119 if (ref($targets{$_}) eq "") {
2120 warn "Deprecated target configuration for $_, ignoring...\n";
2121 } else {
2122 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
2123 }
2124 delete $targets{$_};
2125 }
2126 }
2127
2128 %table = (%table, %targets);
2129
2130}
2131
8483a003
F		 2132# configuration resolver. Will only resolve all the lazy evaluation
2133# codeblocks for the chosen target and all those it inherits from,
bd5192b1
RL		 2134# recursively
2135sub resolve_config {
2136 my $target = shift;
2137 my @breadcrumbs = @_;
2138
c4718849 2139# my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
9c62a279 2140
bd5192b1
RL		 2141 if (grep { $_ eq $target } @breadcrumbs) {
2142 die "inherit_from loop! target backtrace:\n "
2143 ,$target,"\n ",join("\n ", @breadcrumbs),"\n";
2144 }
2145
2146 if (!defined($table{$target})) {
2147 warn "Warning! target $target doesn't exist!\n";
2148 return ();
2149 }
2150 # Recurse through all inheritances. They will be resolved on the
2151 # fly, so when this operation is done, they will all just be a
2152 # bunch of attributes with string values.
2153 # What we get here, though, are keys with references to lists of
2154 # the combined values of them all. We will deal with lists after
2155 # this stage is done.
2156 my %combined_inheritance = ();
2157 if ($table{$target}->{inherit_from}) {
2158 my @inherit_from =
2159 map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
2160 foreach (@inherit_from) {
2161 my %inherited_config = resolve_config($_, $target, @breadcrumbs);
2162
2163 # 'template' is a marker that's considered private to
2164 # the config that had it.
2165 delete $inherited_config{template};
2166
2110febb 2167 foreach (keys %inherited_config) {
bd5192b1
RL		 2168 if (!$combined_inheritance{$_}) {
2169 $combined_inheritance{$_} = [];
2170 }
2171 push @{$combined_inheritance{$_}}, $inherited_config{$_};
2110febb 2172 }
bd5192b1
RL		 2173 }
2174 }
2175
2176 # We won't need inherit_from in this target any more, since we've
2177 # resolved all the inheritances that lead to this
2178 delete $table{$target}->{inherit_from};
2179
2180 # Now is the time to deal with those lists. Here's the place to
2181 # decide what shall be done with those lists, all based on the
2182 # values of the target we're currently dealing with.
2183 # - If a value is a coderef, it will be executed with the list of
2184 # inherited values as arguments.
2185 # - If the corresponding key doesn't have a value at all or is the
8483a003 2186 # empty string, the inherited value list will be run through the
bd5192b1
RL		 2187 # default combiner (below), and the result becomes this target's
2188 # value.
2189 # - Otherwise, this target's value is assumed to be a string that
2190 # will simply override the inherited list of values.
a26d8be9 2191 my $default_combiner = add();
bd5192b1
RL		 2192
2193 my %all_keys =
2194 map { $_ => 1 } (keys %combined_inheritance,
2195 keys %{$table{$target}});
b0b92a5b
RL		 2196
2197 sub process_values {
2198 my $object = shift;
2199 my $inherited = shift; # Always a [ list ]
2200 my $target = shift;
2201 my $entry = shift;
2202
9c62a279
RL		 2203 $add_called = 0;
2204
b0b92a5b
RL		 2205 while(ref($object) eq "CODE") {
2206 $object = $object->(@$inherited);
2207 }
2208 if (!defined($object)) {
2209 return ();
2210 }
2211 elsif (ref($object) eq "ARRAY") {
9c62a279 2212 local $add_called; # To make sure recursive calls don't affect it
b0b92a5b
RL		 2213 return [ map { process_values($_, $inherited, $target, $entry) }
2214 @$object ];
2215 } elsif (ref($object) eq "") {
2216 return $object;
2217 } else {
2218 die "cannot handle reference type ",ref($object)
2219 ," found in target ",$target," -> ",$entry,"\n";
2220 }
2221 }
2222
bd5192b1 2223 foreach (sort keys %all_keys) {
9c62a279 2224 my $previous = $combined_inheritance{$_};
bd5192b1
RL		 2225
2226 # Current target doesn't have a value for the current key?
2227 # Assign it the default combiner, the rest of this loop body
2228 # will handle it just like any other coderef.
2229 if (!exists $table{$target}->{$_}) {
2230 $table{$target}->{$_} = $default_combiner;
2231 }
2232
b0b92a5b
RL		 2233 $table{$target}->{$_} = process_values($table{$target}->{$_},
2234 $combined_inheritance{$_},
2235 $target, $_);
2236 unless(defined($table{$target}->{$_})) {
2237 delete $table{$target}->{$_};
2238 }
c4718849
RL		 2239# if ($extra_checks &&
2240# $previous && !($add_called || $previous ~~ $table{$target}->{$_})) {
2241# warn "$_ got replaced in $target\n";
2242# }
bd5192b1
RL		 2243 }
2244
2245 # Finally done, return the result.
2246 return %{$table{$target}};
2247}
2248
462ba4f6 2249sub usage
d02b48c6 2250 {
462ba4f6 2251 print STDERR $usage;
10a926c1 2252 print STDERR "\npick os/compiler from:\n";
1641cb60 2253 my $j=0;
6457ad15 2254 my $i;
10a926c1 2255 my $k=0;
6457ad15 2256 foreach $i (sort keys %table)
d02b48c6 2257 {
bd5192b1 2258 next if $table{$i}->{template};
462ba4f6 2259 next if $i =~ /^debug/;
10a926c1
UM		 2260 $k += length($i) + 1;
2261 if ($k > 78)
2262 {
2263 print STDERR "\n";
2264 $k=length($i);
2265 }
2266 print STDERR $i . " ";
462ba4f6
UM		 2267 }
2268 foreach $i (sort keys %table)
2269 {
bd5192b1 2270 next if $table{$i}->{template};
462ba4f6 2271 next if $i !~ /^debug/;
10a926c1
UM		 2272 $k += length($i) + 1;
2273 if ($k > 78)
2274 {
2275 print STDERR "\n";
2276 $k=length($i);
2277 }
2278 print STDERR $i . " ";
d02b48c6 2279 }
10a926c1 2280 print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
462ba4f6 2281 exit(1);
d02b48c6
RE		 2282 }
2283
01d99976 2284sub run_dofile
107b5792 2285{
107b5792 2286 my $out = shift;
9fe2bb77 2287 my @templates = @_;
107b5792 2288
ced2c2c5
RS		 2289 unlink $out || warn "Can't remove $out, $!"
2290 if -f $out;
9fe2bb77
RL		 2291 foreach (@templates) {
2292 die "Can't open $_, $!" unless -f $_;
2293 }
a3a08f81 2294 my $cmd = "$config{perl} \"-I.\" \"-Mconfigdata\" \"$dofile\" -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\"";
9fe2bb77
RL		 2295 #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
2296 system($cmd);
107b5792
RL		 2297 exit 1 if $? != 0;
2298 rename("$out.new", $out) || die "Can't rename $out.new, $!";
2299}
2300
656bbdc6
AP		 2301sub which
2302{
2303 my ($name)=@_;
2304
2305 if (eval { require IPC::Cmd; 1; }) {
2306 IPC::Cmd->import();
2307 return scalar IPC::Cmd::can_run($name);
2308 } else {
2309 # if there is $directories component in splitpath,
2310 # then it's not something to test with $PATH...
2311 return $name if (File::Spec->splitpath($name))[1];
2312
2313 foreach (File::Spec->path()) {
2314 my $fullpath = catfile($_, "$name$target{exe_extension}");
2315 if (-f $fullpath and -x $fullpath) {
2316 return $fullpath;
2317 }
2318 }
2319 }
2320}
2321
00ae96ca
RL		 2322# Configuration printer ##############################################
2323
2324sub print_table_entry
2325{
2326 my $target = shift;
2327 my %target = resolve_config($target);
2328 my $type = shift;
2329
2330 # Don't print the templates
2331 return if $target{template};
2332
2333 my @sequence = (
f0bd4686 2334 "sys_id",
00ae96ca
RL		 2335 "cc",
2336 "cflags",
bcb1977b 2337 "defines",
f0bd4686
RL		 2338 "unistd",
2339 "ld",
00ae96ca 2340 "lflags",
c86ddbe6 2341 "plib_lflags",
1740c162 2342 "ex_libs",
00ae96ca
RL		 2343 "bn_ops",
2344 "cpuid_obj",
2345 "bn_obj",
2346 "ec_obj",
2347 "des_obj",
2348 "aes_obj",
2349 "bf_obj",
2350 "md5_obj",
2351 "sha1_obj",
2352 "cast_obj",
2353 "rc4_obj",
2354 "rmd160_obj",
2355 "rc5_obj",
2356 "wp_obj",
2357 "cmll_obj",
2358 "modes_obj",
f0bd4686 2359 "padlock_obj",
9c62a279 2360 "thread_scheme",
00ae96ca
RL		 2361 "perlasm_scheme",
2362 "dso_scheme",
2363 "shared_target",
2364 "shared_cflag",
2365 "shared_ldflag",
64c443e3 2366 "shared_rcflag",
00ae96ca 2367 "shared_extension",
e987f9f2
RL		 2368 "shared_extension_simple",
2369 "shared_import_extension",
2370 "dso_extension",
f0bd4686
RL		 2371 "obj_extension",
2372 "exe_extension",
00ae96ca 2373 "ranlib",
f0bd4686 2374 "ar",
00ae96ca
RL		 2375 "arflags",
2376 "multilib",
f0bd4686 2377 "build_scheme",
00ae96ca
RL		 2378 );
2379
2380 if ($type eq "TABLE") {
2381 print "\n";
2382 print "*** $target\n";
cb212f23
RL		 2383 foreach (@sequence) {
2384 if (ref($target{$_}) eq "ARRAY") {
2385 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
2386 } else {
2387 printf "\$%-12s = %s\n", $_, $target{$_};
2388 }
2389 }
00ae96ca
RL		 2390 } elsif ($type eq "HASH") {
2391 my $largest =
2392 length((sort { length($a) <=> length($b) } @sequence)[-1]);
2393 print " '$target' => {\n";
2394 foreach (@sequence) {
2395 if ($target{$_}) {
cb212f23
RL		 2396 if (ref($target{$_}) eq "ARRAY") {
2397 print " '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
2398 } else {
2399 print " '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
2400 }
00ae96ca
RL		 2401 }
2402 }
2403 print " },\n";
2404 }
2405}
2406
2407# Utility routines ###################################################
2408
2e963849
RL		 2409# On VMS, if the given file is a logical name, File::Spec::Functions
2410# will consider it an absolute path. There are cases when we want a
2411# purely syntactic check without checking the environment.
2412sub isabsolute {
2413 my $file = shift;
2414
2415 # On non-platforms, we just use file_name_is_absolute().
2416 return file_name_is_absolute($file) unless $^O eq "VMS";
2417
2418 # If the file spec includes a device or a directpry spec,
2419 # file_name_is_absolute() is perfectly safe.
2420 return file_name_is_absolute($file) if $file =~ m|[:\[]|;
2421
2422 # Here, we know the given file spec isn't absolute
2423 return 0;
2424}
2425
ec182ef0
RL		 2426# Makes a directory absolute and cleans out /../ in paths like foo/../bar
2427# On some platforms, this uses rel2abs(), while on others, realpath() is used.
2428# realpath() requires that at least all path components except the last is an
2429# existing directory. On VMS, the last component of the directory spec must
2430# exist.
2431sub absolutedir {
2432 my $dir = shift;
2433
2434 # realpath() is quite buggy on VMS. It uses LIB$FID_TO_NAME, which
2435 # will return the volume name for the device, no matter what. Also,
2436 # it will return an incorrect directory spec if the argument is a
2437 # directory that doesn't exist.
2438 if ($^O eq "VMS") {
2439 return rel2abs($dir);
2440 }
2441
2442 # We use realpath() on Unix, since no other will properly clean out
2443 # a directory spec.
2444 use Cwd qw/realpath/;
2445
2446 return realpath($dir);
2447}
2448
fe05264e
RL		 2449sub quotify {
2450 my %processors = (
2451 perl => sub { my $x = shift;
2452 $x =~ s/([\\\$\@"])/\\$1/g;
2453 return '"'.$x.'"'; },
2454 );
2455 my $for = shift;
2456 my $processor =
2457 defined($processors{$for}) ? $processors{$for} : sub { shift; };
2458
2110febb 2459 return map { $processor->($_); } @_;
fe05264e 2460}
107b5792 2461
9fe2bb77
RL		 2462# collect_from_file($filename, $line_concat_cond_re, $line_concat)
2463# $filename is a file name to read from
2464# $line_concat_cond_re is a regexp detecting a line continuation ending
2465# $line_concat is a CODEref that takes care of concatenating two lines
2466sub collect_from_file {
2467 my $filename = shift;
2468 my $line_concat_cond_re = shift;
2469 my $line_concat = shift;
2470
2471 open my $fh, $filename || die "unable to read $filename: $!\n";
2472 return sub {
2473 my $saved_line = "";
2474 $_ = "";
2475 while (<$fh>) {
04f171c0 2476 s|\R$||;
9fe2bb77
RL		 2477 if (defined $line_concat) {
2478 $_ = $line_concat->($saved_line, $_);
2479 $saved_line = "";
2480 }
2481 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2482 $saved_line = $_;
2483 next;
2484 }
2485 return $_;
2486 }
2487 die "$filename ending with continuation line\n" if $_;
2488 close $fh;
2489 return undef;
2490 }
2491}
2492
2493# collect_from_array($array, $line_concat_cond_re, $line_concat)
2494# $array is an ARRAYref of lines
2495# $line_concat_cond_re is a regexp detecting a line continuation ending
2496# $line_concat is a CODEref that takes care of concatenating two lines
2497sub collect_from_array {
2498 my $array = shift;
2499 my $line_concat_cond_re = shift;
2500 my $line_concat = shift;
2501 my @array = (@$array);
2502
2503 return sub {
2504 my $saved_line = "";
2505 $_ = "";
2506 while (defined($_ = shift @array)) {
04f171c0 2507 s|\R$||;
9fe2bb77
RL		 2508 if (defined $line_concat) {
2509 $_ = $line_concat->($saved_line, $_);
2510 $saved_line = "";
2511 }
2512 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2513 $saved_line = $_;
2514 next;
2515 }
2516 return $_;
2517 }
2518 die "input text ending with continuation line\n" if $_;
2519 return undef;
2520 }
2521}
2522
2523# collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
2524# $lineiterator is a CODEref that delivers one line at a time.
107b5792
RL		 2525# All following arguments are regex/CODEref pairs, where the regexp detects a
2526# line and the CODEref does something with the result of the regexp.
2527sub collect_information {
9fe2bb77 2528 my $lineiterator = shift;
107b5792
RL		 2529 my %collectors = @_;
2530
9fe2bb77 2531 while(defined($_ = $lineiterator->())) {
04f171c0 2532 s|\R$||;
9fe2bb77 2533 my $found = 0;
2b6b606c
RL		 2534 if ($collectors{"BEFORE"}) {
2535 $collectors{"BEFORE"}->($_);
2536 }
9fe2bb77 2537 foreach my $re (keys %collectors) {
2b6b606c 2538 if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
9fe2bb77
RL		 2539 $collectors{$re}->($lineiterator);
2540 $found = 1;
2541 };
2542 }
2543 if ($collectors{"OTHERWISE"}) {
2544 $collectors{"OTHERWISE"}->($lineiterator, $_)
2545 unless $found || !defined $collectors{"OTHERWISE"};
2546 }
2b6b606c
RL		 2547 if ($collectors{"AFTER"}) {
2548 $collectors{"AFTER"}->($_);
2549 }
107b5792 2550 }
107b5792 2551}
ce959812
RL		 2552
2553# tokenize($line)
2554# $line is a line of text to split up into tokens
2555# returns a list of tokens
2556#
2557# Tokens are divided by spaces. If the tokens include spaces, they
2558# have to be quoted with single or double quotes. Double quotes
2559# inside a double quoted token must be escaped. Escaping is done
2560# with backslash.
2561# Basically, the same quoting rules apply for " and ' as in any
2562# Unix shell.
2563sub tokenize {
2564 my $line = my $debug_line = shift;
2565 my @result = ();
2566
2567 while ($line =~ s|^\s+||, $line ne "") {
2568 my $token = "";
2569 while ($line ne "" && $line !~ m|^\s|) {
2570 if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
2571 $token .= $1;
2572 $line = $';
2573 } elsif ($line =~ m/^'([^']*)'/) {
2574 $token .= $1;
2575 $line = $';
2576 } elsif ($line =~ m/^(\S+)/) {
2577 $token .= $1;
2578 $line = $';
2579 }
2580 }
2581 push @result, $token;
2582 }
2583
2584 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
2585 print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
2586 print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";
2587 }
2588 return @result;
2589}
A mirror of the official openssl repository