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