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