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