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