]> git.ipfire.org Git - thirdparty/openssl.git/blob - Configure
projects / thirdparty / openssl.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
SHA512/224 and SHA512/256
[thirdparty/openssl.git] / Configure
1 #! /usr/bin/env perl
2 # -*- mode: perl; -*-
3 # Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved.
4 #
5 # Licensed under the OpenSSL license (the "License"). You may not use
6 # this file except in compliance with the License. You can obtain a copy
7 # in the file LICENSE in the source distribution or at
8 # https://www.openssl.org/source/license.html
9
10 ## Configure -- OpenSSL source tree configuration script
11
12 use 5.10.0;
13 use strict;
14 use Config;
15 use FindBin;
16 use lib "$FindBin::Bin/util/perl";
17 use File::Basename;
18 use File::Spec::Functions qw/:DEFAULT abs2rel rel2abs/;
19 use File::Path qw/mkpath/;
20 use OpenSSL::Glob;
21
22 # see INSTALL for instructions.
23
24 my $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";
25
26 # Options:
27 #
28 # --config add the given configuration file, which will be read after
29 # any "Configurations*" files that are found in the same
30 # directory as this script.
31 # --prefix prefix for the OpenSSL installation, which includes the
32 # directories bin, lib, include, share/man, share/doc/openssl
33 # This becomes the value of INSTALLTOP in Makefile
34 # (Default: /usr/local)
35 # --openssldir OpenSSL data area, such as openssl.cnf, certificates and keys.
36 # If it's a relative directory, it will be added on the directory
37 # given with --prefix.
38 # This becomes the value of OPENSSLDIR in Makefile and in C.
39 # (Default: PREFIX/ssl)
40 #
41 # --cross-compile-prefix Add specified prefix to binutils components.
42 #
43 # --api One of 0.9.8, 1.0.0 or 1.1.0. Do not compile support for
44 # interfaces deprecated as of the specified OpenSSL version.
45 #
46 # no-hw-xxx do not compile support for specific crypto hardware.
47 # Generic OpenSSL-style methods relating to this support
48 # are always compiled but return NULL if the hardware
49 # support isn't compiled.
50 # no-hw do not compile support for any crypto hardware.
51 # [no-]threads [don't] try to create a library that is suitable for
52 # multithreaded applications (default is "threads" if we
53 # know how to do it)
54 # [no-]shared [don't] try to create shared libraries when supported.
55 # [no-]pic [don't] try to build position independent code when supported.
56 # If disabled, it also disables shared and dynamic-engine.
57 # no-asm do not use assembler
58 # no-dso do not compile in any native shared-library methods. This
59 # will ensure that all methods just return NULL.
60 # no-egd do not compile support for the entropy-gathering daemon APIs
61 # [no-]zlib [don't] compile support for zlib compression.
62 # zlib-dynamic Like "zlib", but the zlib library is expected to be a shared
63 # library and will be loaded in run-time by the OpenSSL library.
64 # sctp include SCTP support
65 # enable-weak-ssl-ciphers
66 # Enable weak ciphers that are disabled by default.
67 # 386 generate 80386 code in assembly modules
68 # no-sse2 disables IA-32 SSE2 code in assembly modules, the above
69 # mentioned '386' option implies this one
70 # no-<cipher> build without specified algorithm (rsa, idea, rc5, ...)
71 # -<xxx> +<xxx> compiler options are passed through
72 # -static while -static is also a pass-through compiler option (and
73 # as such is limited to environments where it's actually
74 # meaningful), it triggers a number configuration options,
75 # namely no-dso, no-pic, no-shared and no-threads. It is
76 # argued that the only reason to produce statically linked
77 # binaries (and in context it means executables linked with
78 # -static flag, and not just executables linked with static
79 # libcrypto.a) is to eliminate dependency on specific run-time,
80 # a.k.a. libc version. The mentioned config options are meant
81 # to achieve just that. Unfortunately on Linux it's impossible
82 # to eliminate the dependency completely for openssl executable
83 # because of getaddrinfo and gethostbyname calls, which can
84 # invoke dynamically loadable library facility anyway to meet
85 # the lookup requests. For this reason on Linux statically
86 # linked openssl executable has rather debugging value than
87 # production quality.
88 #
89 # DEBUG_SAFESTACK use type-safe stacks to enforce type-safety on stack items
90 # provided to stack calls. Generates unique stack functions for
91 # each possible stack type.
92 # BN_LLONG use the type 'long long' in crypto/bn/bn.h
93 # RC4_CHAR use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
94 # Following are set automatically by this script
95 #
96 # MD5_ASM use some extra md5 assembler,
97 # SHA1_ASM use some extra sha1 assembler, must define L_ENDIAN for x86
98 # RMD160_ASM use some extra ripemd160 assembler,
99 # SHA256_ASM sha256_block is implemented in assembler
100 # SHA512_ASM sha512_block is implemented in assembler
101 # AES_ASM AES_[en|de]crypt is implemented in assembler
102
103 # Minimum warning options... any contributions to OpenSSL should at least get
104 # past these.
105
106 # DEBUG_UNUSED enables __owur (warn unused result) checks.
107 # -DPEDANTIC complements -pedantic and is meant to mask code that
108 # is not strictly standard-compliant and/or implementation-specific,
109 # e.g. inline assembly, disregards to alignment requirements, such
110 # that -pedantic would complain about. Incidentally -DPEDANTIC has
111 # to be used even in sanitized builds, because sanitizer too is
112 # supposed to and does take notice of non-standard behaviour. Then
113 # -pedantic with pre-C9x compiler would also complain about 'long
114 # long' not being supported. As 64-bit algorithms are common now,
115 # it grew impossible to resolve this without sizeable additional
116 # code, so we just tell compiler to be pedantic about everything
117 # but 'long long' type.
118
119 my $gcc_devteam_warn = "-DDEBUG_UNUSED"
120 . " -DPEDANTIC -pedantic -Wno-long-long"
121 . " -Wall"
122 . " -Wextra"
123 . " -Wno-unused-parameter"
124 . " -Wno-missing-field-initializers"
125 . " -Wswitch"
126 . " -Wsign-compare"
127 . " -Wmissing-prototypes"
128 . " -Wshadow"
129 . " -Wformat"
130 . " -Wtype-limits"
131 . " -Wundef"
132 . " -Werror"
133 ;
134
135 # These are used in addition to $gcc_devteam_warn when the compiler is clang.
136 # TODO(openssl-team): fix problems and investigate if (at least) the
137 # following warnings can also be enabled:
138 # -Wcast-align
139 # -Wunreachable-code -- no, too ugly/compiler-specific
140 # -Wlanguage-extension-token -- no, we use asm()
141 # -Wunused-macros -- no, too tricky for BN and _XOPEN_SOURCE etc
142 # -Wextended-offsetof -- no, needed in CMS ASN1 code
143 my $clang_devteam_warn = ""
144 . " -Wswitch-default"
145 . " -Wno-parentheses-equality"
146 . " -Wno-language-extension-token"
147 . " -Wno-extended-offsetof"
148 . " -Wconditional-uninitialized"
149 . " -Wincompatible-pointer-types-discards-qualifiers"
150 . " -Wmissing-variable-declarations"
151 . " -Wno-unknown-warning-option"
152 ;
153
154 # This adds backtrace information to the memory leak info. Is only used
155 # when crypto-mdebug-backtrace is enabled.
156 my $memleak_devteam_backtrace = "-rdynamic";
157
158 my $strict_warnings = 0;
159
160 # As for $BSDthreads. Idea is to maintain "collective" set of flags,
161 # which would cover all BSD flavors. -pthread applies to them all,
162 # but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
163 # -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
164 # which has to be accompanied by explicit -D_THREAD_SAFE and
165 # sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
166 # seems to be sufficient?
167 our $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
168
169 #
170 # API compatibility name to version number mapping.
171 #
172 my $maxapi = "1.1.0"; # API for "no-deprecated" builds
173 my $apitable = {
174 "1.1.0" => "0x10100000L",
175 "1.0.0" => "0x10000000L",
176 "0.9.8" => "0x00908000L",
177 };
178
179 our %table = ();
180 our %config = ();
181 our %withargs = ();
182
183 # Forward declarations ###############################################
184
185 # read_config(filename)
186 #
187 # Reads a configuration file and populates %table with the contents
188 # (which the configuration file places in %targets).
189 sub read_config;
190
191 # resolve_config(target)
192 #
193 # Resolves all the late evaluations, inheritances and so on for the
194 # chosen target and any target it inherits from.
195 sub resolve_config;
196
197
198 # Information collection #############################################
199
200 # Unified build supports separate build dir
201 my $srcdir = catdir(absolutedir(dirname($0))); # catdir ensures local syntax
202 my $blddir = catdir(absolutedir(".")); # catdir ensures local syntax
203 my $dofile = abs2rel(catfile($srcdir, "util/dofile.pl"));
204
205 my $local_config_envname = 'OPENSSL_LOCAL_CONFIG_DIR';
206
207 $config{sourcedir} = abs2rel($srcdir);
208 $config{builddir} = abs2rel($blddir);
209
210 # Collect reconfiguration information if needed
211 my @argvcopy=@ARGV;
212
213 if (grep /^reconf(igure)?$/, @argvcopy) {
214 die "reconfiguring with other arguments present isn't supported"
215 if scalar @argvcopy > 1;
216 if (-f "./configdata.pm") {
217 my $file = "./configdata.pm";
218 unless (my $return = do $file) {
219 die "couldn't parse $file: $@" if $@;
220 die "couldn't do $file: $!" unless defined $return;
221 die "couldn't run $file" unless $return;
222 }
223
224 @argvcopy = defined($configdata::config{perlargv}) ?
225 @{$configdata::config{perlargv}} : ();
226 die "Incorrect data to reconfigure, please do a normal configuration\n"
227 if (grep(/^reconf/,@argvcopy));
228 $config{perlenv} = $configdata::config{perlenv} // {};
229
230 print "Reconfiguring with: ", join(" ",@argvcopy), "\n";
231 foreach (sort keys %{$config{perlenv}}) {
232 print " $_ = $config{perlenv}->{$_}\n";
233 }
234 } else {
235 die "Insufficient data to reconfigure, please do a normal configuration\n";
236 }
237 }
238
239 $config{perlargv} = [ @argvcopy ];
240
241 # Collect version numbers
242 $config{version} = "unknown";
243 $config{version_num} = "unknown";
244 $config{shlib_version_number} = "unknown";
245 $config{shlib_version_history} = "unknown";
246
247 collect_information(
248 collect_from_file(catfile($srcdir,'include/openssl/opensslv.h')),
249 qr/OPENSSL.VERSION.TEXT.*OpenSSL (\S+) / => sub { $config{version} = $1; },
250 qr/OPENSSL.VERSION.NUMBER.*(0x\S+)/ => sub { $config{version_num}=$1 },
251 qr/SHLIB_VERSION_NUMBER *"([^"]+)"/ => sub { $config{shlib_version_number}=$1 },
252 qr/SHLIB_VERSION_HISTORY *"([^"]*)"/ => sub { $config{shlib_version_history}=$1 }
253 );
254 if ($config{shlib_version_history} ne "") { $config{shlib_version_history} .= ":"; }
255
256 ($config{major}, $config{minor})
257 = ($config{version} =~ /^([0-9]+)\.([0-9\.]+)/);
258 ($config{shlib_major}, $config{shlib_minor})
259 = ($config{shlib_version_number} =~ /^([0-9]+)\.([0-9\.]+)/);
260 die "erroneous version information in opensslv.h: ",
261 "$config{major}, $config{minor}, $config{shlib_major}, $config{shlib_minor}\n"
262 if ($config{major} eq "" || $config{minor} eq ""
263 || $config{shlib_major} eq "" || $config{shlib_minor} eq "");
264
265 # Collect target configurations
266
267 my $pattern = catfile(dirname($0), "Configurations", "*.conf");
268 foreach (sort glob($pattern)) {
269 &read_config($_);
270 }
271
272 if (defined env($local_config_envname)) {
273 if ($^O eq 'VMS') {
274 # VMS environment variables are logical names,
275 # which can be used as is
276 $pattern = $local_config_envname . ':' . '*.conf';
277 } else {
278 $pattern = catfile(env($local_config_envname), '*.conf');
279 }
280
281 foreach (sort glob($pattern)) {
282 &read_config($_);
283 }
284 }
285
286 $config{prefix}="";
287 $config{openssldir}="";
288 $config{processor}="";
289 $config{libdir}="";
290 $config{cross_compile_prefix}="";
291 my $auto_threads=1; # enable threads automatically? true by default
292 my $default_ranlib;
293
294 # Top level directories to build
295 $config{dirs} = [ "crypto", "ssl", "engines", "apps", "test", "util", "tools", "fuzz" ];
296 # crypto/ subdirectories to build
297 $config{sdirs} = [
298 "objects",
299 "md2", "md4", "md5", "sha", "mdc2", "hmac", "ripemd", "whrlpool", "poly1305", "blake2", "siphash", "sm3",
300 "des", "aes", "rc2", "rc4", "rc5", "idea", "aria", "bf", "cast", "camellia", "seed", "sm4", "chacha", "modes",
301 "bn", "ec", "rsa", "dsa", "dh", "dso", "engine",
302 "buffer", "bio", "stack", "lhash", "rand", "err",
303 "evp", "asn1", "pem", "x509", "x509v3", "conf", "txt_db", "pkcs7", "pkcs12", "comp", "ocsp", "ui",
304 "cms", "ts", "srp", "cmac", "ct", "async", "kdf", "store"
305 ];
306 # test/ subdirectories to build
307 $config{tdirs} = [ "ossl_shim" ];
308
309 # Known TLS and DTLS protocols
310 my @tls = qw(ssl3 tls1 tls1_1 tls1_2 tls1_3);
311 my @dtls = qw(dtls1 dtls1_2);
312
313 # Explicitly known options that are possible to disable. They can
314 # be regexps, and will be used like this: /^no-${option}$/
315 # For developers: keep it sorted alphabetically
316
317 my @disablables = (
318 "afalgeng",
319 "aria",
320 "asan",
321 "asm",
322 "async",
323 "autoalginit",
324 "autoerrinit",
325 "bf",
326 "blake2",
327 "camellia",
328 "capieng",
329 "cast",
330 "chacha",
331 "cmac",
332 "cms",
333 "comp",
334 "crypto-mdebug",
335 "crypto-mdebug-backtrace",
336 "ct",
337 "deprecated",
338 "des",
339 "devcryptoeng",
340 "dgram",
341 "dh",
342 "dsa",
343 "dso",
344 "dtls",
345 "dynamic-engine",
346 "ec",
347 "ec2m",
348 "ecdh",
349 "ecdsa",
350 "ec_nistp_64_gcc_128",
351 "egd",
352 "engine",
353 "err",
354 "external-tests",
355 "filenames",
356 "fuzz-libfuzzer",
357 "fuzz-afl",
358 "gost",
359 "heartbeats",
360 "hw(-.+)?",
361 "idea",
362 "makedepend",
363 "md2",
364 "md4",
365 "mdc2",
366 "msan",
367 "multiblock",
368 "nextprotoneg",
369 "ocb",
370 "ocsp",
371 "pic",
372 "poly1305",
373 "posix-io",
374 "psk",
375 "rc2",
376 "rc4",
377 "rc5",
378 "rdrand",
379 "rfc3779",
380 "rmd160",
381 "scrypt",
382 "sctp",
383 "seed",
384 "shared",
385 "siphash",
386 "sm3",
387 "sm4",
388 "sock",
389 "srp",
390 "srtp",
391 "sse2",
392 "ssl",
393 "ssl-trace",
394 "static-engine",
395 "stdio",
396 "tests",
397 "threads",
398 "tls",
399 "tls13downgrade",
400 "ts",
401 "ubsan",
402 "ui-console",
403 "unit-test",
404 "whirlpool",
405 "weak-ssl-ciphers",
406 "zlib",
407 "zlib-dynamic",
408 );
409 foreach my $proto ((@tls, @dtls))
410 {
411 push(@disablables, $proto);
412 push(@disablables, "$proto-method") unless $proto eq "tls1_3";
413 }
414
415 my %deprecated_disablables = (
416 "ssl2" => undef,
417 "buf-freelists" => undef,
418 "ripemd" => "rmd160",
419 "ui" => "ui-console",
420 );
421
422 # All of the following is disabled by default (RC5 was enabled before 0.9.8):
423
424 our %disabled = ( # "what" => "comment"
425 "asan" => "default",
426 "crypto-mdebug" => "default",
427 "crypto-mdebug-backtrace" => "default",
428 "devcryptoeng" => "default",
429 "ec_nistp_64_gcc_128" => "default",
430 "egd" => "default",
431 "external-tests" => "default",
432 "fuzz-libfuzzer" => "default",
433 "fuzz-afl" => "default",
434 "heartbeats" => "default",
435 "md2" => "default",
436 "msan" => "default",
437 "rc5" => "default",
438 "sctp" => "default",
439 "ssl-trace" => "default",
440 "ssl3" => "default",
441 "ssl3-method" => "default",
442 "ubsan" => "default",
443 #TODO(TLS1.3): Temporarily disabled while this is a WIP
444 "tls1_3" => "default",
445 "tls13downgrade" => "default",
446 "unit-test" => "default",
447 "weak-ssl-ciphers" => "default",
448 "zlib" => "default",
449 "zlib-dynamic" => "default",
450 );
451
452 # Note: => pair form used for aesthetics, not to truly make a hash table
453 my @disable_cascades = (
454 # "what" => [ "cascade", ... ]
455 sub { $config{processor} eq "386" }
456 => [ "sse2" ],
457 "ssl" => [ "ssl3" ],
458 "ssl3-method" => [ "ssl3" ],
459 "zlib" => [ "zlib-dynamic" ],
460 "des" => [ "mdc2" ],
461 "ec" => [ "ecdsa", "ecdh" ],
462
463 "dgram" => [ "dtls", "sctp" ],
464 "sock" => [ "dgram" ],
465 "dtls" => [ @dtls ],
466 sub { 0 == scalar grep { !$disabled{$_} } @dtls }
467 => [ "dtls" ],
468
469 "tls" => [ @tls ],
470 sub { 0 == scalar grep { !$disabled{$_} } @tls }
471 => [ "tls" ],
472
473 "crypto-mdebug" => [ "crypto-mdebug-backtrace" ],
474
475 # Without DSO, we can't load dynamic engines, so don't build them dynamic
476 "dso" => [ "dynamic-engine" ],
477
478 # Without position independent code, there can be no shared libraries or DSOs
479 "pic" => [ "shared" ],
480 "shared" => [ "dynamic-engine" ],
481 "engine" => [ "afalgeng", "devcryptoeng" ],
482
483 # no-autoalginit is only useful when building non-shared
484 "autoalginit" => [ "shared", "apps" ],
485
486 "stdio" => [ "apps", "capieng", "egd" ],
487 "apps" => [ "tests" ],
488 "tests" => [ "external-tests" ],
489 "comp" => [ "zlib" ],
490 "ec" => [ "tls1_3" ],
491 sub { !$disabled{"unit-test"} } => [ "heartbeats" ],
492
493 sub { !$disabled{"msan"} } => [ "asm" ],
494 );
495
496 # Avoid protocol support holes. Also disable all versions below N, if version
497 # N is disabled while N+1 is enabled.
498 #
499 my @list = (reverse @tls);
500 while ((my $first, my $second) = (shift @list, shift @list)) {
501 last unless @list;
502 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
503 => [ @list ] );
504 unshift @list, $second;
505 }
506 my @list = (reverse @dtls);
507 while ((my $first, my $second) = (shift @list, shift @list)) {
508 last unless @list;
509 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
510 => [ @list ] );
511 unshift @list, $second;
512 }
513
514 # Explicit "no-..." options will be collected in %disabled along with the defaults.
515 # To remove something from %disabled, use "enable-foo".
516 # For symmetry, "disable-foo" is a synonym for "no-foo".
517
518 my $no_sse2=0;
519
520 &usage if ($#ARGV < 0);
521
522 my $user_cflags="";
523 my @user_defines=();
524 $config{openssl_api_defines}=[];
525 $config{openssl_algorithm_defines}=[];
526 $config{openssl_thread_defines}=[];
527 $config{openssl_sys_defines}=[];
528 $config{openssl_other_defines}=[];
529 my $ldflags="";
530 my $libs="";
531 my $target="";
532 $config{options}="";
533 $config{build_type} = "release";
534
535 my %unsupported_options = ();
536 my %deprecated_options = ();
537 # If you change this, update apps/version.c
538 my @known_seed_sources = qw(getrandom devrandom os egd none rdcpu librandom);
539 my @seed_sources = ();
540 while (@argvcopy)
541 {
542 $_ = shift @argvcopy;
543
544 # Support env variable assignments among the options
545 if (m|^(\w+)=(.+)?$|)
546 {
547 $config{perlenv}->{$1} = $2;
548 next;
549 }
550
551 # VMS is a case insensitive environment, and depending on settings
552 # out of our control, we may receive options uppercased. Let's
553 # downcase at least the part before any equal sign.
554 if ($^O eq "VMS")
555 {
556 s/^([^=]*)/lc($1)/e;
557 }
558 s /^-no-/no-/; # some people just can't read the instructions
559
560 # rewrite some options in "enable-..." form
561 s /^-?-?shared$/enable-shared/;
562 s /^sctp$/enable-sctp/;
563 s /^threads$/enable-threads/;
564 s /^zlib$/enable-zlib/;
565 s /^zlib-dynamic$/enable-zlib-dynamic/;
566
567 if (/^(no|disable|enable)-(.+)$/)
568 {
569 my $word = $2;
570 if (!exists $deprecated_disablables{$word}
571 && !grep { $word =~ /^${_}$/ } @disablables)
572 {
573 $unsupported_options{$_} = 1;
574 next;
575 }
576 }
577 if (/^no-(.+)$/ || /^disable-(.+)$/)
578 {
579 foreach my $proto ((@tls, @dtls))
580 {
581 if ($1 eq "$proto-method")
582 {
583 $disabled{"$proto"} = "option($proto-method)";
584 last;
585 }
586 }
587 if ($1 eq "dtls")
588 {
589 foreach my $proto (@dtls)
590 {
591 $disabled{$proto} = "option(dtls)";
592 }
593 $disabled{"dtls"} = "option(dtls)";
594 }
595 elsif ($1 eq "ssl")
596 {
597 # Last one of its kind
598 $disabled{"ssl3"} = "option(ssl)";
599 }
600 elsif ($1 eq "tls")
601 {
602 # XXX: Tests will fail if all SSL/TLS
603 # protocols are disabled.
604 foreach my $proto (@tls)
605 {
606 $disabled{$proto} = "option(tls)";
607 }
608 }
609 elsif ($1 eq "static-engine")
610 {
611 delete $disabled{"dynamic-engine"};
612 }
613 elsif ($1 eq "dynamic-engine")
614 {
615 $disabled{"dynamic-engine"} = "option";
616 }
617 elsif (exists $deprecated_disablables{$1})
618 {
619 $deprecated_options{$_} = 1;
620 if (defined $deprecated_disablables{$1})
621 {
622 $disabled{$deprecated_disablables{$1}} = "option";
623 }
624 }
625 else
626 {
627 $disabled{$1} = "option";
628 }
629 # No longer an automatic choice
630 $auto_threads = 0 if ($1 eq "threads");
631 }
632 elsif (/^enable-(.+)$/)
633 {
634 if ($1 eq "static-engine")
635 {
636 $disabled{"dynamic-engine"} = "option";
637 }
638 elsif ($1 eq "dynamic-engine")
639 {
640 delete $disabled{"dynamic-engine"};
641 }
642 elsif ($1 eq "zlib-dynamic")
643 {
644 delete $disabled{"zlib"};
645 }
646 my $algo = $1;
647 delete $disabled{$algo};
648
649 # No longer an automatic choice
650 $auto_threads = 0 if ($1 eq "threads");
651 }
652 elsif (/^--strict-warnings$/)
653 {
654 $strict_warnings = 1;
655 }
656 elsif (/^--debug$/)
657 {
658 $config{build_type} = "debug";
659 }
660 elsif (/^--release$/)
661 {
662 $config{build_type} = "release";
663 }
664 elsif (/^386$/)
665 { $config{processor}=386; }
666 elsif (/^fips$/)
667 {
668 die "FIPS mode not supported\n";
669 }
670 elsif (/^rsaref$/)
671 {
672 # No RSAref support any more since it's not needed.
673 # The check for the option is there so scripts aren't
674 # broken
675 }
676 elsif (/^nofipscanistercheck$/)
677 {
678 die "FIPS mode not supported\n";
679 }
680 elsif (/^[-+]/)
681 {
682 if (/^--prefix=(.*)$/)
683 {
684 $config{prefix}=$1;
685 die "Directory given with --prefix MUST be absolute\n"
686 unless file_name_is_absolute($config{prefix});
687 }
688 elsif (/^--api=(.*)$/)
689 {
690 $config{api}=$1;
691 }
692 elsif (/^--libdir=(.*)$/)
693 {
694 $config{libdir}=$1;
695 }
696 elsif (/^--openssldir=(.*)$/)
697 {
698 $config{openssldir}=$1;
699 }
700 elsif (/^--with-zlib-lib=(.*)$/)
701 {
702 $withargs{zlib_lib}=$1;
703 }
704 elsif (/^--with-zlib-include=(.*)$/)
705 {
706 $withargs{zlib_include}=$1;
707 }
708 elsif (/^--with-fuzzer-lib=(.*)$/)
709 {
710 $withargs{fuzzer_lib}=$1;
711 }
712 elsif (/^--with-fuzzer-include=(.*)$/)
713 {
714 $withargs{fuzzer_include}=$1;
715 }
716 elsif (/^--with-rand-seed=(.*)$/)
717 {
718 foreach my $x (split(m|,|, $1))
719 {
720 die "Unknown --with-rand-seed choice $x\n"
721 if ! grep { $x eq $_ } @known_seed_sources;
722 push @seed_sources, $x;
723 }
724 }
725 elsif (/^--cross-compile-prefix=(.*)$/)
726 {
727 $config{cross_compile_prefix}=$1;
728 }
729 elsif (/^--config=(.*)$/)
730 {
731 read_config $1;
732 }
733 elsif (/^-L(.*)$/)
734 {
735 $ldflags.=$_." ";
736 }
737 elsif (/^-l(.*)$/ or /^-Wl,/)
738 {
739 $libs.=$_." ";
740 }
741 elsif (/^-framework$/)
742 {
743 $libs.=$_." ".shift(@argvcopy)." ";
744 }
745 elsif (/^-rpath$/ or /^-R$/)
746 # -rpath is the OSF1 rpath flag
747 # -R is the old Solaris rpath flag
748 {
749 my $rpath = shift(@argvcopy) || "";
750 $rpath .= " " if $rpath ne "";
751 $libs.=$_." ".$rpath;
752 }
753 elsif (/^-static$/)
754 {
755 $libs.=$_." ";
756 $disabled{"dso"} = "forced";
757 $disabled{"pic"} = "forced";
758 $disabled{"shared"} = "forced";
759 $disabled{"threads"} = "forced";
760 }
761 elsif (/^-D(.*)$/)
762 {
763 push @user_defines, $1;
764 }
765 else # common if (/^[-+]/), just pass down...
766 {
767 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
768 $user_cflags.=" ".$_;
769 }
770 }
771 else
772 {
773 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
774 $target=$_;
775 }
776 unless ($_ eq $target || /^no-/ || /^disable-/)
777 {
778 # "no-..." follows later after implied deactivations
779 # have been derived. (Don't take this too seriously,
780 # we really only write OPTIONS to the Makefile out of
781 # nostalgia.)
782
783 if ($config{options} eq "")
784 { $config{options} = $_; }
785 else
786 { $config{options} .= " ".$_; }
787 }
788
789 if (defined($config{api}) && !exists $apitable->{$config{api}}) {
790 die "***** Unsupported api compatibility level: $config{api}\n",
791 }
792
793 if (keys %deprecated_options)
794 {
795 warn "***** Deprecated options: ",
796 join(", ", keys %deprecated_options), "\n";
797 }
798 if (keys %unsupported_options)
799 {
800 die "***** Unsupported options: ",
801 join(", ", keys %unsupported_options), "\n";
802 }
803 }
804
805 if ($libs =~ /(^|\s)-Wl,-rpath,/
806 && !$disabled{shared}
807 && !($disabled{asan} && $disabled{msan} && $disabled{ubsan})) {
808 die "***** Cannot simultaneously use -rpath, shared libraries, and\n",
809 "***** any of asan, msan or ubsan\n";
810 }
811
812 if (scalar(@seed_sources) == 0) {
813 print "Using implicit seed configuration\n";
814 push @seed_sources, 'os';
815 }
816 die "Cannot seed with none and anything else"
817 if scalar(grep { $_ eq 'none' } @seed_sources) > 0
818 && scalar(@seed_sources) > 1;
819 push @{$config{openssl_other_defines}},
820 map { (my $x = $_) =~ tr|[\-a-z]|[_A-Z]|; "OPENSSL_RAND_SEED_$x" }
821 @seed_sources;
822
823 my @tocheckfor = (keys %disabled);
824 while (@tocheckfor) {
825 my %new_tocheckfor = ();
826 my @cascade_copy = (@disable_cascades);
827 while (@cascade_copy) {
828 my ($test, $descendents) = (shift @cascade_copy, shift @cascade_copy);
829 if (ref($test) eq "CODE" ? $test->() : defined($disabled{$test})) {
830 foreach(grep { !defined($disabled{$_}) } @$descendents) {
831 $new_tocheckfor{$_} = 1; $disabled{$_} = "forced";
832 }
833 }
834 }
835 @tocheckfor = (keys %new_tocheckfor);
836 }
837
838 our $die = sub { die @_; };
839 if ($target eq "TABLE") {
840 local $die = sub { warn @_; };
841 foreach (sort keys %table) {
842 print_table_entry($_, "TABLE");
843 }
844 exit 0;
845 }
846
847 if ($target eq "LIST") {
848 foreach (sort keys %table) {
849 print $_,"\n" unless $table{$_}->{template};
850 }
851 exit 0;
852 }
853
854 if ($target eq "HASH") {
855 local $die = sub { warn @_; };
856 print "%table = (\n";
857 foreach (sort keys %table) {
858 print_table_entry($_, "HASH");
859 }
860 exit 0;
861 }
862
863 print "Configuring OpenSSL version $config{version} ($config{version_num})\n";
864 print "for $target\n";
865
866 # Backward compatibility?
867 if ($target =~ m/^CygWin32(-.*)$/) {
868 $target = "Cygwin".$1;
869 }
870
871 # Support for legacy targets having a name starting with 'debug-'
872 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
873 if ($d) {
874 $config{build_type} = "debug";
875
876 # If we do not find debug-foo in the table, the target is set to foo.
877 if (!$table{$target}) {
878 $target = $t;
879 }
880 }
881 $config{target} = $target;
882 my %target = resolve_config($target);
883
884 &usage if (!%target || $target{template});
885
886 %target = ( %{$table{DEFAULTS}}, %target );
887
888 # Make the flags to build DSOs the same as for shared libraries unless they
889 # are already defined
890 $target{dso_cflags} = $target{shared_cflag} unless defined $target{dso_cflags};
891 $target{dso_cxxflags} = $target{shared_cxxflag} unless defined $target{dso_cxxflags};
892 $target{dso_lflags} = $target{shared_ldflag} unless defined $target{dso_lflags};
893 {
894 my $shared_info_pl =
895 catfile(dirname($0), "Configurations", "shared-info.pl");
896 my %shared_info = read_eval_file($shared_info_pl);
897 push @{$target{_conf_fname_int}}, $shared_info_pl;
898 my $si = $target{shared_target};
899 while (ref $si ne "HASH") {
900 last if ! defined $si;
901 if (ref $si eq "CODE") {
902 $si = $si->();
903 } else {
904 $si = $shared_info{$si};
905 }
906 }
907
908 # Some of the 'shared_target' values don't have any entried in
909 # %shared_info. That's perfectly fine, AS LONG AS the build file
910 # template knows how to handle this. That is currently the case for
911 # Windows and VMS.
912 if (defined $si) {
913 # Just as above, copy certain shared_* attributes to the corresponding
914 # dso_ attribute unless the latter is already defined
915 $si->{dso_cflags} = $si->{shared_cflag} unless defined $si->{dso_cflags};
916 $si->{dso_cxxflags} = $si->{shared_cxxflag} unless defined $si->{dso_cxxflags};
917 $si->{dso_lflags} = $si->{shared_ldflag} unless defined $si->{dso_lflags};
918 foreach (sort keys %$si) {
919 $target{$_} = defined $target{$_}
920 ? add($si->{$_})->($target{$_})
921 : $si->{$_};
922 }
923 }
924 }
925
926 my %conf_files = map { $_ => 1 } (@{$target{_conf_fname_int}});
927 $config{conf_files} = [ sort keys %conf_files ];
928
929 foreach my $feature (@{$target{disable}}) {
930 if (exists $deprecated_disablables{$feature}) {
931 warn "***** config $target disables deprecated feature $feature\n";
932 } elsif (!grep { $feature eq $_ } @disablables) {
933 die "***** config $target disables unknown feature $feature\n";
934 }
935 $disabled{$feature} = 'config';
936 }
937 foreach my $feature (@{$target{enable}}) {
938 if ("default" eq ($disabled{$_} // "")) {
939 if (exists $deprecated_disablables{$feature}) {
940 warn "***** config $target enables deprecated feature $feature\n";
941 } elsif (!grep { $feature eq $_ } @disablables) {
942 die "***** config $target enables unknown feature $feature\n";
943 }
944 delete $disabled{$_};
945 }
946 }
947
948 foreach (sort (keys %disabled))
949 {
950 $config{options} .= " no-$_";
951
952 printf " no-%-12s %-10s", $_, "[$disabled{$_}]";
953
954 if (/^dso$/)
955 { }
956 elsif (/^threads$/)
957 { }
958 elsif (/^shared$/)
959 { }
960 elsif (/^pic$/)
961 { }
962 elsif (/^zlib$/)
963 { }
964 elsif (/^dynamic-engine$/)
965 { }
966 elsif (/^makedepend$/)
967 { }
968 elsif (/^zlib-dynamic$/)
969 { }
970 elsif (/^sse2$/)
971 { $no_sse2 = 1; }
972 elsif (/^engine$/)
973 {
974 @{$config{dirs}} = grep !/^engines$/, @{$config{dirs}};
975 @{$config{sdirs}} = grep !/^engine$/, @{$config{sdirs}};
976 push @{$config{openssl_other_defines}}, "OPENSSL_NO_ENGINE";
977 print " OPENSSL_NO_ENGINE (skip engines)";
978 }
979 else
980 {
981 my ($WHAT, $what);
982
983 ($WHAT = $what = $_) =~ tr/[\-a-z]/[_A-Z]/;
984
985 # Fix up C macro end names
986 $WHAT = "RMD160" if $what eq "ripemd";
987
988 # fix-up crypto/directory name(s)
989 $what = "ripemd" if $what eq "rmd160";
990 $what = "whrlpool" if $what eq "whirlpool";
991
992 if ($what ne "async" && $what ne "err"
993 && grep { $_ eq $what } @{$config{sdirs}})
994 {
995 push @{$config{openssl_algorithm_defines}}, "OPENSSL_NO_$WHAT";
996 @{$config{sdirs}} = grep { $_ ne $what} @{$config{sdirs}};
997
998 print " OPENSSL_NO_$WHAT (skip dir)";
999 }
1000 else
1001 {
1002 push @{$config{openssl_other_defines}}, "OPENSSL_NO_$WHAT";
1003 print " OPENSSL_NO_$WHAT";
1004
1005 if (/^err$/) { push @user_defines, "OPENSSL_NO_ERR"; }
1006 }
1007 }
1008
1009 print "\n";
1010 }
1011
1012 $target{cxxflags}=$target{cflags} unless defined $target{cxxflags};
1013 $target{exe_extension}="";
1014 $target{exe_extension}=".exe" if ($config{target} eq "DJGPP"
1015 || $config{target} =~ /^(?:Cygwin|mingw)/);
1016 $target{exe_extension}=".pm" if ($config{target} =~ /vos/);
1017
1018 ($target{shared_extension_simple}=$target{shared_extension})
1019 =~ s|\.\$\(SHLIB_VERSION_NUMBER\)||;
1020 $target{dso_extension}=$target{shared_extension_simple};
1021 ($target{shared_import_extension}=$target{shared_extension_simple}.".a")
1022 if ($config{target} =~ /^(?:Cygwin|mingw)/);
1023
1024
1025 $config{cross_compile_prefix} = env('CROSS_COMPILE')
1026 if $config{cross_compile_prefix} eq "";
1027
1028 # Allow overriding the names of some tools. USE WITH CARE
1029 # Note: only Unix cares about HASHBANGPERL... that explains
1030 # the default string.
1031 $config{perl} = ($^O ne "VMS" ? $^X : "perl");
1032 $config{hashbangperl} =
1033 env('HASHBANGPERL') || env('PERL') || "/usr/bin/env perl";
1034 $target{cc} = env('CC') || $target{cc} || "cc";
1035 $target{cxx} = env('CXX') || $target{cxx} || "c++";
1036 $target{ranlib} = env('RANLIB') || $target{ranlib} ||
1037 (which("$config{cross_compile_prefix}ranlib") ?
1038 "\$(CROSS_COMPILE)ranlib" : "true");
1039 $target{ar} = env('AR') || $target{ar} || "ar";
1040 $target{nm} = env('NM') || $target{nm} || "nm";
1041 $target{rc} =
1042 env('RC') || env('WINDRES') || $target{rc} || "windres";
1043
1044 # Allow overriding the build file name
1045 $target{build_file} = env('BUILDFILE') || $target{build_file} || "Makefile";
1046
1047 # Cache information necessary for reconfiguration
1048 $config{cc} = $target{cc};
1049 $config{cxx} = $target{cxx};
1050 $config{build_file} = $target{build_file};
1051
1052 # For cflags, lflags, plib_lflags, ex_libs and defines, add the debug_
1053 # or release_ attributes.
1054 # Do it in such a way that no spurious space is appended (hence the grep).
1055 $config{defines} = [];
1056 $config{cflags} = "";
1057 $config{cxxflags} = "";
1058 $config{lflags} = "";
1059 $config{ex_libs} = "";
1060 $config{shared_ldflag} = "";
1061
1062 # Make sure build_scheme is consistent.
1063 $target{build_scheme} = [ $target{build_scheme} ]
1064 if ref($target{build_scheme}) ne "ARRAY";
1065
1066 my ($builder, $builder_platform, @builder_opts) =
1067 @{$target{build_scheme}};
1068
1069 foreach my $checker (($builder_platform."-".$target{build_file}."-checker.pm",
1070 $builder_platform."-checker.pm")) {
1071 my $checker_path = catfile($srcdir, "Configurations", $checker);
1072 if (-f $checker_path) {
1073 my $fn = $ENV{CONFIGURE_CHECKER_WARN}
1074 ? sub { warn $@; } : sub { die $@; };
1075 if (! do $checker_path) {
1076 if ($@) {
1077 $fn->($@);
1078 } elsif ($!) {
1079 $fn->($!);
1080 } else {
1081 $fn->("The detected tools didn't match the platform\n");
1082 }
1083 }
1084 last;
1085 }
1086 }
1087
1088 push @{$config{defines}}, "NDEBUG" if $config{build_type} eq "release";
1089
1090 if ($target =~ /^mingw/ && `$target{cc} --target-help 2>&1` =~ m/-mno-cygwin/m)
1091 {
1092 $config{cflags} .= " -mno-cygwin";
1093 $config{shared_ldflag} .= " -mno-cygwin";
1094 }
1095
1096 if ($target =~ /linux.*-mips/ && !$disabled{asm} && $user_cflags !~ /-m(ips|arch=)/) {
1097 # minimally required architecture flags for assembly modules
1098 $config{cflags}="-mips2 $config{cflags}" if ($target =~ /mips32/);
1099 $config{cflags}="-mips3 $config{cflags}" if ($target =~ /mips64/);
1100 }
1101
1102 my $no_shared_warn=0;
1103 my $no_user_cflags=0;
1104 my $no_user_defines=0;
1105
1106 # The DSO code currently always implements all functions so that no
1107 # applications will have to worry about that from a compilation point
1108 # of view. However, the "method"s may return zero unless that platform
1109 # has support compiled in for them. Currently each method is enabled
1110 # by a define "DSO_<name>" ... we translate the "dso_scheme" config
1111 # string entry into using the following logic;
1112 if (!$disabled{dso} && $target{dso_scheme} ne "")
1113 {
1114 $target{dso_scheme} =~ tr/[a-z]/[A-Z]/;
1115 if ($target{dso_scheme} eq "DLFCN")
1116 {
1117 unshift @{$config{defines}}, "DSO_DLFCN", "HAVE_DLFCN_H";
1118 }
1119 elsif ($target{dso_scheme} eq "DLFCN_NO_H")
1120 {
1121 unshift @{$config{defines}}, "DSO_DLFCN";
1122 }
1123 else
1124 {
1125 unshift @{$config{defines}}, "DSO_$target{dso_scheme}";
1126 }
1127 }
1128
1129 $config{ex_libs}="$libs$config{ex_libs}" if ($libs ne "");
1130 $config{lflags}="$config{lflags}$ldflags" if ($ldflags ne "");
1131
1132 # If threads aren't disabled, check how possible they are
1133 unless ($disabled{threads}) {
1134 if ($auto_threads) {
1135 # Enabled by default, disable it forcibly if unavailable
1136 if ($target{thread_scheme} eq "(unknown)") {
1137 $disabled{threads} = "unavailable";
1138 }
1139 } else {
1140 # The user chose to enable threads explicitly, let's see
1141 # if there's a chance that's possible
1142 if ($target{thread_scheme} eq "(unknown)") {
1143 # If the user asked for "threads" and we don't have internal
1144 # knowledge how to do it, [s]he is expected to provide any
1145 # system-dependent compiler options that are necessary. We
1146 # can't truly check that the given options are correct, but
1147 # we expect the user to know what [s]He is doing.
1148 if ($no_user_cflags && $no_user_defines) {
1149 die "You asked for multi-threading support, but didn't\n"
1150 ,"provide any system-specific compiler options\n";
1151 }
1152 }
1153 }
1154 }
1155
1156 # If threads still aren't disabled, add a C macro to ensure the source
1157 # code knows about it. Any other flag is taken care of by the configs.
1158 unless($disabled{threads}) {
1159 foreach (("defines", "openssl_thread_defines")) {
1160 push @{$config{$_}}, "OPENSSL_THREADS";
1161 }
1162 }
1163
1164 # With "deprecated" disable all deprecated features.
1165 if (defined($disabled{"deprecated"})) {
1166 $config{api} = $maxapi;
1167 }
1168
1169 if ($target{shared_target} eq "")
1170 {
1171 $no_shared_warn = 1
1172 if (!$disabled{shared} || !$disabled{"dynamic-engine"});
1173 $disabled{shared} = "no-shared-target";
1174 $disabled{pic} = $disabled{shared} = $disabled{"dynamic-engine"} =
1175 "no-shared-target";
1176 }
1177
1178 if ($disabled{"dynamic-engine"}) {
1179 push @{$config{defines}}, "OPENSSL_NO_DYNAMIC_ENGINE";
1180 $config{dynamic_engines} = 0;
1181 } else {
1182 push @{$config{defines}}, "OPENSSL_NO_STATIC_ENGINE";
1183 $config{dynamic_engines} = 1;
1184 }
1185
1186 unless ($disabled{asan}) {
1187 $config{cflags} .= "-fsanitize=address ";
1188 }
1189
1190 unless ($disabled{ubsan}) {
1191 # -DPEDANTIC or -fnosanitize=alignment may also be required on some
1192 # platforms.
1193 $config{cflags} .= "-fsanitize=undefined -fno-sanitize-recover=all ";
1194 }
1195
1196 unless ($disabled{msan}) {
1197 $config{cflags} .= "-fsanitize=memory ";
1198 }
1199
1200 unless ($disabled{"fuzz-libfuzzer"} && $disabled{"fuzz-afl"}
1201 && $disabled{asan} && $disabled{ubsan} && $disabled{msan}) {
1202 $config{cflags} .= "-fno-omit-frame-pointer -g ";
1203 }
1204 #
1205 # Platform fix-ups
1206 #
1207
1208 # This saves the build files from having to check
1209 if ($disabled{pic})
1210 {
1211 foreach (qw(shared_cflag shared_cxxflag shared_ldflag
1212 dso_cflags dso_cxxflags dso_lflags))
1213 {
1214 $target{$_} = "";
1215 }
1216 }
1217 else
1218 {
1219 push @{$config{defines}}, "OPENSSL_PIC";
1220 }
1221
1222 if ($target{sys_id} ne "")
1223 {
1224 push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
1225 }
1226
1227 unless ($disabled{asm}) {
1228 $target{cpuid_asm_src}=$table{DEFAULTS}->{cpuid_asm_src} if ($config{processor} eq "386");
1229 $target{bn_asm_src} =~ s/\w+-gf2m.c// if (defined($disabled{ec2m}));
1230
1231 # bn-586 is the only one implementing bn_*_part_words
1232 push @{$config{defines}}, "OPENSSL_BN_ASM_PART_WORDS" if ($target{bn_asm_src} =~ /bn-586/);
1233 push @{$config{defines}}, "OPENSSL_IA32_SSE2" if (!$no_sse2 && $target{bn_asm_src} =~ /86/);
1234
1235 push @{$config{defines}}, "OPENSSL_BN_ASM_MONT" if ($target{bn_asm_src} =~ /-mont/);
1236 push @{$config{defines}}, "OPENSSL_BN_ASM_MONT5" if ($target{bn_asm_src} =~ /-mont5/);
1237 push @{$config{defines}}, "OPENSSL_BN_ASM_GF2m" if ($target{bn_asm_src} =~ /-gf2m/);
1238
1239 if ($target{sha1_asm_src}) {
1240 push @{$config{defines}}, "SHA1_ASM" if ($target{sha1_asm_src} =~ /sx86/ || $target{sha1_asm_src} =~ /sha1/);
1241 push @{$config{defines}}, "SHA256_ASM" if ($target{sha1_asm_src} =~ /sha256/);
1242 push @{$config{defines}}, "SHA512_ASM" if ($target{sha1_asm_src} =~ /sha512/);
1243 }
1244 if ($target{rc4_asm_src} ne $table{DEFAULTS}->{rc4_asm_src}) {
1245 push @{$config{defines}}, "RC4_ASM";
1246 }
1247 if ($target{md5_asm_src}) {
1248 push @{$config{defines}}, "MD5_ASM";
1249 }
1250 $target{cast_asm_src}=$table{DEFAULTS}->{cast_asm_src} unless $disabled{pic}; # CAST assembler is not PIC
1251 if ($target{rmd160_asm_src}) {
1252 push @{$config{defines}}, "RMD160_ASM";
1253 }
1254 if ($target{aes_asm_src}) {
1255 push @{$config{defines}}, "AES_ASM" if ($target{aes_asm_src} =~ m/\baes-/);;
1256 # aes-ctr.fake is not a real file, only indication that assembler
1257 # module implements AES_ctr32_encrypt...
1258 push @{$config{defines}}, "AES_CTR_ASM" if ($target{aes_asm_src} =~ s/\s*aes-ctr\.fake//);
1259 # aes-xts.fake indicates presence of AES_xts_[en|de]crypt...
1260 push @{$config{defines}}, "AES_XTS_ASM" if ($target{aes_asm_src} =~ s/\s*aes-xts\.fake//);
1261 $target{aes_asm_src} =~ s/\s*(vpaes|aesni)-x86\.s//g if ($no_sse2);
1262 push @{$config{defines}}, "VPAES_ASM" if ($target{aes_asm_src} =~ m/vpaes/);
1263 push @{$config{defines}}, "BSAES_ASM" if ($target{aes_asm_src} =~ m/bsaes/);
1264 }
1265 if ($target{wp_asm_src} =~ /mmx/) {
1266 if ($config{processor} eq "386") {
1267 $target{wp_asm_src}=$table{DEFAULTS}->{wp_asm_src};
1268 } elsif (!$disabled{"whirlpool"}) {
1269 push @{$config{defines}}, "WHIRLPOOL_ASM";
1270 }
1271 }
1272 if ($target{modes_asm_src} =~ /ghash-/) {
1273 push @{$config{defines}}, "GHASH_ASM";
1274 }
1275 if ($target{ec_asm_src} =~ /ecp_nistz256/) {
1276 push @{$config{defines}}, "ECP_NISTZ256_ASM";
1277 }
1278 if ($target{padlock_asm_src} ne $table{DEFAULTS}->{padlock_asm_src}) {
1279 push @{$config{defines}}, "PADLOCK_ASM";
1280 }
1281 if ($target{poly1305_asm_src} ne "") {
1282 push @{$config{defines}}, "POLY1305_ASM";
1283 }
1284 }
1285
1286 my %predefined = compiler_predefined($target{cc});
1287
1288 # Check for makedepend capabilities.
1289 if (!$disabled{makedepend}) {
1290 if ($config{target} =~ /^(VC|vms)-/) {
1291 # For VC- and vms- targets, there's nothing more to do here. The
1292 # functionality is hard coded in the corresponding build files for
1293 # cl (Windows) and CC/DECC (VMS).
1294 } elsif ($predefined{__GNUC__} >= 3) {
1295 # We know that GNU C version 3 and up as well as all clang
1296 # versions support dependency generation
1297 $config{makedepprog} = "\$(CROSS_COMPILE)$target{cc}";
1298 } else {
1299 # In all other cases, we look for 'makedepend', and disable the
1300 # capability if not found.
1301 $config{makedepprog} = which('makedepend');
1302 $disabled{makedepend} = "unavailable" unless $config{makedepprog};
1303 }
1304 }
1305
1306
1307 # Deal with bn_ops ###################################################
1308
1309 $config{bn_ll} =0;
1310 $config{export_var_as_fn} =0;
1311 my $def_int="unsigned int";
1312 $config{rc4_int} =$def_int;
1313 ($config{b64l},$config{b64},$config{b32})=(0,0,1);
1314
1315 my $count = 0;
1316 foreach (sort split(/\s+/,$target{bn_ops})) {
1317 $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1318 $config{export_var_as_fn}=1 if $_ eq 'EXPORT_VAR_AS_FN';
1319 $config{bn_ll}=1 if $_ eq 'BN_LLONG';
1320 $config{rc4_int}="unsigned char" if $_ eq 'RC4_CHAR';
1321 ($config{b64l},$config{b64},$config{b32})
1322 =(0,1,0) if $_ eq 'SIXTY_FOUR_BIT';
1323 ($config{b64l},$config{b64},$config{b32})
1324 =(1,0,0) if $_ eq 'SIXTY_FOUR_BIT_LONG';
1325 ($config{b64l},$config{b64},$config{b32})
1326 =(0,0,1) if $_ eq 'THIRTY_TWO_BIT';
1327 }
1328 die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1329 if $count > 1;
1330
1331
1332 # Hack cflags for better warnings (dev option) #######################
1333
1334 # "Stringify" the C flags string. This permits it to be made part of a string
1335 # and works as well on command lines.
1336 $config{cflags} =~ s/([\\\"])/\\$1/g;
1337
1338 if (defined($config{api})) {
1339 $config{openssl_api_defines} = [ "OPENSSL_MIN_API=".$apitable->{$config{api}} ];
1340 my $apiflag = sprintf("OPENSSL_API_COMPAT=%s", $apitable->{$config{api}});
1341 push @{$config{defines}}, $apiflag;
1342 }
1343
1344 if (defined($predefined{__clang__}) && !$disabled{asm}) {
1345 $config{cflags} .= " -Qunused-arguments";
1346 }
1347
1348 if ($strict_warnings)
1349 {
1350 my $wopt;
1351 my $gccver = $predefined{__GNUC__} // -1;
1352
1353 die "ERROR --strict-warnings requires gcc[>=4] or gcc-alike"
1354 unless $gccver >= 4;
1355 $gcc_devteam_warn .= " -Wmisleading-indentation" if $gccver >= 6;
1356 foreach $wopt (split /\s+/, $gcc_devteam_warn)
1357 {
1358 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1359 }
1360 if (defined($predefined{__clang__}))
1361 {
1362 foreach $wopt (split /\s+/, $clang_devteam_warn)
1363 {
1364 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1365 }
1366 }
1367 }
1368
1369 unless ($disabled{"crypto-mdebug-backtrace"})
1370 {
1371 foreach my $wopt (split /\s+/, $memleak_devteam_backtrace)
1372 {
1373 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1374 }
1375 if ($target =~ /^BSD-/)
1376 {
1377 $config{ex_libs} .= " -lexecinfo";
1378 }
1379 }
1380
1381 if ($user_cflags ne "") { $config{cflags}="$config{cflags}$user_cflags"; $config{cxxflags}="$config{cxxflags}$user_cflags";}
1382 else { $no_user_cflags=1; }
1383 if (@user_defines) { $config{defines}=[ @{$config{defines}}, @user_defines ]; }
1384 else { $no_user_defines=1; }
1385
1386 # ALL MODIFICATIONS TO %config and %target MUST BE DONE FROM HERE ON
1387
1388 unless ($disabled{afalgeng}) {
1389 $config{afalgeng}="";
1390 if ($target =~ m/^linux/) {
1391 my $minver = 4*10000 + 1*100 + 0;
1392 if ($config{cross_compile_prefix} eq "") {
1393 my $verstr = `uname -r`;
1394 my ($ma, $mi1, $mi2) = split("\\.", $verstr);
1395 ($mi2) = $mi2 =~ /(\d+)/;
1396 my $ver = $ma*10000 + $mi1*100 + $mi2;
1397 if ($ver < $minver) {
1398 $disabled{afalgeng} = "too-old-kernel";
1399 } else {
1400 push @{$config{engdirs}}, "afalg";
1401 }
1402 } else {
1403 $disabled{afalgeng} = "cross-compiling";
1404 }
1405 } else {
1406 $disabled{afalgeng} = "not-linux";
1407 }
1408 }
1409
1410 push @{$config{openssl_other_defines}}, "OPENSSL_NO_AFALGENG" if ($disabled{afalgeng});
1411
1412 # If we use the unified build, collect information from build.info files
1413 my %unified_info = ();
1414
1415 my $buildinfo_debug = defined($ENV{CONFIGURE_DEBUG_BUILDINFO});
1416 if ($builder eq "unified") {
1417 use with_fallback qw(Text::Template);
1418
1419 sub cleandir {
1420 my $base = shift;
1421 my $dir = shift;
1422 my $relativeto = shift || ".";
1423
1424 $dir = catdir($base,$dir) unless isabsolute($dir);
1425
1426 # Make sure the directories we're building in exists
1427 mkpath($dir);
1428
1429 my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
1430 #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1431 return $res;
1432 }
1433
1434 sub cleanfile {
1435 my $base = shift;
1436 my $file = shift;
1437 my $relativeto = shift || ".";
1438
1439 $file = catfile($base,$file) unless isabsolute($file);
1440
1441 my $d = dirname($file);
1442 my $f = basename($file);
1443
1444 # Make sure the directories we're building in exists
1445 mkpath($d);
1446
1447 my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
1448 #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1449 return $res;
1450 }
1451
1452 # Store the name of the template file we will build the build file from
1453 # in %config. This may be useful for the build file itself.
1454 my @build_file_template_names =
1455 ( $builder_platform."-".$target{build_file}.".tmpl",
1456 $target{build_file}.".tmpl" );
1457 my @build_file_templates = ();
1458
1459 # First, look in the user provided directory, if given
1460 if (defined env($local_config_envname)) {
1461 @build_file_templates =
1462 map {
1463 if ($^O eq 'VMS') {
1464 # VMS environment variables are logical names,
1465 # which can be used as is
1466 $local_config_envname . ':' . $_;
1467 } else {
1468 catfile(env($local_config_envname), $_);
1469 }
1470 }
1471 @build_file_template_names;
1472 }
1473 # Then, look in our standard directory
1474 push @build_file_templates,
1475 ( map { cleanfile($srcdir, catfile("Configurations", $_), $blddir) }
1476 @build_file_template_names );
1477
1478 my $build_file_template;
1479 for $_ (@build_file_templates) {
1480 $build_file_template = $_;
1481 last if -f $build_file_template;
1482
1483 $build_file_template = undef;
1484 }
1485 if (!defined $build_file_template) {
1486 die "*** Couldn't find any of:\n", join("\n", @build_file_templates), "\n";
1487 }
1488 $config{build_file_templates}
1489 = [ $build_file_template,
1490 cleanfile($srcdir, catfile("Configurations", "common.tmpl"),
1491 $blddir) ];
1492
1493 my @build_infos = ( [ ".", "build.info" ] );
1494 foreach (@{$config{dirs}}) {
1495 push @build_infos, [ $_, "build.info" ]
1496 if (-f catfile($srcdir, $_, "build.info"));
1497 }
1498 foreach (@{$config{sdirs}}) {
1499 push @build_infos, [ catdir("crypto", $_), "build.info" ]
1500 if (-f catfile($srcdir, "crypto", $_, "build.info"));
1501 }
1502 foreach (@{$config{engdirs}}) {
1503 push @build_infos, [ catdir("engines", $_), "build.info" ]
1504 if (-f catfile($srcdir, "engines", $_, "build.info"));
1505 }
1506 foreach (@{$config{tdirs}}) {
1507 push @build_infos, [ catdir("test", $_), "build.info" ]
1508 if (-f catfile($srcdir, "test", $_, "build.info"));
1509 }
1510
1511 $config{build_infos} = [ ];
1512
1513 my %ordinals = ();
1514 foreach (@build_infos) {
1515 my $sourced = catdir($srcdir, $_->[0]);
1516 my $buildd = catdir($blddir, $_->[0]);
1517
1518 mkpath($buildd);
1519
1520 my $f = $_->[1];
1521 # The basic things we're trying to build
1522 my @programs = ();
1523 my @programs_install = ();
1524 my @libraries = ();
1525 my @libraries_install = ();
1526 my @engines = ();
1527 my @engines_install = ();
1528 my @scripts = ();
1529 my @scripts_install = ();
1530 my @extra = ();
1531 my @overrides = ();
1532 my @intermediates = ();
1533 my @rawlines = ();
1534
1535 my %sources = ();
1536 my %shared_sources = ();
1537 my %includes = ();
1538 my %depends = ();
1539 my %renames = ();
1540 my %sharednames = ();
1541 my %generate = ();
1542
1543 push @{$config{build_infos}}, catfile(abs2rel($sourced, $blddir), $f);
1544 my $template =
1545 Text::Template->new(TYPE => 'FILE',
1546 SOURCE => catfile($sourced, $f),
1547 PREPEND => qq{use lib "$FindBin::Bin/util/perl";});
1548 die "Something went wrong with $sourced/$f: $!\n" unless $template;
1549 my @text =
1550 split /^/m,
1551 $template->fill_in(HASH => { config => \%config,
1552 target => \%target,
1553 disabled => \%disabled,
1554 withargs => \%withargs,
1555 builddir => abs2rel($buildd, $blddir),
1556 sourcedir => abs2rel($sourced, $blddir),
1557 buildtop => abs2rel($blddir, $blddir),
1558 sourcetop => abs2rel($srcdir, $blddir) },
1559 DELIMITERS => [ "{-", "-}" ]);
1560
1561 # The top item of this stack has the following values
1562 # -2 positive already run and we found ELSE (following ELSIF should fail)
1563 # -1 positive already run (skip until ENDIF)
1564 # 0 negatives so far (if we're at a condition, check it)
1565 # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
1566 # 2 positive ELSE (following ELSIF should fail)
1567 my @skip = ();
1568 collect_information(
1569 collect_from_array([ @text ],
1570 qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
1571 $l1 =~ s/\\$//; $l1.$l2 }),
1572 # Info we're looking for
1573 qr/^\s*IF\[((?:\\.|[^\\\]])*)\]\s*$/
1574 => sub {
1575 if (! @skip || $skip[$#skip] > 0) {
1576 push @skip, !! $1;
1577 } else {
1578 push @skip, -1;
1579 }
1580 },
1581 qr/^\s*ELSIF\[((?:\\.|[^\\\]])*)\]\s*$/
1582 => sub { die "ELSIF out of scope" if ! @skip;
1583 die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
1584 $skip[$#skip] = -1 if $skip[$#skip] != 0;
1585 $skip[$#skip] = !! $1
1586 if $skip[$#skip] == 0; },
1587 qr/^\s*ELSE\s*$/
1588 => sub { die "ELSE out of scope" if ! @skip;
1589 $skip[$#skip] = -2 if $skip[$#skip] != 0;
1590 $skip[$#skip] = 2 if $skip[$#skip] == 0; },
1591 qr/^\s*ENDIF\s*$/
1592 => sub { die "ENDIF out of scope" if ! @skip;
1593 pop @skip; },
1594 qr/^\s*PROGRAMS(_NO_INST)?\s*=\s*(.*)\s*$/
1595 => sub {
1596 if (!@skip || $skip[$#skip] > 0) {
1597 my $install = $1;
1598 my @x = tokenize($2);
1599 push @programs, @x;
1600 push @programs_install, @x unless $install;
1601 }
1602 },
1603 qr/^\s*LIBS(_NO_INST)?\s*=\s*(.*)\s*$/
1604 => sub {
1605 if (!@skip || $skip[$#skip] > 0) {
1606 my $install = $1;
1607 my @x = tokenize($2);
1608 push @libraries, @x;
1609 push @libraries_install, @x unless $install;
1610 }
1611 },
1612 qr/^\s*ENGINES(_NO_INST)?\s*=\s*(.*)\s*$/
1613 => sub {
1614 if (!@skip || $skip[$#skip] > 0) {
1615 my $install = $1;
1616 my @x = tokenize($2);
1617 push @engines, @x;
1618 push @engines_install, @x unless $install;
1619 }
1620 },
1621 qr/^\s*SCRIPTS(_NO_INST)?\s*=\s*(.*)\s*$/
1622 => sub {
1623 if (!@skip || $skip[$#skip] > 0) {
1624 my $install = $1;
1625 my @x = tokenize($2);
1626 push @scripts, @x;
1627 push @scripts_install, @x unless $install;
1628 }
1629 },
1630 qr/^\s*EXTRA\s*=\s*(.*)\s*$/
1631 => sub { push @extra, tokenize($1)
1632 if !@skip || $skip[$#skip] > 0 },
1633 qr/^\s*OVERRIDES\s*=\s*(.*)\s*$/
1634 => sub { push @overrides, tokenize($1)
1635 if !@skip || $skip[$#skip] > 0 },
1636
1637 qr/^\s*ORDINALS\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/,
1638 => sub { push @{$ordinals{$1}}, tokenize($2)
1639 if !@skip || $skip[$#skip] > 0 },
1640 qr/^\s*SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1641 => sub { push @{$sources{$1}}, tokenize($2)
1642 if !@skip || $skip[$#skip] > 0 },
1643 qr/^\s*SHARED_SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1644 => sub { push @{$shared_sources{$1}}, tokenize($2)
1645 if !@skip || $skip[$#skip] > 0 },
1646 qr/^\s*INCLUDE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1647 => sub { push @{$includes{$1}}, tokenize($2)
1648 if !@skip || $skip[$#skip] > 0 },
1649 qr/^\s*DEPEND\[((?:\\.|[^\\\]])*)\]\s*=\s*(.*)\s*$/
1650 => sub { push @{$depends{$1}}, tokenize($2)
1651 if !@skip || $skip[$#skip] > 0 },
1652 qr/^\s*GENERATE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1653 => sub { push @{$generate{$1}}, $2
1654 if !@skip || $skip[$#skip] > 0 },
1655 qr/^\s*RENAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1656 => sub { push @{$renames{$1}}, tokenize($2)
1657 if !@skip || $skip[$#skip] > 0 },
1658 qr/^\s*SHARED_NAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1659 => sub { push @{$sharednames{$1}}, tokenize($2)
1660 if !@skip || $skip[$#skip] > 0 },
1661 qr/^\s*BEGINRAW\[((?:\\.|[^\\\]])+)\]\s*$/
1662 => sub {
1663 my $lineiterator = shift;
1664 my $target_kind = $1;
1665 while (defined $lineiterator->()) {
1666 s|\R$||;
1667 if (/^\s*ENDRAW\[((?:\\.|[^\\\]])+)\]\s*$/) {
1668 die "ENDRAW doesn't match BEGINRAW"
1669 if $1 ne $target_kind;
1670 last;
1671 }
1672 next if @skip && $skip[$#skip] <= 0;
1673 push @rawlines, $_
1674 if ($target_kind eq $target{build_file}
1675 || $target_kind eq $target{build_file}."(".$builder_platform.")");
1676 }
1677 },
1678 qr/^\s*(?:#.*)?$/ => sub { },
1679 "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" },
1680 "BEFORE" => sub {
1681 if ($buildinfo_debug) {
1682 print STDERR "DEBUG: Parsing ",join(" ", @_),"\n";
1683 print STDERR "DEBUG: ... before parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1684 }
1685 },
1686 "AFTER" => sub {
1687 if ($buildinfo_debug) {
1688 print STDERR "DEBUG: .... after parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1689 }
1690 },
1691 );
1692 die "runaway IF?" if (@skip);
1693
1694 foreach (keys %renames) {
1695 die "$_ renamed to more than one thing: "
1696 ,join(" ", @{$renames{$_}}),"\n"
1697 if scalar @{$renames{$_}} > 1;
1698 my $dest = cleanfile($buildd, $_, $blddir);
1699 my $to = cleanfile($buildd, $renames{$_}->[0], $blddir);
1700 die "$dest renamed to more than one thing: "
1701 ,$unified_info{rename}->{$dest}, $to
1702 unless !defined($unified_info{rename}->{$dest})
1703 or $unified_info{rename}->{$dest} eq $to;
1704 $unified_info{rename}->{$dest} = $to;
1705 }
1706
1707 foreach (@programs) {
1708 my $program = cleanfile($buildd, $_, $blddir);
1709 if ($unified_info{rename}->{$program}) {
1710 $program = $unified_info{rename}->{$program};
1711 }
1712 $unified_info{programs}->{$program} = 1;
1713 }
1714
1715 foreach (@programs_install) {
1716 my $program = cleanfile($buildd, $_, $blddir);
1717 if ($unified_info{rename}->{$program}) {
1718 $program = $unified_info{rename}->{$program};
1719 }
1720 $unified_info{install}->{programs}->{$program} = 1;
1721 }
1722
1723 foreach (@libraries) {
1724 my $library = cleanfile($buildd, $_, $blddir);
1725 if ($unified_info{rename}->{$library}) {
1726 $library = $unified_info{rename}->{$library};
1727 }
1728 $unified_info{libraries}->{$library} = 1;
1729 }
1730
1731 foreach (@libraries_install) {
1732 my $library = cleanfile($buildd, $_, $blddir);
1733 if ($unified_info{rename}->{$library}) {
1734 $library = $unified_info{rename}->{$library};
1735 }
1736 $unified_info{install}->{libraries}->{$library} = 1;
1737 }
1738
1739 die <<"EOF" if scalar @engines and !$config{dynamic_engines};
1740 ENGINES can only be used if configured with 'dynamic-engine'.
1741 This is usually a fault in a build.info file.
1742 EOF
1743 foreach (@engines) {
1744 my $library = cleanfile($buildd, $_, $blddir);
1745 if ($unified_info{rename}->{$library}) {
1746 $library = $unified_info{rename}->{$library};
1747 }
1748 $unified_info{engines}->{$library} = 1;
1749 }
1750
1751 foreach (@engines_install) {
1752 my $library = cleanfile($buildd, $_, $blddir);
1753 if ($unified_info{rename}->{$library}) {
1754 $library = $unified_info{rename}->{$library};
1755 }
1756 $unified_info{install}->{engines}->{$library} = 1;
1757 }
1758
1759 foreach (@scripts) {
1760 my $script = cleanfile($buildd, $_, $blddir);
1761 if ($unified_info{rename}->{$script}) {
1762 $script = $unified_info{rename}->{$script};
1763 }
1764 $unified_info{scripts}->{$script} = 1;
1765 }
1766
1767 foreach (@scripts_install) {
1768 my $script = cleanfile($buildd, $_, $blddir);
1769 if ($unified_info{rename}->{$script}) {
1770 $script = $unified_info{rename}->{$script};
1771 }
1772 $unified_info{install}->{scripts}->{$script} = 1;
1773 }
1774
1775 foreach (@extra) {
1776 my $extra = cleanfile($buildd, $_, $blddir);
1777 $unified_info{extra}->{$extra} = 1;
1778 }
1779
1780 foreach (@overrides) {
1781 my $override = cleanfile($buildd, $_, $blddir);
1782 $unified_info{overrides}->{$override} = 1;
1783 }
1784
1785 push @{$unified_info{rawlines}}, @rawlines;
1786
1787 unless ($disabled{shared}) {
1788 # Check sharednames.
1789 foreach (keys %sharednames) {
1790 my $dest = cleanfile($buildd, $_, $blddir);
1791 if ($unified_info{rename}->{$dest}) {
1792 $dest = $unified_info{rename}->{$dest};
1793 }
1794 die "shared_name for $dest with multiple values: "
1795 ,join(" ", @{$sharednames{$_}}),"\n"
1796 if scalar @{$sharednames{$_}} > 1;
1797 my $to = cleanfile($buildd, $sharednames{$_}->[0], $blddir);
1798 die "shared_name found for a library $dest that isn't defined\n"
1799 unless $unified_info{libraries}->{$dest};
1800 die "shared_name for $dest with multiple values: "
1801 ,$unified_info{sharednames}->{$dest}, ", ", $to
1802 unless !defined($unified_info{sharednames}->{$dest})
1803 or $unified_info{sharednames}->{$dest} eq $to;
1804 $unified_info{sharednames}->{$dest} = $to;
1805 }
1806
1807 # Additionally, we set up sharednames for libraries that don't
1808 # have any, as themselves. Only for libraries that aren't
1809 # explicitly static.
1810 foreach (grep !/\.a$/, keys %{$unified_info{libraries}}) {
1811 if (!defined $unified_info{sharednames}->{$_}) {
1812 $unified_info{sharednames}->{$_} = $_
1813 }
1814 }
1815
1816 # Check that we haven't defined any library as both shared and
1817 # explicitly static. That is forbidden.
1818 my @doubles = ();
1819 foreach (grep /\.a$/, keys %{$unified_info{libraries}}) {
1820 (my $l = $_) =~ s/\.a$//;
1821 push @doubles, $l if defined $unified_info{sharednames}->{$l};
1822 }
1823 die "these libraries are both explicitly static and shared:\n ",
1824 join(" ", @doubles), "\n"
1825 if @doubles;
1826 }
1827
1828 foreach (keys %sources) {
1829 my $dest = $_;
1830 my $ddest = cleanfile($buildd, $_, $blddir);
1831 if ($unified_info{rename}->{$ddest}) {
1832 $ddest = $unified_info{rename}->{$ddest};
1833 }
1834 foreach (@{$sources{$dest}}) {
1835 my $s = cleanfile($sourced, $_, $blddir);
1836
1837 # If it isn't in the source tree, we assume it's generated
1838 # in the build tree
1839 if (! -f $s) {
1840 $s = cleanfile($buildd, $_, $blddir);
1841 }
1842 # We recognise C++, C and asm files
1843 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
1844 my $o = $_;
1845 $o =~ s/\.[csS]$/.o/; # C and assembler
1846 $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
1847 $o = cleanfile($buildd, $o, $blddir);
1848 $unified_info{sources}->{$ddest}->{$o} = 1;
1849 $unified_info{sources}->{$o}->{$s} = 1;
1850 } else {
1851 $unified_info{sources}->{$ddest}->{$s} = 1;
1852 }
1853 }
1854 }
1855
1856 foreach (keys %shared_sources) {
1857 my $dest = $_;
1858 my $ddest = cleanfile($buildd, $_, $blddir);
1859 if ($unified_info{rename}->{$ddest}) {
1860 $ddest = $unified_info{rename}->{$ddest};
1861 }
1862 foreach (@{$shared_sources{$dest}}) {
1863 my $s = cleanfile($sourced, $_, $blddir);
1864
1865 # If it isn't in the source tree, we assume it's generated
1866 # in the build tree
1867 if (! -f $s) {
1868 $s = cleanfile($buildd, $_, $blddir);
1869 }
1870
1871 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
1872 # We recognise C++, C and asm files
1873 my $o = $_;
1874 $o =~ s/\.[csS]$/.o/; # C and assembler
1875 $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
1876 $o = cleanfile($buildd, $o, $blddir);
1877 $unified_info{shared_sources}->{$ddest}->{$o} = 1;
1878 $unified_info{sources}->{$o}->{$s} = 1;
1879 } elsif ($s =~ /\.rc$/) {
1880 # We also recognise resource files
1881 my $o = $_;
1882 $o =~ s/\.rc$/.res/; # Resource configuration
1883 my $o = cleanfile($buildd, $o, $blddir);
1884 $unified_info{shared_sources}->{$ddest}->{$o} = 1;
1885 $unified_info{sources}->{$o}->{$s} = 1;
1886 } elsif ($s =~ /\.(def|map|opt)$/) {
1887 # We also recognise .def / .map / .opt files
1888 # We know they are generated files
1889 my $def = cleanfile($buildd, $s, $blddir);
1890 $unified_info{shared_sources}->{$ddest}->{$def} = 1;
1891 } else {
1892 die "unrecognised source file type for shared library: $s\n";
1893 }
1894 }
1895 }
1896
1897 foreach (keys %generate) {
1898 my $dest = $_;
1899 my $ddest = cleanfile($buildd, $_, $blddir);
1900 if ($unified_info{rename}->{$ddest}) {
1901 $ddest = $unified_info{rename}->{$ddest};
1902 }
1903 die "more than one generator for $dest: "
1904 ,join(" ", @{$generate{$_}}),"\n"
1905 if scalar @{$generate{$_}} > 1;
1906 my @generator = split /\s+/, $generate{$dest}->[0];
1907 $generator[0] = cleanfile($sourced, $generator[0], $blddir),
1908 $unified_info{generate}->{$ddest} = [ @generator ];
1909 }
1910
1911 foreach (keys %depends) {
1912 my $dest = $_;
1913 my $ddest = $dest eq "" ? "" : cleanfile($sourced, $_, $blddir);
1914
1915 # If the destination doesn't exist in source, it can only be
1916 # a generated file in the build tree.
1917 if ($ddest ne "" && ! -f $ddest) {
1918 $ddest = cleanfile($buildd, $_, $blddir);
1919 if ($unified_info{rename}->{$ddest}) {
1920 $ddest = $unified_info{rename}->{$ddest};
1921 }
1922 }
1923 foreach (@{$depends{$dest}}) {
1924 my $d = cleanfile($sourced, $_, $blddir);
1925
1926 # If we know it's generated, or assume it is because we can't
1927 # find it in the source tree, we set file we depend on to be
1928 # in the build tree rather than the source tree, and assume
1929 # and that there are lines to build it in a BEGINRAW..ENDRAW
1930 # section or in the Makefile template.
1931 if (! -f $d
1932 || (grep { $d eq $_ }
1933 map { cleanfile($srcdir, $_, $blddir) }
1934 grep { /\.h$/ } keys %{$unified_info{generate}})) {
1935 $d = cleanfile($buildd, $_, $blddir);
1936 }
1937 # Take note if the file to depend on is being renamed
1938 # Take extra care with files ending with .a, they should
1939 # be treated without that extension, and the extension
1940 # should be added back after treatment.
1941 $d =~ /(\.a)?$/;
1942 my $e = $1 // "";
1943 $d = $`;
1944 if ($unified_info{rename}->{$d}) {
1945 $d = $unified_info{rename}->{$d};
1946 }
1947 $d .= $e;
1948 $unified_info{depends}->{$ddest}->{$d} = 1;
1949 # If we depend on a header file or a perl module, let's make
1950 # sure it can get included
1951 if ($dest ne "" && $d =~ /\.(h|pm)$/) {
1952 my $i = dirname($d);
1953 push @{$unified_info{includes}->{$ddest}->{source}}, $i
1954 unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}->{source}};
1955 }
1956 }
1957 }
1958
1959 foreach (keys %includes) {
1960 my $dest = $_;
1961 my $ddest = cleanfile($sourced, $_, $blddir);
1962
1963 # If the destination doesn't exist in source, it can only be
1964 # a generated file in the build tree.
1965 if (! -f $ddest) {
1966 $ddest = cleanfile($buildd, $_, $blddir);
1967 if ($unified_info{rename}->{$ddest}) {
1968 $ddest = $unified_info{rename}->{$ddest};
1969 }
1970 }
1971 foreach (@{$includes{$dest}}) {
1972 my $is = cleandir($sourced, $_, $blddir);
1973 my $ib = cleandir($buildd, $_, $blddir);
1974 push @{$unified_info{includes}->{$ddest}->{source}}, $is
1975 unless grep { $_ eq $is } @{$unified_info{includes}->{$ddest}->{source}};
1976 push @{$unified_info{includes}->{$ddest}->{build}}, $ib
1977 unless grep { $_ eq $ib } @{$unified_info{includes}->{$ddest}->{build}};
1978 }
1979 }
1980 }
1981
1982 my $ordinals_text = join(', ', sort keys %ordinals);
1983 warn <<"EOF" if $ordinals_text;
1984
1985 WARNING: ORDINALS were specified for $ordinals_text
1986 They are ignored and should be replaced with a combination of GENERATE,
1987 DEPEND and SHARED_SOURCE.
1988 EOF
1989
1990 ### Make unified_info a bit more efficient
1991 # One level structures
1992 foreach (("programs", "libraries", "engines", "scripts", "extra", "overrides")) {
1993 $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
1994 }
1995 # Two level structures
1996 foreach my $l1 (("install", "sources", "shared_sources", "ldadd", "depends")) {
1997 foreach my $l2 (sort keys %{$unified_info{$l1}}) {
1998 $unified_info{$l1}->{$l2} =
1999 [ sort keys %{$unified_info{$l1}->{$l2}} ];
2000 }
2001 }
2002 # Includes
2003 foreach my $dest (sort keys %{$unified_info{includes}}) {
2004 if (defined($unified_info{includes}->{$dest}->{build})) {
2005 my @source_includes =
2006 ( @{$unified_info{includes}->{$dest}->{source}} );
2007 $unified_info{includes}->{$dest} =
2008 [ @{$unified_info{includes}->{$dest}->{build}} ];
2009 foreach my $inc (@source_includes) {
2010 push @{$unified_info{includes}->{$dest}}, $inc
2011 unless grep { $_ eq $inc } @{$unified_info{includes}->{$dest}};
2012 }
2013 } else {
2014 $unified_info{includes}->{$dest} =
2015 [ @{$unified_info{includes}->{$dest}->{source}} ];
2016 }
2017 }
2018 }
2019
2020 # For the schemes that need it, we provide the old *_obj configs
2021 # from the *_asm_obj ones
2022 foreach (grep /_(asm|aux)_src$/, keys %target) {
2023 my $src = $_;
2024 (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
2025 $target{$obj} = $target{$src};
2026 $target{$obj} =~ s/\.[csS]\b/.o/g; # C and assembler
2027 $target{$obj} =~ s/\.(cc|cpp)\b/_cc.o/g; # C++
2028 }
2029
2030 # Write down our configuration where it fits #########################
2031
2032 open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
2033 print OUT <<"EOF";
2034 package configdata;
2035
2036 use strict;
2037 use warnings;
2038
2039 use Exporter;
2040 #use vars qw(\@ISA \@EXPORT);
2041 our \@ISA = qw(Exporter);
2042 our \@EXPORT = qw(\%config \%target \%disabled \%withargs \%unified_info \@disablables);
2043
2044 EOF
2045 print OUT "our %config = (\n";
2046 foreach (sort keys %config) {
2047 if (ref($config{$_}) eq "ARRAY") {
2048 print OUT " ", $_, " => [ ", join(", ",
2049 map { quotify("perl", $_) }
2050 @{$config{$_}}), " ],\n";
2051 } elsif (ref($config{$_}) eq "HASH") {
2052 print OUT " ", $_, " => {";
2053 if (scalar keys %{$config{$_}} > 0) {
2054 print OUT "\n";
2055 foreach my $key (sort keys %{$config{$_}}) {
2056 print OUT " ",
2057 join(" => ",
2058 quotify("perl", $key),
2059 defined $config{$_}->{$key}
2060 ? quotify("perl", $config{$_}->{$key})
2061 : "undef");
2062 print OUT ",\n";
2063 }
2064 print OUT " ";
2065 }
2066 print OUT "},\n";
2067 } else {
2068 print OUT " ", $_, " => ", quotify("perl", $config{$_}), ",\n"
2069 }
2070 }
2071 print OUT <<"EOF";
2072 );
2073
2074 EOF
2075 print OUT "our %target = (\n";
2076 foreach (sort keys %target) {
2077 if (ref($target{$_}) eq "ARRAY") {
2078 print OUT " ", $_, " => [ ", join(", ",
2079 map { quotify("perl", $_) }
2080 @{$target{$_}}), " ],\n";
2081 } else {
2082 print OUT " ", $_, " => ", quotify("perl", $target{$_}), ",\n"
2083 }
2084 }
2085 print OUT <<"EOF";
2086 );
2087
2088 EOF
2089 print OUT "our \%available_protocols = (\n";
2090 print OUT " tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n";
2091 print OUT " dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n";
2092 print OUT <<"EOF";
2093 );
2094
2095 EOF
2096 print OUT "our \@disablables = (\n";
2097 foreach (@disablables) {
2098 print OUT " ", quotify("perl", $_), ",\n";
2099 }
2100 print OUT <<"EOF";
2101 );
2102
2103 EOF
2104 print OUT "our \%disabled = (\n";
2105 foreach (sort keys %disabled) {
2106 print OUT " ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n";
2107 }
2108 print OUT <<"EOF";
2109 );
2110
2111 EOF
2112 print OUT "our %withargs = (\n";
2113 foreach (sort keys %withargs) {
2114 if (ref($withargs{$_}) eq "ARRAY") {
2115 print OUT " ", $_, " => [ ", join(", ",
2116 map { quotify("perl", $_) }
2117 @{$withargs{$_}}), " ],\n";
2118 } else {
2119 print OUT " ", $_, " => ", quotify("perl", $withargs{$_}), ",\n"
2120 }
2121 }
2122 print OUT <<"EOF";
2123 );
2124
2125 EOF
2126 if ($builder eq "unified") {
2127 my $recurse;
2128 $recurse = sub {
2129 my $indent = shift;
2130 foreach (@_) {
2131 if (ref $_ eq "ARRAY") {
2132 print OUT " "x$indent, "[\n";
2133 foreach (@$_) {
2134 $recurse->($indent + 4, $_);
2135 }
2136 print OUT " "x$indent, "],\n";
2137 } elsif (ref $_ eq "HASH") {
2138 my %h = %$_;
2139 print OUT " "x$indent, "{\n";
2140 foreach (sort keys %h) {
2141 if (ref $h{$_} eq "") {
2142 print OUT " "x($indent + 4), quotify("perl", $_), " => ", quotify("perl", $h{$_}), ",\n";
2143 } else {
2144 print OUT " "x($indent + 4), quotify("perl", $_), " =>\n";
2145 $recurse->($indent + 8, $h{$_});
2146 }
2147 }
2148 print OUT " "x$indent, "},\n";
2149 } else {
2150 print OUT " "x$indent, quotify("perl", $_), ",\n";
2151 }
2152 }
2153 };
2154 print OUT "our %unified_info = (\n";
2155 foreach (sort keys %unified_info) {
2156 if (ref $unified_info{$_} eq "") {
2157 print OUT " "x4, quotify("perl", $_), " => ", quotify("perl", $unified_info{$_}), ",\n";
2158 } else {
2159 print OUT " "x4, quotify("perl", $_), " =>\n";
2160 $recurse->(8, $unified_info{$_});
2161 }
2162 }
2163 print OUT <<"EOF";
2164 );
2165
2166 EOF
2167 }
2168 print OUT "1;\n";
2169 close(OUT);
2170
2171 print "\n";
2172 print "PROCESSOR =$config{processor}\n" if $config{processor};
2173 print "PERL =$config{perl}\n";
2174 print "PERLVERSION =$Config{version} for $Config{archname}\n";
2175 print "HASHBANGPERL =$config{hashbangperl}\n";
2176 print "CC =$config{cross_compile_prefix}$target{cc}\n";
2177 print "CFLAG =$target{cflags} $config{cflags}\n";
2178 print "CXX =$config{cross_compile_prefix}$target{cxx}\n"
2179 if defined $target{cxx};
2180 print "CXXFLAG =$target{cxxflags} $config{cxxflags}\n"
2181 if defined $target{cxx};
2182 print "DEFINES =",join(" ", @{$target{defines}}, @{$config{defines}}),"\n";
2183 #print "RANLIB =", $target{ranlib} eq '$(CROSS_COMPILE)ranlib' ?
2184 # "$config{cross_compile_prefix}ranlib" :
2185 # "$target{ranlib}", "\n";
2186 print "LDFLAGS =$config{lflags} $target{lflags}\n";
2187 print "EX_LIBS =$target{ex_libs} $config{ex_libs}\n";
2188
2189 my %builders = (
2190 unified => sub {
2191 run_dofile(catfile($blddir, $target{build_file}),
2192 @{$config{build_file_templates}});
2193 },
2194 );
2195
2196 $builders{$builder}->($builder_platform, @builder_opts);
2197
2198 print <<"EOF" if ($disabled{threads} eq "unavailable");
2199
2200 The library could not be configured for supporting multi-threaded
2201 applications as the compiler options required on this system are not known.
2202 See file INSTALL for details if you need multi-threading.
2203 EOF
2204
2205 print <<"EOF" if ($no_shared_warn);
2206
2207 The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
2208 platform, so we will pretend you gave the option 'no-pic', which also disables
2209 'shared' and 'dynamic-engine'. If you know how to implement shared libraries
2210 or position independent code, please let us know (but please first make sure
2211 you have tried with a current version of OpenSSL).
2212 EOF
2213
2214 print <<"EOF" if (-f catfile($srcdir, "configdata.pm") && $srcdir ne $blddir);
2215
2216 WARNING: there are indications that another build was made in the source
2217 directory. This build may have picked up artifacts from that build, the
2218 safest course of action is to clean the source directory and redo this
2219 configuration.
2220 EOF
2221
2222 exit(0);
2223
2224 ######################################################################
2225 #
2226 # Helpers and utility functions
2227 #
2228
2229 # Configuration file reading #########################################
2230
2231 # Note: All of the helper functions are for lazy evaluation. They all
2232 # return a CODE ref, which will return the intended value when evaluated.
2233 # Thus, whenever there's mention of a returned value, it's about that
2234 # intended value.
2235
2236 # Helper function to implement conditional inheritance depending on the
2237 # value of $disabled{asm}. Used in inherit_from values as follows:
2238 #
2239 # inherit_from => [ "template", asm("asm_tmpl") ]
2240 #
2241 sub asm {
2242 my @x = @_;
2243 sub {
2244 $disabled{asm} ? () : @x;
2245 }
2246 }
2247
2248 # Helper function to implement conditional value variants, with a default
2249 # plus additional values based on the value of $config{build_type}.
2250 # Arguments are given in hash table form:
2251 #
2252 # picker(default => "Basic string: ",
2253 # debug => "debug",
2254 # release => "release")
2255 #
2256 # When configuring with --debug, the resulting string will be
2257 # "Basic string: debug", and when not, it will be "Basic string: release"
2258 #
2259 # This can be used to create variants of sets of flags according to the
2260 # build type:
2261 #
2262 # cflags => picker(default => "-Wall",
2263 # debug => "-g -O0",
2264 # release => "-O3")
2265 #
2266 sub picker {
2267 my %opts = @_;
2268 return sub { add($opts{default} || (),
2269 $opts{$config{build_type}} || ())->(); }
2270 }
2271
2272 # Helper function to combine several values of different types into one.
2273 # This is useful if you want to combine a string with the result of a
2274 # lazy function, such as:
2275 #
2276 # cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
2277 #
2278 sub combine {
2279 my @stuff = @_;
2280 return sub { add(@stuff)->(); }
2281 }
2282
2283 # Helper function to implement conditional values depending on the value
2284 # of $disabled{threads}. Can be used as follows:
2285 #
2286 # cflags => combine("-Wall", threads("-pthread"))
2287 #
2288 sub threads {
2289 my @flags = @_;
2290 return sub { add($disabled{threads} ? () : @flags)->(); }
2291 }
2292
2293
2294
2295 our $add_called = 0;
2296 # Helper function to implement adding values to already existing configuration
2297 # values. It handles elements that are ARRAYs, CODEs and scalars
2298 sub _add {
2299 my $separator = shift;
2300
2301 # If there's any ARRAY in the collection of values OR the separator
2302 # is undef, we will return an ARRAY of combined values, otherwise a
2303 # string of joined values with $separator as the separator.
2304 my $found_array = !defined($separator);
2305
2306 my @values =
2307 map {
2308 my $res = $_;
2309 while (ref($res) eq "CODE") {
2310 $res = $res->();
2311 }
2312 if (defined($res)) {
2313 if (ref($res) eq "ARRAY") {
2314 $found_array = 1;
2315 @$res;
2316 } else {
2317 $res;
2318 }
2319 } else {
2320 ();
2321 }
2322 } (@_);
2323
2324 $add_called = 1;
2325
2326 if ($found_array) {
2327 [ @values ];
2328 } else {
2329 join($separator, grep { defined($_) && $_ ne "" } @values);
2330 }
2331 }
2332 sub add_before {
2333 my $separator = " ";
2334 if (ref($_[$#_]) eq "HASH") {
2335 my $opts = pop;
2336 $separator = $opts->{separator};
2337 }
2338 my @x = @_;
2339 sub { _add($separator, @x, @_) };
2340 }
2341 sub add {
2342 my $separator = " ";
2343 if (ref($_[$#_]) eq "HASH") {
2344 my $opts = pop;
2345 $separator = $opts->{separator};
2346 }
2347 my @x = @_;
2348 sub { _add($separator, @_, @x) };
2349 }
2350
2351 sub read_eval_file {
2352 my $fname = shift;
2353 my $content;
2354 my @result;
2355
2356 open F, "< $fname" or die "Can't open '$fname': $!\n";
2357 {
2358 undef local $/;
2359 $content = <F>;
2360 }
2361 close F;
2362 {
2363 local $@;
2364
2365 @result = ( eval $content );
2366 warn $@ if $@;
2367 }
2368 return wantarray ? @result : $result[0];
2369 }
2370
2371 # configuration reader, evaluates the input file as a perl script and expects
2372 # it to fill %targets with target configurations. Those are then added to
2373 # %table.
2374 sub read_config {
2375 my $fname = shift;
2376 my %targets;
2377
2378 {
2379 # Protect certain tables from tampering
2380 local %table = ();
2381
2382 %targets = read_eval_file($fname);
2383 }
2384 my %preexisting = ();
2385 foreach (sort keys %targets) {
2386 $preexisting{$_} = 1 if $table{$_};
2387 }
2388 die <<"EOF",
2389 The following config targets from $fname
2390 shadow pre-existing config targets with the same name:
2391 EOF
2392 map { " $_\n" } sort keys %preexisting
2393 if %preexisting;
2394
2395
2396 # For each target, check that it's configured with a hash table.
2397 foreach (keys %targets) {
2398 if (ref($targets{$_}) ne "HASH") {
2399 if (ref($targets{$_}) eq "") {
2400 warn "Deprecated target configuration for $_, ignoring...\n";
2401 } else {
2402 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
2403 }
2404 delete $targets{$_};
2405 } else {
2406 $targets{$_}->{_conf_fname_int} = add([ $fname ]);
2407 }
2408 }
2409
2410 %table = (%table, %targets);
2411
2412 }
2413
2414 # configuration resolver. Will only resolve all the lazy evaluation
2415 # codeblocks for the chosen target and all those it inherits from,
2416 # recursively
2417 sub resolve_config {
2418 my $target = shift;
2419 my @breadcrumbs = @_;
2420
2421 # my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
2422
2423 if (grep { $_ eq $target } @breadcrumbs) {
2424 die "inherit_from loop! target backtrace:\n "
2425 ,$target,"\n ",join("\n ", @breadcrumbs),"\n";
2426 }
2427
2428 if (!defined($table{$target})) {
2429 warn "Warning! target $target doesn't exist!\n";
2430 return ();
2431 }
2432 # Recurse through all inheritances. They will be resolved on the
2433 # fly, so when this operation is done, they will all just be a
2434 # bunch of attributes with string values.
2435 # What we get here, though, are keys with references to lists of
2436 # the combined values of them all. We will deal with lists after
2437 # this stage is done.
2438 my %combined_inheritance = ();
2439 if ($table{$target}->{inherit_from}) {
2440 my @inherit_from =
2441 map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
2442 foreach (@inherit_from) {
2443 my %inherited_config = resolve_config($_, $target, @breadcrumbs);
2444
2445 # 'template' is a marker that's considered private to
2446 # the config that had it.
2447 delete $inherited_config{template};
2448
2449 foreach (keys %inherited_config) {
2450 if (!$combined_inheritance{$_}) {
2451 $combined_inheritance{$_} = [];
2452 }
2453 push @{$combined_inheritance{$_}}, $inherited_config{$_};
2454 }
2455 }
2456 }
2457
2458 # We won't need inherit_from in this target any more, since we've
2459 # resolved all the inheritances that lead to this
2460 delete $table{$target}->{inherit_from};
2461
2462 # Now is the time to deal with those lists. Here's the place to
2463 # decide what shall be done with those lists, all based on the
2464 # values of the target we're currently dealing with.
2465 # - If a value is a coderef, it will be executed with the list of
2466 # inherited values as arguments.
2467 # - If the corresponding key doesn't have a value at all or is the
2468 # empty string, the inherited value list will be run through the
2469 # default combiner (below), and the result becomes this target's
2470 # value.
2471 # - Otherwise, this target's value is assumed to be a string that
2472 # will simply override the inherited list of values.
2473 my $default_combiner = add();
2474
2475 my %all_keys =
2476 map { $_ => 1 } (keys %combined_inheritance,
2477 keys %{$table{$target}});
2478
2479 sub process_values {
2480 my $object = shift;
2481 my $inherited = shift; # Always a [ list ]
2482 my $target = shift;
2483 my $entry = shift;
2484
2485 $add_called = 0;
2486
2487 while(ref($object) eq "CODE") {
2488 $object = $object->(@$inherited);
2489 }
2490 if (!defined($object)) {
2491 return ();
2492 }
2493 elsif (ref($object) eq "ARRAY") {
2494 local $add_called; # To make sure recursive calls don't affect it
2495 return [ map { process_values($_, $inherited, $target, $entry) }
2496 @$object ];
2497 } elsif (ref($object) eq "") {
2498 return $object;
2499 } else {
2500 die "cannot handle reference type ",ref($object)
2501 ," found in target ",$target," -> ",$entry,"\n";
2502 }
2503 }
2504
2505 foreach (sort keys %all_keys) {
2506 my $previous = $combined_inheritance{$_};
2507
2508 # Current target doesn't have a value for the current key?
2509 # Assign it the default combiner, the rest of this loop body
2510 # will handle it just like any other coderef.
2511 if (!exists $table{$target}->{$_}) {
2512 $table{$target}->{$_} = $default_combiner;
2513 }
2514
2515 $table{$target}->{$_} = process_values($table{$target}->{$_},
2516 $combined_inheritance{$_},
2517 $target, $_);
2518 unless(defined($table{$target}->{$_})) {
2519 delete $table{$target}->{$_};
2520 }
2521 # if ($extra_checks &&
2522 # $previous && !($add_called || $previous ~~ $table{$target}->{$_})) {
2523 # warn "$_ got replaced in $target\n";
2524 # }
2525 }
2526
2527 # Finally done, return the result.
2528 return %{$table{$target}};
2529 }
2530
2531 sub usage
2532 {
2533 print STDERR $usage;
2534 print STDERR "\npick os/compiler from:\n";
2535 my $j=0;
2536 my $i;
2537 my $k=0;
2538 foreach $i (sort keys %table)
2539 {
2540 next if $table{$i}->{template};
2541 next if $i =~ /^debug/;
2542 $k += length($i) + 1;
2543 if ($k > 78)
2544 {
2545 print STDERR "\n";
2546 $k=length($i);
2547 }
2548 print STDERR $i . " ";
2549 }
2550 foreach $i (sort keys %table)
2551 {
2552 next if $table{$i}->{template};
2553 next if $i !~ /^debug/;
2554 $k += length($i) + 1;
2555 if ($k > 78)
2556 {
2557 print STDERR "\n";
2558 $k=length($i);
2559 }
2560 print STDERR $i . " ";
2561 }
2562 print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
2563 exit(1);
2564 }
2565
2566 sub run_dofile
2567 {
2568 my $out = shift;
2569 my @templates = @_;
2570
2571 unlink $out || warn "Can't remove $out, $!"
2572 if -f $out;
2573 foreach (@templates) {
2574 die "Can't open $_, $!" unless -f $_;
2575 }
2576 my $perlcmd = (quotify("maybeshell", $config{perl}))[0];
2577 my $cmd = "$perlcmd \"-I.\" \"-Mconfigdata\" \"$dofile\" -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\"";
2578 #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
2579 system($cmd);
2580 exit 1 if $? != 0;
2581 rename("$out.new", $out) || die "Can't rename $out.new, $!";
2582 }
2583
2584 sub compiler_predefined {
2585 state %predefined;
2586 my $default_compiler = shift;
2587
2588 return () if $^O eq 'VMS';
2589
2590 die 'compiler_predefines called without a default compiler'
2591 unless $default_compiler;
2592
2593 if (! $predefined{$default_compiler}) {
2594 my $cc = "$config{cross_compile_prefix}$default_compiler";
2595
2596 $predefined{$default_compiler} = {};
2597
2598 # collect compiler pre-defines from gcc or gcc-alike...
2599 open(PIPE, "$cc -dM -E -x c /dev/null 2>&1 |");
2600 while (my $l = <PIPE>) {
2601 $l =~ m/^#define\s+(\w+(?:\(\w+\))?)(?:\s+(.+))?/ or last;
2602 $predefined{$default_compiler}->{$1} = $2 // '';
2603 }
2604 close(PIPE);
2605 }
2606
2607 return %{$predefined{$default_compiler}};
2608 }
2609
2610 sub which
2611 {
2612 my ($name)=@_;
2613
2614 if (eval { require IPC::Cmd; 1; }) {
2615 IPC::Cmd->import();
2616 return scalar IPC::Cmd::can_run($name);
2617 } else {
2618 # if there is $directories component in splitpath,
2619 # then it's not something to test with $PATH...
2620 return $name if (File::Spec->splitpath($name))[1];
2621
2622 foreach (File::Spec->path()) {
2623 my $fullpath = catfile($_, "$name$target{exe_extension}");
2624 if (-f $fullpath and -x $fullpath) {
2625 return $fullpath;
2626 }
2627 }
2628 }
2629 }
2630
2631 sub env
2632 {
2633 my $name = shift;
2634
2635 # Note that if $ENV{$name} doesn't exist or is undefined,
2636 # $config{perlenv}->{$name} will be created with the value
2637 # undef. This is intentional.
2638
2639 $config{perlenv}->{$name} = $ENV{$name}
2640 if ! exists $config{perlenv}->{$name};
2641 return $config{perlenv}->{$name};
2642 }
2643
2644 # Configuration printer ##############################################
2645
2646 sub print_table_entry
2647 {
2648 my $target = shift;
2649 my %target = resolve_config($target);
2650 my $type = shift;
2651
2652 # Don't print the templates
2653 return if $target{template};
2654
2655 my @sequence = (
2656 "sys_id",
2657 "cc",
2658 "cflags",
2659 "defines",
2660 "unistd",
2661 "ld",
2662 "lflags",
2663 "loutflag",
2664 "plib_lflags",
2665 "ex_libs",
2666 "bn_ops",
2667 "apps_aux_src",
2668 "cpuid_asm_src",
2669 "uplink_aux_src",
2670 "bn_asm_src",
2671 "ec_asm_src",
2672 "des_asm_src",
2673 "aes_asm_src",
2674 "bf_asm_src",
2675 "md5_asm_src",
2676 "cast_asm_src",
2677 "sha1_asm_src",
2678 "rc4_asm_src",
2679 "rmd160_asm_src",
2680 "rc5_asm_src",
2681 "wp_asm_src",
2682 "cmll_asm_src",
2683 "modes_asm_src",
2684 "padlock_asm_src",
2685 "chacha_asm_src",
2686 "poly1035_asm_src",
2687 "thread_scheme",
2688 "perlasm_scheme",
2689 "dso_scheme",
2690 "shared_target",
2691 "shared_cflag",
2692 "shared_defines",
2693 "shared_ldflag",
2694 "shared_rcflag",
2695 "shared_extension",
2696 "dso_extension",
2697 "obj_extension",
2698 "exe_extension",
2699 "ranlib",
2700 "ar",
2701 "arflags",
2702 "aroutflag",
2703 "rc",
2704 "rcflags",
2705 "rcoutflag",
2706 "mt",
2707 "mtflags",
2708 "mtinflag",
2709 "mtoutflag",
2710 "multilib",
2711 "build_scheme",
2712 );
2713
2714 if ($type eq "TABLE") {
2715 print "\n";
2716 print "*** $target\n";
2717 foreach (@sequence) {
2718 if (ref($target{$_}) eq "ARRAY") {
2719 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
2720 } else {
2721 printf "\$%-12s = %s\n", $_, $target{$_};
2722 }
2723 }
2724 } elsif ($type eq "HASH") {
2725 my $largest =
2726 length((sort { length($a) <=> length($b) } @sequence)[-1]);
2727 print " '$target' => {\n";
2728 foreach (@sequence) {
2729 if ($target{$_}) {
2730 if (ref($target{$_}) eq "ARRAY") {
2731 print " '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
2732 } else {
2733 print " '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
2734 }
2735 }
2736 }
2737 print " },\n";
2738 }
2739 }
2740
2741 # Utility routines ###################################################
2742
2743 # On VMS, if the given file is a logical name, File::Spec::Functions
2744 # will consider it an absolute path. There are cases when we want a
2745 # purely syntactic check without checking the environment.
2746 sub isabsolute {
2747 my $file = shift;
2748
2749 # On non-platforms, we just use file_name_is_absolute().
2750 return file_name_is_absolute($file) unless $^O eq "VMS";
2751
2752 # If the file spec includes a device or a directory spec,
2753 # file_name_is_absolute() is perfectly safe.
2754 return file_name_is_absolute($file) if $file =~ m|[:\[]|;
2755
2756 # Here, we know the given file spec isn't absolute
2757 return 0;
2758 }
2759
2760 # Makes a directory absolute and cleans out /../ in paths like foo/../bar
2761 # On some platforms, this uses rel2abs(), while on others, realpath() is used.
2762 # realpath() requires that at least all path components except the last is an
2763 # existing directory. On VMS, the last component of the directory spec must
2764 # exist.
2765 sub absolutedir {
2766 my $dir = shift;
2767
2768 # realpath() is quite buggy on VMS. It uses LIB$FID_TO_NAME, which
2769 # will return the volume name for the device, no matter what. Also,
2770 # it will return an incorrect directory spec if the argument is a
2771 # directory that doesn't exist.
2772 if ($^O eq "VMS") {
2773 return rel2abs($dir);
2774 }
2775
2776 # We use realpath() on Unix, since no other will properly clean out
2777 # a directory spec.
2778 use Cwd qw/realpath/;
2779
2780 return realpath($dir);
2781 }
2782
2783 sub quotify {
2784 my %processors = (
2785 perl => sub { my $x = shift;
2786 $x =~ s/([\\\$\@"])/\\$1/g;
2787 return '"'.$x.'"'; },
2788 maybeshell => sub { my $x = shift;
2789 (my $y = $x) =~ s/([\\\"])/\\$1/g;
2790 if ($x ne $y || $x =~ m|\s|) {
2791 return '"'.$y.'"';
2792 } else {
2793 return $x;
2794 }
2795 },
2796 );
2797 my $for = shift;
2798 my $processor =
2799 defined($processors{$for}) ? $processors{$for} : sub { shift; };
2800
2801 return map { $processor->($_); } @_;
2802 }
2803
2804 # collect_from_file($filename, $line_concat_cond_re, $line_concat)
2805 # $filename is a file name to read from
2806 # $line_concat_cond_re is a regexp detecting a line continuation ending
2807 # $line_concat is a CODEref that takes care of concatenating two lines
2808 sub collect_from_file {
2809 my $filename = shift;
2810 my $line_concat_cond_re = shift;
2811 my $line_concat = shift;
2812
2813 open my $fh, $filename || die "unable to read $filename: $!\n";
2814 return sub {
2815 my $saved_line = "";
2816 $_ = "";
2817 while (<$fh>) {
2818 s|\R$||;
2819 if (defined $line_concat) {
2820 $_ = $line_concat->($saved_line, $_);
2821 $saved_line = "";
2822 }
2823 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2824 $saved_line = $_;
2825 next;
2826 }
2827 return $_;
2828 }
2829 die "$filename ending with continuation line\n" if $_;
2830 close $fh;
2831 return undef;
2832 }
2833 }
2834
2835 # collect_from_array($array, $line_concat_cond_re, $line_concat)
2836 # $array is an ARRAYref of lines
2837 # $line_concat_cond_re is a regexp detecting a line continuation ending
2838 # $line_concat is a CODEref that takes care of concatenating two lines
2839 sub collect_from_array {
2840 my $array = shift;
2841 my $line_concat_cond_re = shift;
2842 my $line_concat = shift;
2843 my @array = (@$array);
2844
2845 return sub {
2846 my $saved_line = "";
2847 $_ = "";
2848 while (defined($_ = shift @array)) {
2849 s|\R$||;
2850 if (defined $line_concat) {
2851 $_ = $line_concat->($saved_line, $_);
2852 $saved_line = "";
2853 }
2854 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2855 $saved_line = $_;
2856 next;
2857 }
2858 return $_;
2859 }
2860 die "input text ending with continuation line\n" if $_;
2861 return undef;
2862 }
2863 }
2864
2865 # collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
2866 # $lineiterator is a CODEref that delivers one line at a time.
2867 # All following arguments are regex/CODEref pairs, where the regexp detects a
2868 # line and the CODEref does something with the result of the regexp.
2869 sub collect_information {
2870 my $lineiterator = shift;
2871 my %collectors = @_;
2872
2873 while(defined($_ = $lineiterator->())) {
2874 s|\R$||;
2875 my $found = 0;
2876 if ($collectors{"BEFORE"}) {
2877 $collectors{"BEFORE"}->($_);
2878 }
2879 foreach my $re (keys %collectors) {
2880 if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
2881 $collectors{$re}->($lineiterator);
2882 $found = 1;
2883 };
2884 }
2885 if ($collectors{"OTHERWISE"}) {
2886 $collectors{"OTHERWISE"}->($lineiterator, $_)
2887 unless $found || !defined $collectors{"OTHERWISE"};
2888 }
2889 if ($collectors{"AFTER"}) {
2890 $collectors{"AFTER"}->($_);
2891 }
2892 }
2893 }
2894
2895 # tokenize($line)
2896 # $line is a line of text to split up into tokens
2897 # returns a list of tokens
2898 #
2899 # Tokens are divided by spaces. If the tokens include spaces, they
2900 # have to be quoted with single or double quotes. Double quotes
2901 # inside a double quoted token must be escaped. Escaping is done
2902 # with backslash.
2903 # Basically, the same quoting rules apply for " and ' as in any
2904 # Unix shell.
2905 sub tokenize {
2906 my $line = my $debug_line = shift;
2907 my @result = ();
2908
2909 while ($line =~ s|^\s+||, $line ne "") {
2910 my $token = "";
2911 while ($line ne "" && $line !~ m|^\s|) {
2912 if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
2913 $token .= $1;
2914 $line = $';
2915 } elsif ($line =~ m/^'([^']*)'/) {
2916 $token .= $1;
2917 $line = $';
2918 } elsif ($line =~ m/^(\S+)/) {
2919 $token .= $1;
2920 $line = $';
2921 }
2922 }
2923 push @result, $token;
2924 }
2925
2926 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
2927 print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
2928 print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";
2929 }
2930 return @result;
2931 }
A mirror of the official openssl repository