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