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