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