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