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