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