]> 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
Makefile.shared: revert Haiku support commit.
[thirdparty/openssl.git] / Configure
CommitLineData
de17db91 1#! /usr/bin/env perl
f4d8f037 2# -*- mode: perl; -*-
ac3d0e13
RS		 3# Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
4#
5# Licensed under the OpenSSL license (the "License"). You may not use
6# this file except in compliance with the License. You can obtain a copy
7# in the file LICENSE in the source distribution or at
8# https://www.openssl.org/source/license.html
de17db91 9
a4ed5532 10## Configure -- OpenSSL source tree configuration script
1641cb60 11
9f519add 12require 5.10.0;
1641cb60 13use strict;
f09e7ca9 14use File::Basename;
85152ca4 15use File::Spec::Functions qw/:DEFAULT abs2rel rel2abs/;
dca99383 16use File::Path qw/mkpath/;
6646f69f 17use IPC::Cmd qw/can_run/;
1641cb60 18
22a4f969 19# see INSTALL for instructions.
462ba4f6 20
e4ef2e25 21my $usage="Usage: Configure [no-<cipher> ...] [enable-<cipher> ...] [-Dxxx] [-lxxx] [-Lxxx] [-fxxx] [-Kxxx] [no-hw-xxx|no-hw] [[no-]threads] [[no-]shared] [[no-]zlib|zlib-dynamic] [no-asm] [no-dso] [no-egd] [sctp] [386] [--prefix=DIR] [--openssldir=OPENSSLDIR] [--with-xxx[=vvv]] [--config=FILE] os/compiler[:flags]\n";
462ba4f6 22
434c5dd3 23# Options:
e5f3045f 24#
f09e7ca9
RS		 25# --config add the given configuration file, which will be read after
26# any "Configurations*" files that are found in the same
27# directory as this script.
d74dfafd
RL		 28# --prefix prefix for the OpenSSL installation, which includes the
29# directories bin, lib, include, share/man, share/doc/openssl
30# This becomes the value of INSTALLTOP in Makefile
31# (Default: /usr/local)
32# --openssldir OpenSSL data area, such as openssl.cnf, certificates and keys.
33# If it's a relative directory, it will be added on the directory
34# given with --prefix.
35# This becomes the value of OPENSSLDIR in Makefile and in C.
36# (Default: PREFIX/ssl)
e5f3045f 37#
cbfb39d1
AP		 38# --cross-compile-prefix Add specified prefix to binutils components.
39#
98186eb4
VD		 40# --api One of 0.9.8, 1.0.0 or 1.1.0. Do not compile support for
41# interfaces deprecated as of the specified OpenSSL version.
42#
5270e702
RL		 43# no-hw-xxx do not compile support for specific crypto hardware.
44# Generic OpenSSL-style methods relating to this support
45# are always compiled but return NULL if the hardware
46# support isn't compiled.
47# no-hw do not compile support for any crypto hardware.
5f8d5c96
BM		 48# [no-]threads [don't] try to create a library that is suitable for
49# multithreaded applications (default is "threads" if we
50# know how to do it)
fcc6a1c4 51# [no-]shared [don't] try to create shared libraries when supported.
ae48242c 52# [no-]pic [don't] try to build position independent code when supported.
45b71abe 53# If disabled, it also disables shared and dynamic-engine.
a723979d 54# no-asm do not use assembler
bc2aadad
GT		 55# no-dso do not compile in any native shared-library methods. This
56# will ensure that all methods just return NULL.
0423f812 57# no-egd do not compile support for the entropy-gathering daemon APIs
e452de9d
RL		 58# [no-]zlib [don't] compile support for zlib compression.
59# zlib-dynamic Like "zlib", but the zlib library is expected to be a shared
60# library and will be loaded in run-time by the OpenSSL library.
7e159e01 61# sctp include SCTP support
22a4f969 62# 386 generate 80386 code
8b1a5af3
MC		 63# enable-weak-ssl-ciphers
64# Enable weak ciphers that are disabled by default. This currently
65# only includes RC4 based ciphers.
d0590fe6 66# no-sse2 disables IA-32 SSE2 code, above option implies no-sse2
79df9d62 67# no-<cipher> build without specified algorithm (rsa, idea, rc5, ...)
fce0ba5f 68# -<xxx> +<xxx> compiler options are passed through
e41c8d6a
GT		 69#
70# DEBUG_SAFESTACK use type-safe stacks to enforce type-safety on stack items
71# provided to stack calls. Generates unique stack functions for
72# each possible stack type.
d02b48c6 73# BN_LLONG use the type 'long long' in crypto/bn/bn.h
d02b48c6 74# RC4_CHAR use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
d0590fe6
AP		 75# Following are set automatically by this script
76#
8483a003
F		 77# MD5_ASM use some extra md5 assembler,
78# SHA1_ASM use some extra sha1 assembler, must define L_ENDIAN for x86
79# RMD160_ASM use some extra ripemd160 assembler,
d0590fe6
AP		 80# SHA256_ASM sha256_block is implemented in assembler
81# SHA512_ASM sha512_block is implemented in assembler
82# AES_ASM ASE_[en|de]crypt is implemented in assembler
d02b48c6 83
363bd0b4 84# Minimum warning options... any contributions to OpenSSL should at least get
fce0ba5f 85# past these.
363bd0b4 86
463a7b8c
AP		 87# DEBUG_UNUSED enables __owur (warn unused result) checks.
88my $gcc_devteam_warn = "-DDEBUG_UNUSED"
89 # -DPEDANTIC complements -pedantic and is meant to mask code that
90 # is not strictly standard-compliant and/or implementation-specifc,
91 # e.g. inline assembly, disregards to alignment requirements, such
92 # that -pedantic would complain about. Incidentally -DPEDANTIC has
93 # to be used even in sanitized builds, because sanitizer too is
94 # supposed to and does take notice of non-standard behaviour. Then
95 # -pedantic with pre-C9x compiler would also complain about 'long
96 # long' not being supported. As 64-bit algorithms are common now,
97 # it grew impossible to resolve this without sizeable additional
98 # code, so we just tell compiler to be pedantic about everything
99 # but 'long long' type.
100 . " -DPEDANTIC -pedantic -Wno-long-long"
8bccbce5 101 . " -Wall"
8bccbce5
RS		 102 . " -Wsign-compare"
103 . " -Wmissing-prototypes"
104 . " -Wshadow"
105 . " -Wformat"
106 . " -Wtype-limits"
107 . " -Werror"
108 ;
363bd0b4 109
190c8c60
BL		 110# These are used in addition to $gcc_devteam_warn when the compiler is clang.
111# TODO(openssl-team): fix problems and investigate if (at least) the
480405e4 112# following warnings can also be enabled:
8bccbce5 113# -Wswitch-enum
8bccbce5
RS		 114# -Wcast-align
115# -Wunreachable-code
a773b52a
RS		 116# -Wlanguage-extension-token -- no, we use asm()
117# -Wunused-macros -- no, too tricky for BN and _XOPEN_SOURCE etc
118# -Wextended-offsetof -- no, needed in CMS ASN1 code
8bccbce5
RS		 119my $clang_devteam_warn = ""
120 . " -Qunused-arguments"
121 . " -Wextra"
122 . " -Wno-unused-parameter"
123 . " -Wno-missing-field-initializers"
124 . " -Wno-language-extension-token"
125 . " -Wno-extended-offsetof"
126 . " -Wconditional-uninitialized"
127 . " -Wincompatible-pointer-types-discards-qualifiers"
128 . " -Wmissing-variable-declarations"
129 ;
cb2bc054 130
ef8ca6bd
RL		 131# This adds backtrace information to the memory leak info. Is only used
132# when crypto-mdebug-backtrace is enabled.
133my $memleak_devteam_backtrace = "-rdynamic";
a1d3f3d1 134
0c28f277
DSH		 135my $strict_warnings = 0;
136
b7efa56a 137# As for $BSDthreads. Idea is to maintain "collective" set of flags,
fce0ba5f 138# which would cover all BSD flavors. -pthread applies to them all,
b7efa56a
AP		 139# but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
140# -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
141# which has to be accompanied by explicit -D_THREAD_SAFE and
142# sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
143# seems to be sufficient?
9c62a279 144our $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
d02b48c6 145
98186eb4
VD		 146#
147# API compability name to version number mapping.
148#
149my $maxapi = "1.1.0"; # API for "no-deprecated" builds
150my $apitable = {
151 "1.1.0" => "0x10100000L",
152 "1.0.0" => "0x10000000L",
153 "0.9.8" => "0x00908000L",
154};
155
9e0724a1 156our %table = ();
291e94df 157our %config = ();
98fdbce0 158our %withargs = ();
3e83e686 159
bd5192b1 160# Forward declarations ###############################################
7ead0c89 161
bd5192b1
RL		 162# read_config(filename)
163#
164# Reads a configuration file and populates %table with the contents
165# (which the configuration file places in %targets).
166sub read_config;
7d46b942 167
bd5192b1
RL		 168# resolve_config(target)
169#
8483a003 170# Resolves all the late evaluations, inheritances and so on for the
bd5192b1
RL		 171# chosen target and any target it inherits from.
172sub resolve_config;
7d46b942 173
15c7adb0 174
107b5792
RL		 175# Information collection #############################################
176
9fe2bb77 177# Unified build supports separate build dir
ec182ef0
RL		 178my $srcdir = catdir(absolutedir(dirname($0))); # catdir ensures local syntax
179my $blddir = catdir(absolutedir(".")); # catdir ensures local syntax
9fe2bb77
RL		 180my $dofile = abs2rel(catfile($srcdir, "util/dofile.pl"));
181
b5293d4c
RL		 182my $local_config_envname = 'OPENSSL_LOCAL_CONFIG_DIR';
183
9fe2bb77
RL		 184$config{sourcedir} = abs2rel($srcdir);
185$config{builddir} = abs2rel($blddir);
186
107b5792
RL		 187# Collect version numbers
188$config{version} = "unknown";
189$config{version_num} = "unknown";
190$config{shlib_version_number} = "unknown";
191$config{shlib_version_history} = "unknown";
192
193collect_information(
9fe2bb77 194 collect_from_file(catfile($srcdir,'include/openssl/opensslv.h')),
107b5792
RL		 195 qr/OPENSSL.VERSION.TEXT.*OpenSSL (\S+) / => sub { $config{version} = $1; },
196 qr/OPENSSL.VERSION.NUMBER.*(0x\S+)/ => sub { $config{version_num}=$1 },
197 qr/SHLIB_VERSION_NUMBER *"([^"]+)"/ => sub { $config{shlib_version_number}=$1 },
198 qr/SHLIB_VERSION_HISTORY *"([^"]*)"/ => sub { $config{shlib_version_history}=$1 }
199 );
200if ($config{shlib_version_history} ne "") { $config{shlib_version_history} .= ":"; }
201
202($config{major}, $config{minor})
203 = ($config{version} =~ /^([0-9]+)\.([0-9\.]+)/);
204($config{shlib_major}, $config{shlib_minor})
205 = ($config{shlib_version_number} =~ /^([0-9]+)\.([0-9\.]+)/);
206die "erroneous version information in opensslv.h: ",
207 "$config{major}, $config{minor}, $config{shlib_major}, $config{shlib_minor}\n"
208 if ($config{major} eq "" || $config{minor} eq ""
209 || $config{shlib_major} eq "" || $config{shlib_minor} eq "");
210
211# Collect target configurations
212
85152ca4 213my $pattern = catfile(dirname($0), "Configurations", "*.conf");
97a0cc52 214foreach (sort glob($pattern) ) {
f09e7ca9
RS		 215 &read_config($_);
216}
d02b48c6 217
b5293d4c
RL		 218if (defined $ENV{$local_config_envname}) {
219 if ($^O eq 'VMS') {
220 # VMS environment variables are logical names,
221 # which can be used as is
222 $pattern = $local_config_envname . ':' . '*.conf';
223 } else {
224 $pattern = catfile($ENV{$local_config_envname}, '*.conf');
225 }
226
227 foreach (sort glob($pattern) ) {
228 &read_config($_);
229 }
230}
231
291e94df 232
107b5792
RL		 233print "Configuring OpenSSL version $config{version} (0x$config{version_num})\n";
234
291e94df
RL		 235$config{prefix}="";
236$config{openssldir}="";
7d130f68 237$config{processor}="";
107b5792 238$config{libdir}="";
642a6138 239$config{cross_compile_prefix}="";
107b5792 240$config{fipslibdir}="/usr/local/ssl/fips-2.0/lib/";
1ab2f7f1 241my $nofipscanistercheck=0;
107b5792 242$config{baseaddr}="0xFB00000";
9c62a279 243my $auto_threads=1; # enable threads automatically? true by default
0396479d 244my $default_ranlib;
107b5792
RL		 245$config{fips}=0;
246
247# Top level directories to build
248$config{dirs} = [ "crypto", "ssl", "engines", "apps", "test", "tools" ];
249# crypto/ subdirectories to build
250$config{sdirs} = [
251 "objects",
2d0b4412 252 "md2", "md4", "md5", "sha", "mdc2", "hmac", "ripemd", "whrlpool", "poly1305", "blake2",
107b5792
RL		 253 "des", "aes", "rc2", "rc4", "rc5", "idea", "bf", "cast", "camellia", "seed", "chacha", "modes",
254 "bn", "ec", "rsa", "dsa", "dh", "dso", "engine",
255 "buffer", "bio", "stack", "lhash", "rand", "err",
256 "evp", "asn1", "pem", "x509", "x509v3", "conf", "txt_db", "pkcs7", "pkcs12", "comp", "ocsp", "ui",
dba31777 257 "cms", "ts", "srp", "cmac", "ct", "async", "kdf"
107b5792 258 ];
99aab161 259
6b01bed2
VD		 260# Known TLS and DTLS protocols
261my @tls = qw(ssl3 tls1 tls1_1 tls1_2);
262my @dtls = qw(dtls1 dtls1_2);
263
8483a003 264# Explicitly known options that are possible to disable. They can
8b527be2
RL		 265# be regexps, and will be used like this: /^no-${option}$/
266# For developers: keep it sorted alphabetically
267
268my @disablables = (
c91a0a83 269 "afalgeng",
c38bb727 270 "asan",
8b527be2 271 "asm",
52739e40 272 "async",
b184e3ef 273 "autoalginit",
498abff0 274 "autoerrinit",
8b527be2 275 "bf",
2d0b4412 276 "blake2",
8b527be2
RL		 277 "camellia",
278 "capieng",
279 "cast",
48f14845 280 "chacha",
8b527be2
RL		 281 "cmac",
282 "cms",
283 "comp",
3e45d393 284 "crypto-mdebug",
ef8ca6bd 285 "crypto-mdebug-backtrace",
8b527be2
RL		 286 "ct",
287 "deprecated",
288 "des",
289 "dgram",
290 "dh",
291 "dsa",
292 "dso",
a5ecdc6a 293 "dtls",
343ec2b0 294 "dynamic-engine",
8b527be2
RL		 295 "ec",
296 "ec2m",
6b01bed2
VD		 297 "ecdh",
298 "ecdsa",
8b527be2 299 "ec_nistp_64_gcc_128",
b31feae6 300 "egd",
8b527be2 301 "engine",
1288f26f 302 "err",
02f7114a 303 "filenames",
c38bb727 304 "fuzz",
168c3b73 305 "gost",
8b527be2 306 "heartbeats",
8b527be2
RL		 307 "hw(-.+)?",
308 "idea",
09aa263a 309 "makedepend",
8b527be2
RL		 310 "md2",
311 "md4",
8b527be2 312 "mdc2",
fa22f98f 313 "multiblock",
8b527be2
RL		 314 "nextprotoneg",
315 "ocb",
316 "ocsp",
ae48242c 317 "pic",
48f14845 318 "poly1305",
8b527be2
RL		 319 "posix-io",
320 "psk",
321 "rc2",
322 "rc4",
323 "rc5",
324 "rdrand",
325 "rfc3779",
1288f26f 326 "ripemd",
8b527be2 327 "rmd160",
8b527be2 328 "scrypt",
8b527be2
RL		 329 "sctp",
330 "seed",
8b527be2
RL		 331 "shared",
332 "sock",
333 "srp",
334 "srtp",
335 "sse2",
336 "ssl",
8b527be2
RL		 337 "ssl-trace",
338 "static-engine",
339 "stdio",
8b527be2
RL		 340 "threads",
341 "tls",
1288f26f 342 "ts",
c38bb727 343 "ubsan",
1288f26f 344 "ui",
8b527be2
RL		 345 "unit-test",
346 "whirlpool",
8b1a5af3 347 "weak-ssl-ciphers",
8b527be2
RL		 348 "zlib",
349 "zlib-dynamic",
350 );
6b01bed2
VD		 351foreach my $proto ((@tls, @dtls))
352 {
353 push(@disablables, $proto);
354 push(@disablables, "$proto-method");
355 }
8b527be2 356
e80381e1
RL		 357my @deprecated_disablables = (
358 "ssl2",
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} ||
6646f69f 916 (scalar can_run("$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
6646f69f 1161 $config{makedepprog} = scalar can_run('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
1973 run_dofile("util/domd", "util/domd.in");
1974 chmod 0755, "util/domd";
88087414 1975 },
88087414
RL		 1976 );
1977
ddf1847d 1978$builders{$builder}->($builder_platform, @builder_opts);
fce0ba5f 1979
76ffb43d 1980print <<"EOF";
63d3f44a 1981
89ec98e0 1982Configured for $target.
63d3f44a 1983EOF
5f8d5c96 1984
9c62a279 1985print <<"EOF" if ($disabled{threads} eq "unavailable");
5f8d5c96
BM		 1986
1987The library could not be configured for supporting multi-threaded
1988applications as the compiler options required on this system are not known.
ff1b7e09 1989See file INSTALL for details if you need multi-threading.
ec577822
BM		 1990EOF
1991
76ffb43d 1992print <<"EOF" if ($no_shared_warn);
2964ba8c 1993
ae48242c
RL		 1994The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
1995platform, so we will pretend you gave the option 'no-pic', which also disables
1996'shared' and 'dynamic-engine'. If you know how to implement shared libraries
1997or position independent code, please let us know (but please first make sure
1998you have tried with a current version of OpenSSL).
2e31ef03
RS		 1999EOF
2000
ddc606c9
RL		 2001print <<"EOF" if (-f catfile($srcdir, "configdata.pm") && $srcdir ne $blddir);
2002
2003WARNING: there are indications that another build was made in the source
2004directory. This build may have picked up artifacts from that build, the
2005safest course of action is to clean the source directory and redo this
2006configuration.
2007EOF
2008
d02b48c6
RE		 2009exit(0);
2010
bd5192b1
RL		 2011######################################################################
2012#
2013# Helpers and utility functions
2014#
2015
2016# Configuration file reading #########################################
2017
1f2e1cd5
RL		 2018# Note: All of the helper functions are for lazy evaluation. They all
2019# return a CODE ref, which will return the intended value when evaluated.
2020# Thus, whenever there's mention of a returned value, it's about that
2021# intended value.
2022
bd5192b1 2023# Helper function to implement conditional inheritance depending on the
00b0d663 2024# value of $disabled{asm}. Used in inherit_from values as follows:
bd5192b1
RL		 2025#
2026# inherit_from => [ "template", asm("asm_tmpl") ]
2027#
2028sub asm {
2029 my @x = @_;
2030 sub {
00b0d663 2031 $disabled{asm} ? () : @x;
bd5192b1
RL		 2032 }
2033}
2034
1f2e1cd5
RL		 2035# Helper function to implement conditional value variants, with a default
2036# plus additional values based on the value of $config{build_type}.
2037# Arguments are given in hash table form:
2038#
2039# picker(default => "Basic string: ",
2040# debug => "debug",
2041# release => "release")
2042#
2043# When configuring with --debug, the resulting string will be
2044# "Basic string: debug", and when not, it will be "Basic string: release"
2045#
2046# This can be used to create variants of sets of flags according to the
2047# build type:
2048#
2049# cflags => picker(default => "-Wall",
2050# debug => "-g -O0",
2051# release => "-O3")
2052#
2053sub picker {
2054 my %opts = @_;
2055 return sub { add($opts{default} || (),
2056 $opts{$config{build_type}} || ())->(); }
2057}
2058
2059# Helper function to combine several values of different types into one.
2060# This is useful if you want to combine a string with the result of a
2061# lazy function, such as:
2062#
2063# cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
2064#
2065sub combine {
2066 my @stuff = @_;
2067 return sub { add(@stuff)->(); }
2068}
2069
2070# Helper function to implement conditional values depending on the value
2071# of $disabled{threads}. Can be used as follows:
2072#
2073# cflags => combine("-Wall", threads("-pthread"))
2074#
2075sub threads {
2076 my @flags = @_;
2077 return sub { add($disabled{threads} ? () : @flags)->(); }
2078}
2079
2080
2081
9c62a279 2082our $add_called = 0;
88087414
RL		 2083# Helper function to implement adding values to already existing configuration
2084# values. It handles elements that are ARRAYs, CODEs and scalars
2085sub _add {
2086 my $separator = shift;
2087
bcb1977b
RL		 2088 # If there's any ARRAY in the collection of values OR the separator
2089 # is undef, we will return an ARRAY of combined values, otherwise a
2090 # string of joined values with $separator as the separator.
2091 my $found_array = !defined($separator);
88087414
RL		 2092
2093 my @values =
2094 map {
b0b92a5b
RL		 2095 my $res = $_;
2096 while (ref($res) eq "CODE") {
2097 $res = $res->();
2098 }
2099 if (defined($res)) {
2100 if (ref($res) eq "ARRAY") {
2101 $found_array = 1;
2102 @$res;
2103 } else {
2104 $res;
2105 }
88087414 2106 } else {
b0b92a5b 2107 ();
88087414
RL		 2108 }
2109 } (@_);
2110
9c62a279
RL		 2111 $add_called = 1;
2112
88087414
RL		 2113 if ($found_array) {
2114 [ @values ];
2115 } else {
b0b92a5b 2116 join($separator, grep { defined($_) && $_ ne "" } @values);
88087414
RL		 2117 }
2118}
2119sub add_before {
bdcd83e1
RL		 2120 my $separator = " ";
2121 if (ref($_[$#_]) eq "HASH") {
2122 my $opts = pop;
2123 $separator = $opts->{separator};
2124 }
88087414
RL		 2125 my @x = @_;
2126 sub { _add($separator, @x, @_) };
2127}
2128sub add {
bdcd83e1
RL		 2129 my $separator = " ";
2130 if (ref($_[$#_]) eq "HASH") {
2131 my $opts = pop;
2132 $separator = $opts->{separator};
2133 }
88087414
RL		 2134 my @x = @_;
2135 sub { _add($separator, @_, @x) };
2136}
2137
bd5192b1
RL		 2138# configuration reader, evaluates the input file as a perl script and expects
2139# it to fill %targets with target configurations. Those are then added to
2140# %table.
2141sub read_config {
2142 my $fname = shift;
2143 open(CONFFILE, "< $fname")
2144 or die "Can't open configuration file '$fname'!\n";
2145 my $x = $/;
2146 undef $/;
2147 my $content = <CONFFILE>;
2148 $/ = $x;
2149 close(CONFFILE);
2150 my %targets = ();
2151 {
2152 local %table = %::table; # Protect %table from tampering
2153
2154 eval $content;
2155 warn $@ if $@;
2156 }
2157
2158 # For each target, check that it's configured with a hash table.
2159 foreach (keys %targets) {
2160 if (ref($targets{$_}) ne "HASH") {
2161 if (ref($targets{$_}) eq "") {
2162 warn "Deprecated target configuration for $_, ignoring...\n";
2163 } else {
2164 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
2165 }
2166 delete $targets{$_};
2167 }
2168 }
2169
2170 %table = (%table, %targets);
2171
2172}
2173
8483a003
F		 2174# configuration resolver. Will only resolve all the lazy evaluation
2175# codeblocks for the chosen target and all those it inherits from,
bd5192b1
RL		 2176# recursively
2177sub resolve_config {
2178 my $target = shift;
2179 my @breadcrumbs = @_;
2180
c4718849 2181# my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
9c62a279 2182
bd5192b1
RL		 2183 if (grep { $_ eq $target } @breadcrumbs) {
2184 die "inherit_from loop! target backtrace:\n "
2185 ,$target,"\n ",join("\n ", @breadcrumbs),"\n";
2186 }
2187
2188 if (!defined($table{$target})) {
2189 warn "Warning! target $target doesn't exist!\n";
2190 return ();
2191 }
2192 # Recurse through all inheritances. They will be resolved on the
2193 # fly, so when this operation is done, they will all just be a
2194 # bunch of attributes with string values.
2195 # What we get here, though, are keys with references to lists of
2196 # the combined values of them all. We will deal with lists after
2197 # this stage is done.
2198 my %combined_inheritance = ();
2199 if ($table{$target}->{inherit_from}) {
2200 my @inherit_from =
2201 map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
2202 foreach (@inherit_from) {
2203 my %inherited_config = resolve_config($_, $target, @breadcrumbs);
2204
2205 # 'template' is a marker that's considered private to
2206 # the config that had it.
2207 delete $inherited_config{template};
2208
2110febb 2209 foreach (keys %inherited_config) {
bd5192b1
RL		 2210 if (!$combined_inheritance{$_}) {
2211 $combined_inheritance{$_} = [];
2212 }
2213 push @{$combined_inheritance{$_}}, $inherited_config{$_};
2110febb 2214 }
bd5192b1
RL		 2215 }
2216 }
2217
2218 # We won't need inherit_from in this target any more, since we've
2219 # resolved all the inheritances that lead to this
2220 delete $table{$target}->{inherit_from};
2221
2222 # Now is the time to deal with those lists. Here's the place to
2223 # decide what shall be done with those lists, all based on the
2224 # values of the target we're currently dealing with.
2225 # - If a value is a coderef, it will be executed with the list of
2226 # inherited values as arguments.
2227 # - If the corresponding key doesn't have a value at all or is the
8483a003 2228 # empty string, the inherited value list will be run through the
bd5192b1
RL		 2229 # default combiner (below), and the result becomes this target's
2230 # value.
2231 # - Otherwise, this target's value is assumed to be a string that
2232 # will simply override the inherited list of values.
a26d8be9 2233 my $default_combiner = add();
bd5192b1
RL		 2234
2235 my %all_keys =
2236 map { $_ => 1 } (keys %combined_inheritance,
2237 keys %{$table{$target}});
b0b92a5b
RL		 2238
2239 sub process_values {
2240 my $object = shift;
2241 my $inherited = shift; # Always a [ list ]
2242 my $target = shift;
2243 my $entry = shift;
2244
9c62a279
RL		 2245 $add_called = 0;
2246
b0b92a5b
RL		 2247 while(ref($object) eq "CODE") {
2248 $object = $object->(@$inherited);
2249 }
2250 if (!defined($object)) {
2251 return ();
2252 }
2253 elsif (ref($object) eq "ARRAY") {
9c62a279 2254 local $add_called; # To make sure recursive calls don't affect it
b0b92a5b
RL		 2255 return [ map { process_values($_, $inherited, $target, $entry) }
2256 @$object ];
2257 } elsif (ref($object) eq "") {
2258 return $object;
2259 } else {
2260 die "cannot handle reference type ",ref($object)
2261 ," found in target ",$target," -> ",$entry,"\n";
2262 }
2263 }
2264
bd5192b1 2265 foreach (sort keys %all_keys) {
9c62a279 2266 my $previous = $combined_inheritance{$_};
bd5192b1
RL		 2267
2268 # Current target doesn't have a value for the current key?
2269 # Assign it the default combiner, the rest of this loop body
2270 # will handle it just like any other coderef.
2271 if (!exists $table{$target}->{$_}) {
2272 $table{$target}->{$_} = $default_combiner;
2273 }
2274
b0b92a5b
RL		 2275 $table{$target}->{$_} = process_values($table{$target}->{$_},
2276 $combined_inheritance{$_},
2277 $target, $_);
2278 unless(defined($table{$target}->{$_})) {
2279 delete $table{$target}->{$_};
2280 }
c4718849
RL		 2281# if ($extra_checks &&
2282# $previous && !($add_called || $previous ~~ $table{$target}->{$_})) {
2283# warn "$_ got replaced in $target\n";
2284# }
bd5192b1
RL		 2285 }
2286
2287 # Finally done, return the result.
2288 return %{$table{$target}};
2289}
2290
462ba4f6 2291sub usage
d02b48c6 2292 {
462ba4f6 2293 print STDERR $usage;
10a926c1 2294 print STDERR "\npick os/compiler from:\n";
1641cb60 2295 my $j=0;
6457ad15 2296 my $i;
10a926c1 2297 my $k=0;
6457ad15 2298 foreach $i (sort keys %table)
d02b48c6 2299 {
bd5192b1 2300 next if $table{$i}->{template};
462ba4f6 2301 next if $i =~ /^debug/;
10a926c1
UM		 2302 $k += length($i) + 1;
2303 if ($k > 78)
2304 {
2305 print STDERR "\n";
2306 $k=length($i);
2307 }
2308 print STDERR $i . " ";
462ba4f6
UM		 2309 }
2310 foreach $i (sort keys %table)
2311 {
bd5192b1 2312 next if $table{$i}->{template};
462ba4f6 2313 next if $i !~ /^debug/;
10a926c1
UM		 2314 $k += length($i) + 1;
2315 if ($k > 78)
2316 {
2317 print STDERR "\n";
2318 $k=length($i);
2319 }
2320 print STDERR $i . " ";
d02b48c6 2321 }
10a926c1 2322 print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
462ba4f6 2323 exit(1);
d02b48c6
RE		 2324 }
2325
01d99976 2326sub run_dofile
107b5792 2327{
107b5792 2328 my $out = shift;
9fe2bb77 2329 my @templates = @_;
107b5792 2330
ced2c2c5
RS		 2331 unlink $out || warn "Can't remove $out, $!"
2332 if -f $out;
9fe2bb77
RL		 2333 foreach (@templates) {
2334 die "Can't open $_, $!" unless -f $_;
2335 }
2336 my $cmd = "$config{perl} \"-I.\" \"-Mconfigdata\" $dofile -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\"";
2337 #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
2338 system($cmd);
107b5792
RL		 2339 exit 1 if $? != 0;
2340 rename("$out.new", $out) || die "Can't rename $out.new, $!";
2341}
2342
00ae96ca
RL		 2343# Configuration printer ##############################################
2344
2345sub print_table_entry
2346{
2347 my $target = shift;
2348 my %target = resolve_config($target);
2349 my $type = shift;
2350
2351 # Don't print the templates
2352 return if $target{template};
2353
2354 my @sequence = (
f0bd4686 2355 "sys_id",
00ae96ca
RL		 2356 "cc",
2357 "cflags",
bcb1977b 2358 "defines",
f0bd4686
RL		 2359 "unistd",
2360 "ld",
00ae96ca 2361 "lflags",
c86ddbe6 2362 "plib_lflags",
1740c162 2363 "ex_libs",
00ae96ca
RL		 2364 "bn_ops",
2365 "cpuid_obj",
2366 "bn_obj",
2367 "ec_obj",
2368 "des_obj",
2369 "aes_obj",
2370 "bf_obj",
2371 "md5_obj",
2372 "sha1_obj",
2373 "cast_obj",
2374 "rc4_obj",
2375 "rmd160_obj",
2376 "rc5_obj",
2377 "wp_obj",
2378 "cmll_obj",
2379 "modes_obj",
f0bd4686 2380 "padlock_obj",
9c62a279 2381 "thread_scheme",
00ae96ca
RL		 2382 "perlasm_scheme",
2383 "dso_scheme",
2384 "shared_target",
2385 "shared_cflag",
2386 "shared_ldflag",
64c443e3 2387 "shared_rcflag",
00ae96ca 2388 "shared_extension",
e987f9f2
RL		 2389 "shared_extension_simple",
2390 "shared_import_extension",
2391 "dso_extension",
f0bd4686
RL		 2392 "obj_extension",
2393 "exe_extension",
00ae96ca 2394 "ranlib",
f0bd4686 2395 "ar",
00ae96ca
RL		 2396 "arflags",
2397 "multilib",
f0bd4686 2398 "build_scheme",
00ae96ca
RL		 2399 );
2400
2401 if ($type eq "TABLE") {
2402 print "\n";
2403 print "*** $target\n";
cb212f23
RL		 2404 foreach (@sequence) {
2405 if (ref($target{$_}) eq "ARRAY") {
2406 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
2407 } else {
2408 printf "\$%-12s = %s\n", $_, $target{$_};
2409 }
2410 }
00ae96ca
RL		 2411 } elsif ($type eq "HASH") {
2412 my $largest =
2413 length((sort { length($a) <=> length($b) } @sequence)[-1]);
2414 print " '$target' => {\n";
2415 foreach (@sequence) {
2416 if ($target{$_}) {
cb212f23
RL		 2417 if (ref($target{$_}) eq "ARRAY") {
2418 print " '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
2419 } else {
2420 print " '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
2421 }
00ae96ca
RL		 2422 }
2423 }
2424 print " },\n";
2425 }
2426}
2427
2428# Utility routines ###################################################
2429
2e963849
RL		 2430# On VMS, if the given file is a logical name, File::Spec::Functions
2431# will consider it an absolute path. There are cases when we want a
2432# purely syntactic check without checking the environment.
2433sub isabsolute {
2434 my $file = shift;
2435
2436 # On non-platforms, we just use file_name_is_absolute().
2437 return file_name_is_absolute($file) unless $^O eq "VMS";
2438
2439 # If the file spec includes a device or a directpry spec,
2440 # file_name_is_absolute() is perfectly safe.
2441 return file_name_is_absolute($file) if $file =~ m|[:\[]|;
2442
2443 # Here, we know the given file spec isn't absolute
2444 return 0;
2445}
2446
ec182ef0
RL		 2447# Makes a directory absolute and cleans out /../ in paths like foo/../bar
2448# On some platforms, this uses rel2abs(), while on others, realpath() is used.
2449# realpath() requires that at least all path components except the last is an
2450# existing directory. On VMS, the last component of the directory spec must
2451# exist.
2452sub absolutedir {
2453 my $dir = shift;
2454
2455 # realpath() is quite buggy on VMS. It uses LIB$FID_TO_NAME, which
2456 # will return the volume name for the device, no matter what. Also,
2457 # it will return an incorrect directory spec if the argument is a
2458 # directory that doesn't exist.
2459 if ($^O eq "VMS") {
2460 return rel2abs($dir);
2461 }
2462
2463 # We use realpath() on Unix, since no other will properly clean out
2464 # a directory spec.
2465 use Cwd qw/realpath/;
2466
2467 return realpath($dir);
2468}
2469
fe05264e
RL		 2470sub quotify {
2471 my %processors = (
2472 perl => sub { my $x = shift;
2473 $x =~ s/([\\\$\@"])/\\$1/g;
2474 return '"'.$x.'"'; },
2475 );
2476 my $for = shift;
2477 my $processor =
2478 defined($processors{$for}) ? $processors{$for} : sub { shift; };
2479
2110febb 2480 return map { $processor->($_); } @_;
fe05264e 2481}
107b5792 2482
9fe2bb77
RL		 2483# collect_from_file($filename, $line_concat_cond_re, $line_concat)
2484# $filename is a file name to read from
2485# $line_concat_cond_re is a regexp detecting a line continuation ending
2486# $line_concat is a CODEref that takes care of concatenating two lines
2487sub collect_from_file {
2488 my $filename = shift;
2489 my $line_concat_cond_re = shift;
2490 my $line_concat = shift;
2491
2492 open my $fh, $filename || die "unable to read $filename: $!\n";
2493 return sub {
2494 my $saved_line = "";
2495 $_ = "";
2496 while (<$fh>) {
04f171c0 2497 s|\R$||;
9fe2bb77
RL		 2498 if (defined $line_concat) {
2499 $_ = $line_concat->($saved_line, $_);
2500 $saved_line = "";
2501 }
2502 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2503 $saved_line = $_;
2504 next;
2505 }
2506 return $_;
2507 }
2508 die "$filename ending with continuation line\n" if $_;
2509 close $fh;
2510 return undef;
2511 }
2512}
2513
2514# collect_from_array($array, $line_concat_cond_re, $line_concat)
2515# $array is an ARRAYref of lines
2516# $line_concat_cond_re is a regexp detecting a line continuation ending
2517# $line_concat is a CODEref that takes care of concatenating two lines
2518sub collect_from_array {
2519 my $array = shift;
2520 my $line_concat_cond_re = shift;
2521 my $line_concat = shift;
2522 my @array = (@$array);
2523
2524 return sub {
2525 my $saved_line = "";
2526 $_ = "";
2527 while (defined($_ = shift @array)) {
04f171c0 2528 s|\R$||;
9fe2bb77
RL		 2529 if (defined $line_concat) {
2530 $_ = $line_concat->($saved_line, $_);
2531 $saved_line = "";
2532 }
2533 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2534 $saved_line = $_;
2535 next;
2536 }
2537 return $_;
2538 }
2539 die "input text ending with continuation line\n" if $_;
2540 return undef;
2541 }
2542}
2543
2544# collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
2545# $lineiterator is a CODEref that delivers one line at a time.
107b5792
RL		 2546# All following arguments are regex/CODEref pairs, where the regexp detects a
2547# line and the CODEref does something with the result of the regexp.
2548sub collect_information {
9fe2bb77 2549 my $lineiterator = shift;
107b5792
RL		 2550 my %collectors = @_;
2551
9fe2bb77 2552 while(defined($_ = $lineiterator->())) {
04f171c0 2553 s|\R$||;
9fe2bb77 2554 my $found = 0;
2b6b606c
RL		 2555 if ($collectors{"BEFORE"}) {
2556 $collectors{"BEFORE"}->($_);
2557 }
9fe2bb77 2558 foreach my $re (keys %collectors) {
2b6b606c 2559 if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
9fe2bb77
RL		 2560 $collectors{$re}->($lineiterator);
2561 $found = 1;
2562 };
2563 }
2564 if ($collectors{"OTHERWISE"}) {
2565 $collectors{"OTHERWISE"}->($lineiterator, $_)
2566 unless $found || !defined $collectors{"OTHERWISE"};
2567 }
2b6b606c
RL		 2568 if ($collectors{"AFTER"}) {
2569 $collectors{"AFTER"}->($_);
2570 }
107b5792 2571 }
107b5792 2572}
ce959812
RL		 2573
2574# tokenize($line)
2575# $line is a line of text to split up into tokens
2576# returns a list of tokens
2577#
2578# Tokens are divided by spaces. If the tokens include spaces, they
2579# have to be quoted with single or double quotes. Double quotes
2580# inside a double quoted token must be escaped. Escaping is done
2581# with backslash.
2582# Basically, the same quoting rules apply for " and ' as in any
2583# Unix shell.
2584sub tokenize {
2585 my $line = my $debug_line = shift;
2586 my @result = ();
2587
2588 while ($line =~ s|^\s+||, $line ne "") {
2589 my $token = "";
2590 while ($line ne "" && $line !~ m|^\s|) {
2591 if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
2592 $token .= $1;
2593 $line = $';
2594 } elsif ($line =~ m/^'([^']*)'/) {
2595 $token .= $1;
2596 $line = $';
2597 } elsif ($line =~ m/^(\S+)/) {
2598 $token .= $1;
2599 $line = $';
2600 }
2601 }
2602 push @result, $token;
2603 }
2604
2605 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
2606 print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
2607 print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";
2608 }
2609 return @result;
2610}
A mirror of the official openssl repository