3 # Copyright 2016-2017 The OpenSSL Project Authors. All Rights Reserved.
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
10 ## Configure -- OpenSSL source tree configuration script
16 use File::Spec::Functions qw/:DEFAULT abs2rel rel2abs/;
17 use File::Path qw/mkpath/;
18 use if $^O ne "VMS", 'File::Glob' => qw/glob/;
20 # see INSTALL for instructions.
22 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";
26 # --config add the given configuration file, which will be read after
27 # any "Configurations*" files that are found in the same
28 # directory as this script.
29 # --prefix prefix for the OpenSSL installation, which includes the
30 # directories bin, lib, include, share/man, share/doc/openssl
31 # This becomes the value of INSTALLTOP in Makefile
32 # (Default: /usr/local)
33 # --openssldir OpenSSL data area, such as openssl.cnf, certificates and keys.
34 # If it's a relative directory, it will be added on the directory
35 # given with --prefix.
36 # This becomes the value of OPENSSLDIR in Makefile and in C.
37 # (Default: PREFIX/ssl)
39 # --cross-compile-prefix Add specified prefix to binutils components.
41 # --api One of 0.9.8, 1.0.0 or 1.1.0. Do not compile support for
42 # interfaces deprecated as of the specified OpenSSL version.
44 # no-hw-xxx do not compile support for specific crypto hardware.
45 # Generic OpenSSL-style methods relating to this support
46 # are always compiled but return NULL if the hardware
47 # support isn't compiled.
48 # no-hw do not compile support for any crypto hardware.
49 # [no-]threads [don't] try to create a library that is suitable for
50 # multithreaded applications (default is "threads" if we
52 # [no-]shared [don't] try to create shared libraries when supported.
53 # [no-]pic [don't] try to build position independent code when supported.
54 # If disabled, it also disables shared and dynamic-engine.
55 # no-asm do not use assembler
56 # no-dso do not compile in any native shared-library methods. This
57 # will ensure that all methods just return NULL.
58 # no-egd do not compile support for the entropy-gathering daemon APIs
59 # [no-]zlib [don't] compile support for zlib compression.
60 # zlib-dynamic Like "zlib", but the zlib library is expected to be a shared
61 # library and will be loaded in run-time by the OpenSSL library.
62 # sctp include SCTP support
63 # enable-weak-ssl-ciphers
64 # Enable weak ciphers that are disabled by default.
65 # 386 generate 80386 code in assembly modules
66 # no-sse2 disables IA-32 SSE2 code in assembly modules, the above
67 # mentioned '386' option implies this one
68 # no-<cipher> build without specified algorithm (rsa, idea, rc5, ...)
69 # -<xxx> +<xxx> compiler options are passed through
70 # -static while -static is also a pass-through compiler option (and
71 # as such is limited to environments where it's actually
72 # meaningful), it triggers a number configuration options,
73 # namely no-dso, no-pic, no-shared and no-threads. It is
74 # argued that the only reason to produce statically linked
75 # binaries (and in context it means executables linked with
76 # -static flag, and not just executables linked with static
77 # libcrypto.a) is to eliminate dependency on specific run-time,
78 # a.k.a. libc version. The mentioned config options are meant
79 # to achieve just that. Unfortunately on Linux it's impossible
80 # to eliminate the dependency completely for openssl executable
81 # because of getaddrinfo and gethostbyname calls, which can
82 # invoke dynamically loadable library facility anyway to meet
83 # the lookup requests. For this reason on Linux statically
84 # linked openssl executable has rather debugging value than
87 # DEBUG_SAFESTACK use type-safe stacks to enforce type-safety on stack items
88 # provided to stack calls. Generates unique stack functions for
89 # each possible stack type.
90 # BN_LLONG use the type 'long long' in crypto/bn/bn.h
91 # RC4_CHAR use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
92 # Following are set automatically by this script
94 # MD5_ASM use some extra md5 assembler,
95 # SHA1_ASM use some extra sha1 assembler, must define L_ENDIAN for x86
96 # RMD160_ASM use some extra ripemd160 assembler,
97 # SHA256_ASM sha256_block is implemented in assembler
98 # SHA512_ASM sha512_block is implemented in assembler
99 # AES_ASM AES_[en|de]crypt is implemented in assembler
101 # Minimum warning options... any contributions to OpenSSL should at least get
104 # DEBUG_UNUSED enables __owur (warn unused result) checks.
105 # -DPEDANTIC complements -pedantic and is meant to mask code that
106 # is not strictly standard-compliant and/or implementation-specific,
107 # e.g. inline assembly, disregards to alignment requirements, such
108 # that -pedantic would complain about. Incidentally -DPEDANTIC has
109 # to be used even in sanitized builds, because sanitizer too is
110 # supposed to and does take notice of non-standard behaviour. Then
111 # -pedantic with pre-C9x compiler would also complain about 'long
112 # long' not being supported. As 64-bit algorithms are common now,
113 # it grew impossible to resolve this without sizeable additional
114 # code, so we just tell compiler to be pedantic about everything
115 # but 'long long' type.
117 my $gcc_devteam_warn = "-DDEBUG_UNUSED"
119 . " -DPEDANTIC -pedantic -Wno-long-long"
122 . " -Wno-unused-parameter"
123 . " -Wno-missing-field-initializers"
125 . " -Wmissing-prototypes"
133 # These are used in addition to $gcc_devteam_warn when the compiler is clang.
134 # TODO(openssl-team): fix problems and investigate if (at least) the
135 # following warnings can also be enabled:
137 # -Wunreachable-code -- no, too ugly/compiler-specific
138 # -Wlanguage-extension-token -- no, we use asm()
139 # -Wunused-macros -- no, too tricky for BN and _XOPEN_SOURCE etc
140 # -Wextended-offsetof -- no, needed in CMS ASN1 code
141 my $clang_devteam_warn = ""
142 . " -Qunused-arguments"
143 . " -Wswitch-default"
144 . " -Wno-parentheses-equality"
145 . " -Wno-language-extension-token"
146 . " -Wno-extended-offsetof"
147 . " -Wconditional-uninitialized"
148 . " -Wincompatible-pointer-types-discards-qualifiers"
149 . " -Wmissing-variable-declarations"
152 # This adds backtrace information to the memory leak info. Is only used
153 # when crypto-mdebug-backtrace is enabled.
154 my $memleak_devteam_backtrace = "-rdynamic";
156 my $strict_warnings = 0;
158 # As for $BSDthreads. Idea is to maintain "collective" set of flags,
159 # which would cover all BSD flavors. -pthread applies to them all,
160 # but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
161 # -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
162 # which has to be accompanied by explicit -D_THREAD_SAFE and
163 # sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
164 # seems to be sufficient?
165 our $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
168 # API compatibility name to version number mapping.
170 my $maxapi = "1.1.0"; # API for "no-deprecated" builds
172 "1.1.0" => "0x10100000L",
173 "1.0.0" => "0x10000000L",
174 "0.9.8" => "0x00908000L",
181 # Forward declarations ###############################################
183 # read_config(filename)
185 # Reads a configuration file and populates %table with the contents
186 # (which the configuration file places in %targets).
189 # resolve_config(target)
191 # Resolves all the late evaluations, inheritances and so on for the
192 # chosen target and any target it inherits from.
196 # Information collection #############################################
198 # Unified build supports separate build dir
199 my $srcdir = catdir(absolutedir(dirname($0))); # catdir ensures local syntax
200 my $blddir = catdir(absolutedir(".")); # catdir ensures local syntax
201 my $dofile = abs2rel(catfile($srcdir, "util/dofile.pl"));
203 my $local_config_envname = 'OPENSSL_LOCAL_CONFIG_DIR';
205 $config{sourcedir} = abs2rel($srcdir);
206 $config{builddir} = abs2rel($blddir);
208 # Collect reconfiguration information if needed
211 if (grep /^reconf(igure)?$/, @argvcopy) {
212 if (-f "./configdata.pm") {
213 my $file = "./configdata.pm";
214 unless (my $return = do $file) {
215 die "couldn't parse $file: $@" if $@;
216 die "couldn't do $file: $!" unless defined $return;
217 die "couldn't run $file" unless $return;
220 @argvcopy = defined($configdata::config{perlargv}) ?
221 @{$configdata::config{perlargv}} : ();
222 die "Incorrect data to reconfigure, please do a normal configuration\n"
223 if (grep(/^reconf/,@argvcopy));
224 $ENV{CROSS_COMPILE} = $configdata::config{cross_compile_prefix}
225 if defined($configdata::config{cross_compile_prefix});
226 $ENV{CC} = $configdata::config{cc}
227 if defined($configdata::config{cc});
228 $ENV{CXX} = $configdata::config{cxx}
229 if defined($configdata::config{cxx});
230 $ENV{BUILDFILE} = $configdata::config{build_file}
231 if defined($configdata::config{build_file});
232 $ENV{$local_config_envname} = $configdata::config{local_config_dir}
233 if defined($configdata::config{local_config_dir});
235 print "Reconfiguring with: ", join(" ",@argvcopy), "\n";
236 print " CROSS_COMPILE = ",$ENV{CROSS_COMPILE},"\n"
237 if $ENV{CROSS_COMPILE};
238 print " CC = ",$ENV{CC},"\n" if $ENV{CC};
239 print " CXX = ",$ENV{CXX},"\n" if $ENV{CXX};
240 print " BUILDFILE = ",$ENV{BUILDFILE},"\n" if $ENV{BUILDFILE};
241 print " $local_config_envname = ",$ENV{$local_config_envname},"\n"
242 if $ENV{$local_config_envname};
244 die "Insufficient data to reconfigure, please do a normal configuration\n";
248 $config{perlargv} = [ @argvcopy ];
250 # Collect version numbers
251 $config{version} = "unknown";
252 $config{version_num} = "unknown";
253 $config{shlib_version_number} = "unknown";
254 $config{shlib_version_history} = "unknown";
257 collect_from_file(catfile($srcdir,'include/openssl/opensslv.h')),
258 qr/OPENSSL.VERSION.TEXT.*OpenSSL (\S+) / => sub { $config{version} = $1; },
259 qr/OPENSSL.VERSION.NUMBER.*(0x\S+)/ => sub { $config{version_num}=$1 },
260 qr/SHLIB_VERSION_NUMBER *"([^"]+)"/ => sub { $config{shlib_version_number}=$1 },
261 qr/SHLIB_VERSION_HISTORY *"([^"]*)"/ => sub { $config{shlib_version_history}=$1 }
263 if ($config{shlib_version_history} ne "") { $config{shlib_version_history} .= ":"; }
265 ($config{major}, $config{minor})
266 = ($config{version} =~ /^([0-9]+)\.([0-9\.]+)/);
267 ($config{shlib_major}, $config{shlib_minor})
268 = ($config{shlib_version_number} =~ /^([0-9]+)\.([0-9\.]+)/);
269 die "erroneous version information in opensslv.h: ",
270 "$config{major}, $config{minor}, $config{shlib_major}, $config{shlib_minor}\n"
271 if ($config{major} eq "" || $config{minor} eq ""
272 || $config{shlib_major} eq "" || $config{shlib_minor} eq "");
274 # Collect target configurations
276 my $pattern = catfile(dirname($0), "Configurations", "*.conf");
277 foreach (sort glob($pattern)) {
281 if (defined $ENV{$local_config_envname}) {
283 # VMS environment variables are logical names,
284 # which can be used as is
285 $pattern = $local_config_envname . ':' . '*.conf';
287 $pattern = catfile($ENV{$local_config_envname}, '*.conf');
290 foreach (sort glob($pattern)) {
296 $config{openssldir}="";
297 $config{processor}="";
299 $config{cross_compile_prefix}="";
300 my $auto_threads=1; # enable threads automatically? true by default
303 # Top level directories to build
304 $config{dirs} = [ "crypto", "ssl", "engines", "apps", "test", "util", "tools", "fuzz" ];
305 # crypto/ subdirectories to build
308 "md2", "md4", "md5", "sha", "mdc2", "hmac", "ripemd", "whrlpool", "poly1305", "blake2", "siphash",
309 "des", "aes", "rc2", "rc4", "rc5", "idea", "aria", "bf", "cast", "camellia", "seed", "chacha", "modes",
310 "bn", "ec", "rsa", "dsa", "dh", "dso", "engine",
311 "buffer", "bio", "stack", "lhash", "rand", "err",
312 "evp", "asn1", "pem", "x509", "x509v3", "conf", "txt_db", "pkcs7", "pkcs12", "comp", "ocsp", "ui",
313 "cms", "ts", "srp", "cmac", "ct", "async", "kdf", "store"
315 # test/ subdirectories to build
316 $config{tdirs} = [ "ossl_shim" ];
318 # Known TLS and DTLS protocols
319 my @tls = qw(ssl3 tls1 tls1_1 tls1_2 tls1_3);
320 my @dtls = qw(dtls1 dtls1_2);
322 # Explicitly known options that are possible to disable. They can
323 # be regexps, and will be used like this: /^no-${option}$/
324 # For developers: keep it sorted alphabetically
344 "crypto-mdebug-backtrace",
359 "ec_nistp_64_gcc_128",
416 foreach my $proto ((@tls, @dtls))
418 push(@disablables, $proto);
419 push(@disablables, "$proto-method") unless $proto eq "tls1_3";
422 my %deprecated_disablables = (
424 "buf-freelists" => undef,
425 "ripemd" => "rmd160",
426 "ui" => "ui-console",
429 # All of the following is disabled by default (RC5 was enabled before 0.9.8):
431 our %disabled = ( # "what" => "comment"
434 "crypto-mdebug" => "default",
435 "crypto-mdebug-backtrace" => "default",
436 "devcryptoeng" => "default",
437 "ec_nistp_64_gcc_128" => "default",
439 "external-tests" => "default",
440 "fuzz-libfuzzer" => "default",
441 "fuzz-afl" => "default",
442 "heartbeats" => "default",
447 "ssl-trace" => "default",
449 "ssl3-method" => "default",
450 "ubsan" => "default",
451 #TODO(TLS1.3): Temporarily disabled while this is a WIP
452 "tls1_3" => "default",
453 "tls13downgrade" => "default",
454 "unit-test" => "default",
455 "weak-ssl-ciphers" => "default",
457 "zlib-dynamic" => "default",
460 # Note: => pair form used for aesthetics, not to truly make a hash table
461 my @disable_cascades = (
462 # "what" => [ "cascade", ... ]
463 sub { $config{processor} eq "386" }
466 "ssl3-method" => [ "ssl3" ],
467 "zlib" => [ "zlib-dynamic" ],
469 "ec" => [ "ecdsa", "ecdh" ],
471 "dgram" => [ "dtls", "sctp" ],
472 "sock" => [ "dgram" ],
474 sub { 0 == scalar grep { !$disabled{$_} } @dtls }
477 # SSL 3.0, (D)TLS 1.0 and TLS 1.1 require MD5 and SHA
478 "md5" => [ "ssl", "tls1", "tls1_1", "dtls1" ],
479 "sha" => [ "ssl", "tls1", "tls1_1", "dtls1" ],
481 # Additionally, SSL 3.0 requires either RSA or DSA+DH
483 && ($disabled{dsa} || $disabled{dh}); }
486 # (D)TLS 1.0 and TLS 1.1 also require either RSA or DSA+DH
487 # or ECDSA + ECDH. (D)TLS 1.2 has this requirement as well.
488 # (XXX: We don't support PSK-only builds).
490 && ($disabled{dsa} || $disabled{dh})
491 && ($disabled{ecdsa} || $disabled{ecdh}); }
492 => [ "tls1", "tls1_1", "tls1_2", "tls1_3",
493 "dtls1", "dtls1_2" ],
496 sub { 0 == scalar grep { !$disabled{$_} } @tls }
499 # SRP and HEARTBEATS require TLSEXT
500 "tlsext" => [ "srp", "heartbeats" ],
502 "crypto-mdebug" => [ "crypto-mdebug-backtrace" ],
504 # Without DSO, we can't load dynamic engines, so don't build them dynamic
505 "dso" => [ "dynamic-engine" ],
507 # Without position independent code, there can be no shared libraries or DSOs
508 "pic" => [ "shared" ],
509 "shared" => [ "dynamic-engine" ],
510 "engine" => [ "afalgeng", "devcryptoeng" ],
512 # no-autoalginit is only useful when building non-shared
513 "autoalginit" => [ "shared", "apps" ],
515 "stdio" => [ "apps", "capieng" ],
516 "apps" => [ "tests" ],
517 "comp" => [ "zlib" ],
518 "ec" => [ "tls1_3" ],
519 sub { !$disabled{"unit-test"} } => [ "heartbeats" ],
521 sub { !$disabled{"msan"} } => [ "asm" ],
524 # Avoid protocol support holes. Also disable all versions below N, if version
525 # N is disabled while N+1 is enabled.
527 my @list = (reverse @tls);
528 while ((my $first, my $second) = (shift @list, shift @list)) {
530 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
532 unshift @list, $second;
534 my @list = (reverse @dtls);
535 while ((my $first, my $second) = (shift @list, shift @list)) {
537 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
539 unshift @list, $second;
542 # Explicit "no-..." options will be collected in %disabled along with the defaults.
543 # To remove something from %disabled, use "enable-foo".
544 # For symmetry, "disable-foo" is a synonym for "no-foo".
548 &usage if ($#ARGV < 0);
552 $config{openssl_api_defines}=[];
553 $config{openssl_algorithm_defines}=[];
554 $config{openssl_thread_defines}=[];
555 $config{openssl_sys_defines}=[];
556 $config{openssl_other_defines}=[];
560 $config{build_type} = "release";
562 my %unsupported_options = ();
563 my %deprecated_options = ();
564 # If you change this, update apps/version.c
565 my @known_seed_sources = qw(getrandom devrandom os egd none rdcpu librandom);
566 my @seed_sources = ();
569 $_ = shift @argvcopy;
570 # VMS is a case insensitive environment, and depending on settings
571 # out of our control, we may receive options uppercased. Let's
572 # downcase at least the part before any equal sign.
577 s /^-no-/no-/; # some people just can't read the instructions
579 # rewrite some options in "enable-..." form
580 s /^-?-?shared$/enable-shared/;
581 s /^sctp$/enable-sctp/;
582 s /^threads$/enable-threads/;
583 s /^zlib$/enable-zlib/;
584 s /^zlib-dynamic$/enable-zlib-dynamic/;
586 if (/^(no|disable|enable)-(.+)$/)
589 if (!exists $deprecated_disablables{$word}
590 && !grep { $word =~ /^${_}$/ } @disablables)
592 $unsupported_options{$_} = 1;
596 if (/^no-(.+)$/ || /^disable-(.+)$/)
598 foreach my $proto ((@tls, @dtls))
600 if ($1 eq "$proto-method")
602 $disabled{"$proto"} = "option($proto-method)";
608 foreach my $proto (@dtls)
610 $disabled{$proto} = "option(dtls)";
612 $disabled{"dtls"} = "option(dtls)";
616 # Last one of its kind
617 $disabled{"ssl3"} = "option(ssl)";
621 # XXX: Tests will fail if all SSL/TLS
622 # protocols are disabled.
623 foreach my $proto (@tls)
625 $disabled{$proto} = "option(tls)";
628 elsif ($1 eq "static-engine")
630 delete $disabled{"dynamic-engine"};
632 elsif ($1 eq "dynamic-engine")
634 $disabled{"dynamic-engine"} = "option";
636 elsif (exists $deprecated_disablables{$1})
638 $deprecated_options{$_} = 1;
639 if (defined $deprecated_disablables{$1})
641 $disabled{$deprecated_disablables{$1}} = "option";
646 $disabled{$1} = "option";
648 # No longer an automatic choice
649 $auto_threads = 0 if ($1 eq "threads");
651 elsif (/^enable-(.+)$/)
653 if ($1 eq "static-engine")
655 $disabled{"dynamic-engine"} = "option";
657 elsif ($1 eq "dynamic-engine")
659 delete $disabled{"dynamic-engine"};
661 elsif ($1 eq "zlib-dynamic")
663 delete $disabled{"zlib"};
666 delete $disabled{$algo};
668 # No longer an automatic choice
669 $auto_threads = 0 if ($1 eq "threads");
671 elsif (/^--strict-warnings$/)
673 $strict_warnings = 1;
677 $config{build_type} = "debug";
679 elsif (/^--release$/)
681 $config{build_type} = "release";
684 { $config{processor}=386; }
687 die "FIPS mode not supported\n";
691 # No RSAref support any more since it's not needed.
692 # The check for the option is there so scripts aren't
695 elsif (/^nofipscanistercheck$/)
697 die "FIPS mode not supported\n";
701 if (/^--prefix=(.*)$/)
704 die "Directory given with --prefix MUST be absolute\n"
705 unless file_name_is_absolute($config{prefix});
707 elsif (/^--api=(.*)$/)
711 elsif (/^--libdir=(.*)$/)
715 elsif (/^--openssldir=(.*)$/)
717 $config{openssldir}=$1;
719 elsif (/^--with-zlib-lib=(.*)$/)
721 $withargs{zlib_lib}=$1;
723 elsif (/^--with-zlib-include=(.*)$/)
725 $withargs{zlib_include}=$1;
727 elsif (/^--with-fuzzer-lib=(.*)$/)
729 $withargs{fuzzer_lib}=$1;
731 elsif (/^--with-fuzzer-include=(.*)$/)
733 $withargs{fuzzer_include}=$1;
735 elsif (/^--with-rand-seed=(.*)$/)
737 foreach my $x (split(m|,|, $1))
739 die "Unknown --with-rand-seed choice $x\n"
740 if ! grep { $x eq $_ } @known_seed_sources;
741 push @seed_sources, $x;
744 elsif (/^--cross-compile-prefix=(.*)$/)
746 $config{cross_compile_prefix}=$1;
748 elsif (/^--config=(.*)$/)
752 elsif (/^-[lL](.*)$/ or /^-Wl,/)
756 elsif (/^-framework$/)
758 $libs.=$_." ".shift(@argvcopy)." ";
760 elsif (/^-rpath$/ or /^-R$/)
761 # -rpath is the OSF1 rpath flag
762 # -R is the old Solaris rpath flag
764 my $rpath = shift(@argvcopy) || "";
765 $rpath .= " " if $rpath ne "";
766 $libs.=$_." ".$rpath;
771 $disabled{"dso"} = "forced";
772 $disabled{"pic"} = "forced";
773 $disabled{"shared"} = "forced";
774 $disabled{"threads"} = "forced";
778 push @user_defines, $1;
780 else # common if (/^[-+]/), just pass down...
782 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
783 $user_cflags.=" ".$_;
788 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
791 unless ($_ eq $target || /^no-/ || /^disable-/)
793 # "no-..." follows later after implied disactivations
794 # have been derived. (Don't take this too seriously,
795 # we really only write OPTIONS to the Makefile out of
798 if ($config{options} eq "")
799 { $config{options} = $_; }
801 { $config{options} .= " ".$_; }
804 if (defined($config{api}) && !exists $apitable->{$config{api}}) {
805 die "***** Unsupported api compatibility level: $config{api}\n",
808 if (keys %deprecated_options)
810 warn "***** Deprecated options: ",
811 join(", ", keys %deprecated_options), "\n";
813 if (keys %unsupported_options)
815 die "***** Unsupported options: ",
816 join(", ", keys %unsupported_options), "\n";
820 if ($libs =~ /(^|\s)-Wl,-rpath,/
821 && !$disabled{shared}
822 && !($disabled{asan} && $disabled{msan} && $disabled{ubsan})) {
823 die "***** Cannot simultaneously use -rpath, shared libraries, and\n",
824 "***** any of asan, msan or ubsan\n";
827 if (scalar(@seed_sources) == 0) {
828 print "Using implicit seed configuration\n";
829 push @seed_sources, 'os';
831 die "Cannot seed with none and anything else"
832 if scalar(grep { $_ eq 'none' } @seed_sources) > 0
833 && scalar(@seed_sources) > 1;
834 push @{$config{openssl_other_defines}},
835 map { (my $x = $_) =~ tr|[\-a-z]|[_A-Z]|; "OPENSSL_RAND_SEED_$x" }
838 my @tocheckfor = (keys %disabled);
839 while (@tocheckfor) {
840 my %new_tocheckfor = ();
841 my @cascade_copy = (@disable_cascades);
842 while (@cascade_copy) {
843 my ($test, $descendents) = (shift @cascade_copy, shift @cascade_copy);
844 if (ref($test) eq "CODE" ? $test->() : defined($disabled{$test})) {
845 foreach(grep { !defined($disabled{$_}) } @$descendents) {
846 $new_tocheckfor{$_} = 1; $disabled{$_} = "forced";
850 @tocheckfor = (keys %new_tocheckfor);
853 our $die = sub { die @_; };
854 if ($target eq "TABLE") {
855 local $die = sub { warn @_; };
856 foreach (sort keys %table) {
857 print_table_entry($_, "TABLE");
862 if ($target eq "LIST") {
863 foreach (sort keys %table) {
864 print $_,"\n" unless $table{$_}->{template};
869 if ($target eq "HASH") {
870 local $die = sub { warn @_; };
871 print "%table = (\n";
872 foreach (sort keys %table) {
873 print_table_entry($_, "HASH");
878 print "Configuring OpenSSL version $config{version} ($config{version_num})\n";
879 print "for $target\n";
881 # Backward compatibility?
882 if ($target =~ m/^CygWin32(-.*)$/) {
883 $target = "Cygwin".$1;
886 # Support for legacy targets having a name starting with 'debug-'
887 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
889 $config{build_type} = "debug";
891 # If we do not find debug-foo in the table, the target is set to foo.
892 if (!$table{$target}) {
896 $config{target} = $target;
897 my %target = resolve_config($target);
899 &usage if (!%target || $target{template});
901 my %conf_files = map { $_ => 1 } (@{$target{_conf_fname_int}});
902 $config{conf_files} = [ sort keys %conf_files ];
903 %target = ( %{$table{DEFAULTS}}, %target );
905 foreach my $feature (@{$target{disable}}) {
906 if (exists $deprecated_disablables{$feature}) {
907 warn "***** config $target disables deprecated feature $feature\n";
908 } elsif (!grep { $feature eq $_ } @disablables) {
909 die "***** config $target disables unknown feature $feature\n";
911 $disabled{$feature} = 'config';
913 foreach my $feature (@{$target{enable}}) {
914 if ("default" eq ($disabled{$_} // "")) {
915 if (exists $deprecated_disablables{$feature}) {
916 warn "***** config $target enables deprecated feature $feature\n";
917 } elsif (!grep { $feature eq $_ } @disablables) {
918 die "***** config $target enables unknown feature $feature\n";
920 delete $disabled{$_};
924 foreach (sort (keys %disabled))
926 $config{options} .= " no-$_";
928 printf " no-%-12s %-10s", $_, "[$disabled{$_}]";
940 elsif (/^dynamic-engine$/)
942 elsif (/^makedepend$/)
944 elsif (/^zlib-dynamic$/)
950 @{$config{dirs}} = grep !/^engines$/, @{$config{dirs}};
951 @{$config{sdirs}} = grep !/^engine$/, @{$config{sdirs}};
952 push @{$config{openssl_other_defines}}, "OPENSSL_NO_ENGINE";
953 print " OPENSSL_NO_ENGINE (skip engines)";
959 ($WHAT = $what = $_) =~ tr/[\-a-z]/[_A-Z]/;
961 # Fix up C macro end names
962 $WHAT = "RMD160" if $what eq "ripemd";
964 # fix-up crypto/directory name(s)
965 $what = "ripemd" if $what eq "rmd160";
966 $what = "whrlpool" if $what eq "whirlpool";
968 if ($what ne "async" && $what ne "err"
969 && grep { $_ eq $what } @{$config{sdirs}})
971 push @{$config{openssl_algorithm_defines}}, "OPENSSL_NO_$WHAT";
972 @{$config{sdirs}} = grep { $_ ne $what} @{$config{sdirs}};
974 print " OPENSSL_NO_$WHAT (skip dir)";
978 push @{$config{openssl_other_defines}}, "OPENSSL_NO_$WHAT";
979 print " OPENSSL_NO_$WHAT";
981 if (/^err$/) { push @user_defines, "OPENSSL_NO_ERR"; }
988 $target{cxxflags}=$target{cflags} unless defined $target{cxxflags};
989 $target{exe_extension}="";
990 $target{exe_extension}=".exe" if ($config{target} eq "DJGPP"
991 || $config{target} =~ /^(?:Cygwin|mingw)/);
992 $target{exe_extension}=".pm" if ($config{target} =~ /vos/);
994 ($target{shared_extension_simple}=$target{shared_extension})
995 =~ s|\.\$\(SHLIB_MAJOR\)\.\$\(SHLIB_MINOR\)||;
996 $target{dso_extension}=$target{shared_extension_simple};
997 ($target{shared_import_extension}=$target{shared_extension_simple}.".a")
998 if ($config{target} =~ /^(?:Cygwin|mingw)/);
1001 $config{cross_compile_prefix} = $ENV{'CROSS_COMPILE'}
1002 if $config{cross_compile_prefix} eq "";
1004 # Allow overriding the names of some tools. USE WITH CARE
1005 # Note: only Unix cares about HASHBANGPERL... that explains
1006 # the default string.
1007 $config{perl} = ($^O ne "VMS" ? $^X : "perl");
1008 $config{hashbangperl} =
1009 $ENV{'HASHBANGPERL'} || $ENV{'PERL'} || "/usr/bin/env perl";
1010 $target{cc} = $ENV{'CC'} || $target{cc} || "cc";
1011 $target{cxx} = $ENV{'CXX'} || $target{cxx} || "c++";
1012 $target{ranlib} = $ENV{'RANLIB'} || $target{ranlib} ||
1013 (which("$config{cross_compile_prefix}ranlib") ?
1014 "\$(CROSS_COMPILE)ranlib" : "true");
1015 $target{ar} = $ENV{'AR'} || $target{ar} || "ar";
1016 $target{nm} = $ENV{'NM'} || $target{nm} || "nm";
1018 $ENV{'RC'} || $ENV{'WINDRES'} || $target{rc} || "windres";
1020 # Allow overriding the build file name
1021 $target{build_file} = $ENV{BUILDFILE} || $target{build_file} || "Makefile";
1023 # Cache information necessary for reconfiguration
1024 $config{cc} = $target{cc};
1025 $config{cxx} = $target{cxx};
1026 $config{build_file} = $target{build_file};
1028 # For cflags, lflags, plib_lflags, ex_libs and defines, add the debug_
1029 # or release_ attributes.
1030 # Do it in such a way that no spurious space is appended (hence the grep).
1031 $config{defines} = [];
1032 $config{cflags} = "";
1033 $config{cxxflags} = "";
1034 $config{ex_libs} = "";
1035 $config{shared_ldflag} = "";
1037 # Make sure build_scheme is consistent.
1038 $target{build_scheme} = [ $target{build_scheme} ]
1039 if ref($target{build_scheme}) ne "ARRAY";
1041 my ($builder, $builder_platform, @builder_opts) =
1042 @{$target{build_scheme}};
1044 foreach my $checker (($builder_platform."-".$target{build_file}."-checker.pm",
1045 $builder_platform."-checker.pm")) {
1046 my $checker_path = catfile($srcdir, "Configurations", $checker);
1047 if (-f $checker_path) {
1048 my $fn = $ENV{CONFIGURE_CHECKER_WARN}
1049 ? sub { warn $@; } : sub { die $@; };
1050 if (! do $checker_path) {
1056 $fn->("The detected tools didn't match the platform\n");
1063 push @{$config{defines}}, "NDEBUG" if $config{build_type} eq "release";
1065 if ($target =~ /^mingw/ && `$target{cc} --target-help 2>&1` =~ m/-mno-cygwin/m)
1067 $config{cflags} .= " -mno-cygwin";
1068 $config{shared_ldflag} .= " -mno-cygwin";
1071 if ($target =~ /linux.*-mips/ && !$disabled{asm} && $user_cflags !~ /-m(ips|arch=)/) {
1072 # minimally required architecture flags for assembly modules
1073 $config{cflags}="-mips2 $config{cflags}" if ($target =~ /mips32/);
1074 $config{cflags}="-mips3 $config{cflags}" if ($target =~ /mips64/);
1077 my $no_shared_warn=0;
1078 my $no_user_cflags=0;
1079 my $no_user_defines=0;
1081 # The DSO code currently always implements all functions so that no
1082 # applications will have to worry about that from a compilation point
1083 # of view. However, the "method"s may return zero unless that platform
1084 # has support compiled in for them. Currently each method is enabled
1085 # by a define "DSO_<name>" ... we translate the "dso_scheme" config
1086 # string entry into using the following logic;
1087 if (!$disabled{dso} && $target{dso_scheme} ne "")
1089 $target{dso_scheme} =~ tr/[a-z]/[A-Z]/;
1090 if ($target{dso_scheme} eq "DLFCN")
1092 unshift @{$config{defines}}, "DSO_DLFCN", "HAVE_DLFCN_H";
1094 elsif ($target{dso_scheme} eq "DLFCN_NO_H")
1096 unshift @{$config{defines}}, "DSO_DLFCN";
1100 unshift @{$config{defines}}, "DSO_$target{dso_scheme}";
1104 $config{ex_libs}="$libs$config{ex_libs}" if ($libs ne "");
1106 # If threads aren't disabled, check how possible they are
1107 unless ($disabled{threads}) {
1108 if ($auto_threads) {
1109 # Enabled by default, disable it forcibly if unavailable
1110 if ($target{thread_scheme} eq "(unknown)") {
1111 $disabled{threads} = "unavailable";
1114 # The user chose to enable threads explicitly, let's see
1115 # if there's a chance that's possible
1116 if ($target{thread_scheme} eq "(unknown)") {
1117 # If the user asked for "threads" and we don't have internal
1118 # knowledge how to do it, [s]he is expected to provide any
1119 # system-dependent compiler options that are necessary. We
1120 # can't truly check that the given options are correct, but
1121 # we expect the user to know what [s]He is doing.
1122 if ($no_user_cflags && $no_user_defines) {
1123 die "You asked for multi-threading support, but didn't\n"
1124 ,"provide any system-specific compiler options\n";
1130 # If threads still aren't disabled, add a C macro to ensure the source
1131 # code knows about it. Any other flag is taken care of by the configs.
1132 unless($disabled{threads}) {
1133 foreach (("defines", "openssl_thread_defines")) {
1134 push @{$config{$_}}, "OPENSSL_THREADS";
1138 # With "deprecated" disable all deprecated features.
1139 if (defined($disabled{"deprecated"})) {
1140 $config{api} = $maxapi;
1143 if ($target{shared_target} eq "")
1146 if (!$disabled{shared} || !$disabled{"dynamic-engine"});
1147 $disabled{shared} = "no-shared-target";
1148 $disabled{pic} = $disabled{shared} = $disabled{"dynamic-engine"} =
1152 if ($disabled{"dynamic-engine"}) {
1153 push @{$config{defines}}, "OPENSSL_NO_DYNAMIC_ENGINE";
1154 $config{dynamic_engines} = 0;
1156 push @{$config{defines}}, "OPENSSL_NO_STATIC_ENGINE";
1157 $config{dynamic_engines} = 1;
1160 unless ($disabled{asan}) {
1161 $config{cflags} .= "-fsanitize=address ";
1164 unless ($disabled{ubsan}) {
1165 # -DPEDANTIC or -fnosanitize=alignment may also be required on some
1167 $config{cflags} .= "-fsanitize=undefined -fno-sanitize-recover=all ";
1170 unless ($disabled{msan}) {
1171 $config{cflags} .= "-fsanitize=memory ";
1174 unless ($disabled{"fuzz-libfuzzer"} && $disabled{"fuzz-afl"}
1175 && $disabled{asan} && $disabled{ubsan} && $disabled{msan}) {
1176 $config{cflags} .= "-fno-omit-frame-pointer -g ";
1182 # This saves the build files from having to check
1185 $target{shared_cflag} = $target{shared_ldflag} =
1186 $target{shared_rcflag} = "";
1190 push @{$config{defines}}, "OPENSSL_PIC";
1193 if ($target{sys_id} ne "")
1195 push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
1198 unless ($disabled{asm}) {
1199 $target{cpuid_asm_src}=$table{DEFAULTS}->{cpuid_asm_src} if ($config{processor} eq "386");
1200 $target{bn_asm_src} =~ s/\w+-gf2m.c// if (defined($disabled{ec2m}));
1202 # bn-586 is the only one implementing bn_*_part_words
1203 push @{$config{defines}}, "OPENSSL_BN_ASM_PART_WORDS" if ($target{bn_asm_src} =~ /bn-586/);
1204 push @{$config{defines}}, "OPENSSL_IA32_SSE2" if (!$no_sse2 && $target{bn_asm_src} =~ /86/);
1206 push @{$config{defines}}, "OPENSSL_BN_ASM_MONT" if ($target{bn_asm_src} =~ /-mont/);
1207 push @{$config{defines}}, "OPENSSL_BN_ASM_MONT5" if ($target{bn_asm_src} =~ /-mont5/);
1208 push @{$config{defines}}, "OPENSSL_BN_ASM_GF2m" if ($target{bn_asm_src} =~ /-gf2m/);
1210 if ($target{sha1_asm_src}) {
1211 push @{$config{defines}}, "SHA1_ASM" if ($target{sha1_asm_src} =~ /sx86/ || $target{sha1_asm_src} =~ /sha1/);
1212 push @{$config{defines}}, "SHA256_ASM" if ($target{sha1_asm_src} =~ /sha256/);
1213 push @{$config{defines}}, "SHA512_ASM" if ($target{sha1_asm_src} =~ /sha512/);
1215 if ($target{rc4_asm_src} ne $table{DEFAULTS}->{rc4_asm_src}) {
1216 push @{$config{defines}}, "RC4_ASM";
1218 if ($target{md5_asm_src}) {
1219 push @{$config{defines}}, "MD5_ASM";
1221 $target{cast_asm_src}=$table{DEFAULTS}->{cast_asm_src} unless $disabled{pic}; # CAST assembler is not PIC
1222 if ($target{rmd160_asm_src}) {
1223 push @{$config{defines}}, "RMD160_ASM";
1225 if ($target{aes_asm_src}) {
1226 push @{$config{defines}}, "AES_ASM" if ($target{aes_asm_src} =~ m/\baes-/);;
1227 # aes-ctr.fake is not a real file, only indication that assembler
1228 # module implements AES_ctr32_encrypt...
1229 push @{$config{defines}}, "AES_CTR_ASM" if ($target{aes_asm_src} =~ s/\s*aes-ctr\.fake//);
1230 # aes-xts.fake indicates presence of AES_xts_[en|de]crypt...
1231 push @{$config{defines}}, "AES_XTS_ASM" if ($target{aes_asm_src} =~ s/\s*aes-xts\.fake//);
1232 $target{aes_asm_src} =~ s/\s*(vpaes|aesni)-x86\.s//g if ($no_sse2);
1233 push @{$config{defines}}, "VPAES_ASM" if ($target{aes_asm_src} =~ m/vpaes/);
1234 push @{$config{defines}}, "BSAES_ASM" if ($target{aes_asm_src} =~ m/bsaes/);
1236 if ($target{wp_asm_src} =~ /mmx/) {
1237 if ($config{processor} eq "386") {
1238 $target{wp_asm_src}=$table{DEFAULTS}->{wp_asm_src};
1239 } elsif (!$disabled{"whirlpool"}) {
1240 push @{$config{defines}}, "WHIRLPOOL_ASM";
1243 if ($target{modes_asm_src} =~ /ghash-/) {
1244 push @{$config{defines}}, "GHASH_ASM";
1246 if ($target{ec_asm_src} =~ /ecp_nistz256/) {
1247 push @{$config{defines}}, "ECP_NISTZ256_ASM";
1249 if ($target{padlock_asm_src} ne $table{DEFAULTS}->{padlock_asm_src}) {
1250 push @{$config{defines}}, "PADLOCK_ASM";
1252 if ($target{poly1305_asm_src} ne "") {
1253 push @{$config{defines}}, "POLY1305_ASM";
1257 my $ecc = $target{cc};
1258 if ($^O ne "VMS" && !$disabled{makedepend}) {
1259 # Is the compiler gcc or clang? $ecc is used below to see if
1260 # error-checking can be turned on.
1261 my $ccpcc = "$config{cross_compile_prefix}$target{cc}";
1262 open(PIPE, "$ccpcc --version 2>&1 |");
1265 # Find the version number and save the major.
1266 m|(?:.*)\b(\d+)\.\d+\.\d+\b(?:.*)|;
1267 my $compiler_major = $1;
1268 # We know that GNU C version 3 and up as well as all clang
1269 # versions support dependency generation
1270 $config{makedepprog} = $ccpcc
1271 if (/clang/ || (/gcc/ && $compiler_major >= 3));
1272 $ecc = "clang" if /clang/;
1273 $ecc = "gcc" if /gcc/;
1274 last if ($config{makedepprog} || !$lines--);
1278 $config{makedepprog} = which('makedepend') unless $config{makedepprog};
1279 $disabled{makedepend} = "unavailable" unless $config{makedepprog};
1284 # Deal with bn_ops ###################################################
1287 $config{export_var_as_fn} =0;
1288 my $def_int="unsigned int";
1289 $config{rc4_int} =$def_int;
1290 ($config{b64l},$config{b64},$config{b32})=(0,0,1);
1293 foreach (sort split(/\s+/,$target{bn_ops})) {
1294 $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1295 $config{export_var_as_fn}=1 if $_ eq 'EXPORT_VAR_AS_FN';
1296 $config{bn_ll}=1 if $_ eq 'BN_LLONG';
1297 $config{rc4_int}="unsigned char" if $_ eq 'RC4_CHAR';
1298 ($config{b64l},$config{b64},$config{b32})
1299 =(0,1,0) if $_ eq 'SIXTY_FOUR_BIT';
1300 ($config{b64l},$config{b64},$config{b32})
1301 =(1,0,0) if $_ eq 'SIXTY_FOUR_BIT_LONG';
1302 ($config{b64l},$config{b64},$config{b32})
1303 =(0,0,1) if $_ eq 'THIRTY_TWO_BIT';
1305 die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1309 # Hack cflags for better warnings (dev option) #######################
1311 # "Stringify" the C flags string. This permits it to be made part of a string
1312 # and works as well on command lines.
1313 $config{cflags} =~ s/([\\\"])/\\$1/g;
1315 if (defined($config{api})) {
1316 $config{openssl_api_defines} = [ "OPENSSL_MIN_API=".$apitable->{$config{api}} ];
1317 my $apiflag = sprintf("OPENSSL_API_COMPAT=%s", $apitable->{$config{api}});
1318 push @{$config{defines}}, $apiflag;
1321 if ($strict_warnings)
1324 die "ERROR --strict-warnings requires gcc or clang"
1325 unless $ecc eq 'gcc' || $ecc eq 'clang';
1326 foreach $wopt (split /\s+/, $gcc_devteam_warn)
1328 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1330 if ($ecc eq "clang")
1332 foreach $wopt (split /\s+/, $clang_devteam_warn)
1334 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1339 unless ($disabled{"crypto-mdebug-backtrace"})
1341 foreach my $wopt (split /\s+/, $memleak_devteam_backtrace)
1343 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1345 if ($target =~ /^BSD-/)
1347 $config{ex_libs} .= " -lexecinfo";
1351 if ($user_cflags ne "") { $config{cflags}="$config{cflags}$user_cflags"; $config{cxxflags}="$config{cxxflags}$user_cflags";}
1352 else { $no_user_cflags=1; }
1353 if (@user_defines) { $config{defines}=[ @{$config{defines}}, @user_defines ]; }
1354 else { $no_user_defines=1; }
1356 # ALL MODIFICATIONS TO %config and %target MUST BE DONE FROM HERE ON
1358 unless ($disabled{afalgeng}) {
1359 $config{afalgeng}="";
1360 if ($target =~ m/^linux/) {
1361 my $minver = 4*10000 + 1*100 + 0;
1362 if ($config{cross_compile_prefix} eq "") {
1363 my $verstr = `uname -r`;
1364 my ($ma, $mi1, $mi2) = split("\\.", $verstr);
1365 ($mi2) = $mi2 =~ /(\d+)/;
1366 my $ver = $ma*10000 + $mi1*100 + $mi2;
1367 if ($ver < $minver) {
1368 $disabled{afalgeng} = "too-old-kernel";
1370 push @{$config{engdirs}}, "afalg";
1373 $disabled{afalgeng} = "cross-compiling";
1376 $disabled{afalgeng} = "not-linux";
1380 push @{$config{openssl_other_defines}}, "OPENSSL_NO_AFALGENG" if ($disabled{afalgeng});
1382 # If we use the unified build, collect information from build.info files
1383 my %unified_info = ();
1385 my $buildinfo_debug = defined($ENV{CONFIGURE_DEBUG_BUILDINFO});
1386 if ($builder eq "unified") {
1387 use lib catdir(dirname(__FILE__),"util");
1388 use with_fallback qw(Text::Template);
1393 my $relativeto = shift || ".";
1395 $dir = catdir($base,$dir) unless isabsolute($dir);
1397 # Make sure the directories we're building in exists
1400 my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
1401 #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1408 my $relativeto = shift || ".";
1410 $file = catfile($base,$file) unless isabsolute($file);
1412 my $d = dirname($file);
1413 my $f = basename($file);
1415 # Make sure the directories we're building in exists
1418 my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
1419 #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1423 # Store the name of the template file we will build the build file from
1424 # in %config. This may be useful for the build file itself.
1425 my @build_file_template_names =
1426 ( $builder_platform."-".$target{build_file}.".tmpl",
1427 $target{build_file}.".tmpl" );
1428 my @build_file_templates = ();
1430 # First, look in the user provided directory, if given
1431 if (defined $ENV{$local_config_envname}) {
1432 @build_file_templates =
1435 # VMS environment variables are logical names,
1436 # which can be used as is
1437 $local_config_envname . ':' . $_;
1439 catfile($ENV{$local_config_envname}, $_);
1442 @build_file_template_names;
1444 # Then, look in our standard directory
1445 push @build_file_templates,
1446 ( map { cleanfile($srcdir, catfile("Configurations", $_), $blddir) }
1447 @build_file_template_names );
1449 my $build_file_template;
1450 for $_ (@build_file_templates) {
1451 $build_file_template = $_;
1452 last if -f $build_file_template;
1454 $build_file_template = undef;
1456 if (!defined $build_file_template) {
1457 die "*** Couldn't find any of:\n", join("\n", @build_file_templates), "\n";
1459 $config{build_file_templates}
1460 = [ $build_file_template,
1461 cleanfile($srcdir, catfile("Configurations", "common.tmpl"),
1464 my @build_infos = ( [ ".", "build.info" ] );
1465 foreach (@{$config{dirs}}) {
1466 push @build_infos, [ $_, "build.info" ]
1467 if (-f catfile($srcdir, $_, "build.info"));
1469 foreach (@{$config{sdirs}}) {
1470 push @build_infos, [ catdir("crypto", $_), "build.info" ]
1471 if (-f catfile($srcdir, "crypto", $_, "build.info"));
1473 foreach (@{$config{engdirs}}) {
1474 push @build_infos, [ catdir("engines", $_), "build.info" ]
1475 if (-f catfile($srcdir, "engines", $_, "build.info"));
1477 foreach (@{$config{tdirs}}) {
1478 push @build_infos, [ catdir("test", $_), "build.info" ]
1479 if (-f catfile($srcdir, "test", $_, "build.info"));
1482 $config{build_infos} = [ ];
1484 foreach (@build_infos) {
1485 my $sourced = catdir($srcdir, $_->[0]);
1486 my $buildd = catdir($blddir, $_->[0]);
1491 # The basic things we're trying to build
1493 my @programs_install = ();
1495 my @libraries_install = ();
1497 my @engines_install = ();
1499 my @scripts_install = ();
1502 my @intermediates = ();
1507 my %shared_sources = ();
1511 my %sharednames = ();
1514 push @{$config{build_infos}}, catfile(abs2rel($sourced, $blddir), $f);
1515 my $template = Text::Template->new(TYPE => 'FILE',
1516 SOURCE => catfile($sourced, $f));
1517 die "Something went wrong with $sourced/$f: $!\n" unless $template;
1520 $template->fill_in(HASH => { config => \%config,
1522 disabled => \%disabled,
1523 withargs => \%withargs,
1524 builddir => abs2rel($buildd, $blddir),
1525 sourcedir => abs2rel($sourced, $blddir),
1526 buildtop => abs2rel($blddir, $blddir),
1527 sourcetop => abs2rel($srcdir, $blddir) },
1528 DELIMITERS => [ "{-", "-}" ]);
1530 # The top item of this stack has the following values
1531 # -2 positive already run and we found ELSE (following ELSIF should fail)
1532 # -1 positive already run (skip until ENDIF)
1533 # 0 negatives so far (if we're at a condition, check it)
1534 # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
1535 # 2 positive ELSE (following ELSIF should fail)
1537 collect_information(
1538 collect_from_array([ @text ],
1539 qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
1540 $l1 =~ s/\\$//; $l1.$l2 }),
1541 # Info we're looking for
1542 qr/^\s*IF\[((?:\\.|[^\\\]])*)\]\s*$/
1544 if (! @skip || $skip[$#skip] > 0) {
1550 qr/^\s*ELSIF\[((?:\\.|[^\\\]])*)\]\s*$/
1551 => sub { die "ELSIF out of scope" if ! @skip;
1552 die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
1553 $skip[$#skip] = -1 if $skip[$#skip] != 0;
1554 $skip[$#skip] = !! $1
1555 if $skip[$#skip] == 0; },
1557 => sub { die "ELSE out of scope" if ! @skip;
1558 $skip[$#skip] = -2 if $skip[$#skip] != 0;
1559 $skip[$#skip] = 2 if $skip[$#skip] == 0; },
1561 => sub { die "ENDIF out of scope" if ! @skip;
1563 qr/^\s*PROGRAMS(_NO_INST)?\s*=\s*(.*)\s*$/
1565 if (!@skip || $skip[$#skip] > 0) {
1567 my @x = tokenize($2);
1569 push @programs_install, @x unless $install;
1572 qr/^\s*LIBS(_NO_INST)?\s*=\s*(.*)\s*$/
1574 if (!@skip || $skip[$#skip] > 0) {
1576 my @x = tokenize($2);
1577 push @libraries, @x;
1578 push @libraries_install, @x unless $install;
1581 qr/^\s*ENGINES(_NO_INST)?\s*=\s*(.*)\s*$/
1583 if (!@skip || $skip[$#skip] > 0) {
1585 my @x = tokenize($2);
1587 push @engines_install, @x unless $install;
1590 qr/^\s*SCRIPTS(_NO_INST)?\s*=\s*(.*)\s*$/
1592 if (!@skip || $skip[$#skip] > 0) {
1594 my @x = tokenize($2);
1596 push @scripts_install, @x unless $install;
1599 qr/^\s*EXTRA\s*=\s*(.*)\s*$/
1600 => sub { push @extra, tokenize($1)
1601 if !@skip || $skip[$#skip] > 0 },
1602 qr/^\s*OVERRIDES\s*=\s*(.*)\s*$/
1603 => sub { push @overrides, tokenize($1)
1604 if !@skip || $skip[$#skip] > 0 },
1606 qr/^\s*ORDINALS\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/,
1607 => sub { push @{$ordinals{$1}}, tokenize($2)
1608 if !@skip || $skip[$#skip] > 0 },
1609 qr/^\s*SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1610 => sub { push @{$sources{$1}}, tokenize($2)
1611 if !@skip || $skip[$#skip] > 0 },
1612 qr/^\s*SHARED_SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1613 => sub { push @{$shared_sources{$1}}, tokenize($2)
1614 if !@skip || $skip[$#skip] > 0 },
1615 qr/^\s*INCLUDE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1616 => sub { push @{$includes{$1}}, tokenize($2)
1617 if !@skip || $skip[$#skip] > 0 },
1618 qr/^\s*DEPEND\[((?:\\.|[^\\\]])*)\]\s*=\s*(.*)\s*$/
1619 => sub { push @{$depends{$1}}, tokenize($2)
1620 if !@skip || $skip[$#skip] > 0 },
1621 qr/^\s*GENERATE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1622 => sub { push @{$generate{$1}}, $2
1623 if !@skip || $skip[$#skip] > 0 },
1624 qr/^\s*RENAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1625 => sub { push @{$renames{$1}}, tokenize($2)
1626 if !@skip || $skip[$#skip] > 0 },
1627 qr/^\s*SHARED_NAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1628 => sub { push @{$sharednames{$1}}, tokenize($2)
1629 if !@skip || $skip[$#skip] > 0 },
1630 qr/^\s*BEGINRAW\[((?:\\.|[^\\\]])+)\]\s*$/
1632 my $lineiterator = shift;
1633 my $target_kind = $1;
1634 while (defined $lineiterator->()) {
1636 if (/^\s*ENDRAW\[((?:\\.|[^\\\]])+)\]\s*$/) {
1637 die "ENDRAW doesn't match BEGINRAW"
1638 if $1 ne $target_kind;
1641 next if @skip && $skip[$#skip] <= 0;
1643 if ($target_kind eq $target{build_file}
1644 || $target_kind eq $target{build_file}."(".$builder_platform.")");
1647 qr/^\s*(?:#.*)?$/ => sub { },
1648 "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" },
1650 if ($buildinfo_debug) {
1651 print STDERR "DEBUG: Parsing ",join(" ", @_),"\n";
1652 print STDERR "DEBUG: ... before parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1656 if ($buildinfo_debug) {
1657 print STDERR "DEBUG: .... after parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1661 die "runaway IF?" if (@skip);
1663 foreach (keys %renames) {
1664 die "$_ renamed to more than one thing: "
1665 ,join(" ", @{$renames{$_}}),"\n"
1666 if scalar @{$renames{$_}} > 1;
1667 my $dest = cleanfile($buildd, $_, $blddir);
1668 my $to = cleanfile($buildd, $renames{$_}->[0], $blddir);
1669 die "$dest renamed to more than one thing: "
1670 ,$unified_info{rename}->{$dest}, $to
1671 unless !defined($unified_info{rename}->{$dest})
1672 or $unified_info{rename}->{$dest} eq $to;
1673 $unified_info{rename}->{$dest} = $to;
1676 foreach (@programs) {
1677 my $program = cleanfile($buildd, $_, $blddir);
1678 if ($unified_info{rename}->{$program}) {
1679 $program = $unified_info{rename}->{$program};
1681 $unified_info{programs}->{$program} = 1;
1684 foreach (@programs_install) {
1685 my $program = cleanfile($buildd, $_, $blddir);
1686 if ($unified_info{rename}->{$program}) {
1687 $program = $unified_info{rename}->{$program};
1689 $unified_info{install}->{programs}->{$program} = 1;
1692 foreach (@libraries) {
1693 my $library = cleanfile($buildd, $_, $blddir);
1694 if ($unified_info{rename}->{$library}) {
1695 $library = $unified_info{rename}->{$library};
1697 $unified_info{libraries}->{$library} = 1;
1700 foreach (@libraries_install) {
1701 my $library = cleanfile($buildd, $_, $blddir);
1702 if ($unified_info{rename}->{$library}) {
1703 $library = $unified_info{rename}->{$library};
1705 $unified_info{install}->{libraries}->{$library} = 1;
1708 die <<"EOF" if scalar @engines and !$config{dynamic_engines};
1709 ENGINES can only be used if configured with 'dynamic-engine'.
1710 This is usually a fault in a build.info file.
1712 foreach (@engines) {
1713 my $library = cleanfile($buildd, $_, $blddir);
1714 if ($unified_info{rename}->{$library}) {
1715 $library = $unified_info{rename}->{$library};
1717 $unified_info{engines}->{$library} = 1;
1720 foreach (@engines_install) {
1721 my $library = cleanfile($buildd, $_, $blddir);
1722 if ($unified_info{rename}->{$library}) {
1723 $library = $unified_info{rename}->{$library};
1725 $unified_info{install}->{engines}->{$library} = 1;
1728 foreach (@scripts) {
1729 my $script = cleanfile($buildd, $_, $blddir);
1730 if ($unified_info{rename}->{$script}) {
1731 $script = $unified_info{rename}->{$script};
1733 $unified_info{scripts}->{$script} = 1;
1736 foreach (@scripts_install) {
1737 my $script = cleanfile($buildd, $_, $blddir);
1738 if ($unified_info{rename}->{$script}) {
1739 $script = $unified_info{rename}->{$script};
1741 $unified_info{install}->{scripts}->{$script} = 1;
1745 my $extra = cleanfile($buildd, $_, $blddir);
1746 $unified_info{extra}->{$extra} = 1;
1749 foreach (@overrides) {
1750 my $override = cleanfile($buildd, $_, $blddir);
1751 $unified_info{overrides}->{$override} = 1;
1754 push @{$unified_info{rawlines}}, @rawlines;
1756 unless ($disabled{shared}) {
1757 # Check sharednames.
1758 foreach (keys %sharednames) {
1759 my $dest = cleanfile($buildd, $_, $blddir);
1760 if ($unified_info{rename}->{$dest}) {
1761 $dest = $unified_info{rename}->{$dest};
1763 die "shared_name for $dest with multiple values: "
1764 ,join(" ", @{$sharednames{$_}}),"\n"
1765 if scalar @{$sharednames{$_}} > 1;
1766 my $to = cleanfile($buildd, $sharednames{$_}->[0], $blddir);
1767 die "shared_name found for a library $dest that isn't defined\n"
1768 unless $unified_info{libraries}->{$dest};
1769 die "shared_name for $dest with multiple values: "
1770 ,$unified_info{sharednames}->{$dest}, ", ", $to
1771 unless !defined($unified_info{sharednames}->{$dest})
1772 or $unified_info{sharednames}->{$dest} eq $to;
1773 $unified_info{sharednames}->{$dest} = $to;
1776 # Additionally, we set up sharednames for libraries that don't
1777 # have any, as themselves. Only for libraries that aren't
1778 # explicitely static.
1779 foreach (grep !/\.a$/, keys %{$unified_info{libraries}}) {
1780 if (!defined $unified_info{sharednames}->{$_}) {
1781 $unified_info{sharednames}->{$_} = $_
1785 # Check that we haven't defined any library as both shared and
1786 # explicitely static. That is forbidden.
1788 foreach (grep /\.a$/, keys %{$unified_info{libraries}}) {
1789 (my $l = $_) =~ s/\.a$//;
1790 push @doubles, $l if defined $unified_info{sharednames}->{$l};
1792 die "these libraries are both explicitely static and shared:\n ",
1793 join(" ", @doubles), "\n"
1797 foreach (keys %ordinals) {
1799 my $ddest = cleanfile($buildd, $_, $blddir);
1800 if ($unified_info{rename}->{$ddest}) {
1801 $ddest = $unified_info{rename}->{$ddest};
1803 foreach (@{$ordinals{$dest}}) {
1804 my %known_ordinals =
1807 cleanfile($sourced, catfile("util", "libcrypto.num"), $blddir),
1809 cleanfile($sourced, catfile("util", "libssl.num"), $blddir)
1811 my $o = $known_ordinals{$_};
1812 die "Ordinals for $ddest defined more than once\n"
1813 if $unified_info{ordinals}->{$ddest};
1814 $unified_info{ordinals}->{$ddest} = [ $_, $o ];
1818 foreach (keys %sources) {
1820 my $ddest = cleanfile($buildd, $_, $blddir);
1821 if ($unified_info{rename}->{$ddest}) {
1822 $ddest = $unified_info{rename}->{$ddest};
1824 foreach (@{$sources{$dest}}) {
1825 my $s = cleanfile($sourced, $_, $blddir);
1827 # If it isn't in the source tree, we assume it's generated
1830 $s = cleanfile($buildd, $_, $blddir);
1832 # We recognise C++, C and asm files
1833 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
1835 $o =~ s/\.[csS]$/.o/; # C and assembler
1836 $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
1837 $o = cleanfile($buildd, $o, $blddir);
1838 $unified_info{sources}->{$ddest}->{$o} = 1;
1839 $unified_info{sources}->{$o}->{$s} = 1;
1841 $unified_info{sources}->{$ddest}->{$s} = 1;
1846 foreach (keys %shared_sources) {
1848 my $ddest = cleanfile($buildd, $_, $blddir);
1849 if ($unified_info{rename}->{$ddest}) {
1850 $ddest = $unified_info{rename}->{$ddest};
1852 foreach (@{$shared_sources{$dest}}) {
1853 my $s = cleanfile($sourced, $_, $blddir);
1855 # If it isn't in the source tree, we assume it's generated
1858 $s = cleanfile($buildd, $_, $blddir);
1860 # We recognise C++, C and asm files
1861 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
1863 $o =~ s/\.[csS]$/.o/; # C and assembler
1864 $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
1865 $o = cleanfile($buildd, $o, $blddir);
1866 $unified_info{shared_sources}->{$ddest}->{$o} = 1;
1867 $unified_info{sources}->{$o}->{$s} = 1;
1869 die "unrecognised source file type for shared library: $s\n";
1874 foreach (keys %generate) {
1876 my $ddest = cleanfile($buildd, $_, $blddir);
1877 if ($unified_info{rename}->{$ddest}) {
1878 $ddest = $unified_info{rename}->{$ddest};
1880 die "more than one generator for $dest: "
1881 ,join(" ", @{$generate{$_}}),"\n"
1882 if scalar @{$generate{$_}} > 1;
1883 my @generator = split /\s+/, $generate{$dest}->[0];
1884 $generator[0] = cleanfile($sourced, $generator[0], $blddir),
1885 $unified_info{generate}->{$ddest} = [ @generator ];
1888 foreach (keys %depends) {
1890 my $ddest = $dest eq "" ? "" : cleanfile($sourced, $_, $blddir);
1892 # If the destination doesn't exist in source, it can only be
1893 # a generated file in the build tree.
1894 if ($ddest ne "" && ! -f $ddest) {
1895 $ddest = cleanfile($buildd, $_, $blddir);
1896 if ($unified_info{rename}->{$ddest}) {
1897 $ddest = $unified_info{rename}->{$ddest};
1900 foreach (@{$depends{$dest}}) {
1901 my $d = cleanfile($sourced, $_, $blddir);
1903 # If we know it's generated, or assume it is because we can't
1904 # find it in the source tree, we set file we depend on to be
1905 # in the build tree rather than the source tree, and assume
1906 # and that there are lines to build it in a BEGINRAW..ENDRAW
1907 # section or in the Makefile template.
1909 || (grep { $d eq $_ }
1910 map { cleanfile($srcdir, $_, $blddir) }
1911 grep { /\.h$/ } keys %{$unified_info{generate}})) {
1912 $d = cleanfile($buildd, $_, $blddir);
1914 # Take note if the file to depend on is being renamed
1915 # Take extra care with files ending with .a, they should
1916 # be treated without that extension, and the extension
1917 # should be added back after treatment.
1921 if ($unified_info{rename}->{$d}) {
1922 $d = $unified_info{rename}->{$d};
1925 $unified_info{depends}->{$ddest}->{$d} = 1;
1926 # If we depend on a header file or a perl module, let's make
1927 # sure it can get included
1928 if ($dest ne "" && $d =~ /\.(h|pm)$/) {
1929 my $i = dirname($d);
1930 push @{$unified_info{includes}->{$ddest}->{source}}, $i
1931 unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}->{source}};
1936 foreach (keys %includes) {
1938 my $ddest = cleanfile($sourced, $_, $blddir);
1940 # If the destination doesn't exist in source, it can only be
1941 # a generated file in the build tree.
1943 $ddest = cleanfile($buildd, $_, $blddir);
1944 if ($unified_info{rename}->{$ddest}) {
1945 $ddest = $unified_info{rename}->{$ddest};
1948 foreach (@{$includes{$dest}}) {
1949 my $is = cleandir($sourced, $_, $blddir);
1950 my $ib = cleandir($buildd, $_, $blddir);
1951 push @{$unified_info{includes}->{$ddest}->{source}}, $is
1952 unless grep { $_ eq $is } @{$unified_info{includes}->{$ddest}->{source}};
1953 push @{$unified_info{includes}->{$ddest}->{build}}, $ib
1954 unless grep { $_ eq $ib } @{$unified_info{includes}->{$ddest}->{build}};
1959 ### Make unified_info a bit more efficient
1960 # One level structures
1961 foreach (("programs", "libraries", "engines", "scripts", "extra", "overrides")) {
1962 $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
1964 # Two level structures
1965 foreach my $l1 (("install", "sources", "shared_sources", "ldadd", "depends")) {
1966 foreach my $l2 (sort keys %{$unified_info{$l1}}) {
1967 $unified_info{$l1}->{$l2} =
1968 [ sort keys %{$unified_info{$l1}->{$l2}} ];
1972 foreach my $dest (sort keys %{$unified_info{includes}}) {
1973 if (defined($unified_info{includes}->{$dest}->{build})) {
1974 my @source_includes =
1975 ( @{$unified_info{includes}->{$dest}->{source}} );
1976 $unified_info{includes}->{$dest} =
1977 [ @{$unified_info{includes}->{$dest}->{build}} ];
1978 foreach my $inc (@source_includes) {
1979 push @{$unified_info{includes}->{$dest}}, $inc
1980 unless grep { $_ eq $inc } @{$unified_info{includes}->{$dest}};
1983 $unified_info{includes}->{$dest} =
1984 [ @{$unified_info{includes}->{$dest}->{source}} ];
1989 # For the schemes that need it, we provide the old *_obj configs
1990 # from the *_asm_obj ones
1991 foreach (grep /_(asm|aux)_src$/, keys %target) {
1993 (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
1994 $target{$obj} = $target{$src};
1995 $target{$obj} =~ s/\.[csS]\b/.o/g; # C and assembler
1996 $target{$obj} =~ s/\.(cc|cpp)\b/_cc.o/g; # C++
1999 # Write down our configuration where it fits #########################
2001 open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
2009 #use vars qw(\@ISA \@EXPORT);
2010 our \@ISA = qw(Exporter);
2011 our \@EXPORT = qw(\%config \%target \%disabled \%withargs \%unified_info \@disablables);
2014 print OUT "our %config = (\n";
2015 foreach (sort keys %config) {
2016 if (ref($config{$_}) eq "ARRAY") {
2017 print OUT " ", $_, " => [ ", join(", ",
2018 map { quotify("perl", $_) }
2019 @{$config{$_}}), " ],\n";
2021 print OUT " ", $_, " => ", quotify("perl", $config{$_}), ",\n"
2028 print OUT "our %target = (\n";
2029 foreach (sort keys %target) {
2030 if (ref($target{$_}) eq "ARRAY") {
2031 print OUT " ", $_, " => [ ", join(", ",
2032 map { quotify("perl", $_) }
2033 @{$target{$_}}), " ],\n";
2035 print OUT " ", $_, " => ", quotify("perl", $target{$_}), ",\n"
2042 print OUT "our \%available_protocols = (\n";
2043 print OUT " tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n";
2044 print OUT " dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n";
2049 print OUT "our \@disablables = (\n";
2050 foreach (@disablables) {
2051 print OUT " ", quotify("perl", $_), ",\n";
2057 print OUT "our \%disabled = (\n";
2058 foreach (sort keys %disabled) {
2059 print OUT " ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n";
2065 print OUT "our %withargs = (\n";
2066 foreach (sort keys %withargs) {
2067 if (ref($withargs{$_}) eq "ARRAY") {
2068 print OUT " ", $_, " => [ ", join(", ",
2069 map { quotify("perl", $_) }
2070 @{$withargs{$_}}), " ],\n";
2072 print OUT " ", $_, " => ", quotify("perl", $withargs{$_}), ",\n"
2079 if ($builder eq "unified") {
2084 if (ref $_ eq "ARRAY") {
2085 print OUT " "x$indent, "[\n";
2087 $recurse->($indent + 4, $_);
2089 print OUT " "x$indent, "],\n";
2090 } elsif (ref $_ eq "HASH") {
2092 print OUT " "x$indent, "{\n";
2093 foreach (sort keys %h) {
2094 if (ref $h{$_} eq "") {
2095 print OUT " "x($indent + 4), quotify("perl", $_), " => ", quotify("perl", $h{$_}), ",\n";
2097 print OUT " "x($indent + 4), quotify("perl", $_), " =>\n";
2098 $recurse->($indent + 8, $h{$_});
2101 print OUT " "x$indent, "},\n";
2103 print OUT " "x$indent, quotify("perl", $_), ",\n";
2107 print OUT "our %unified_info = (\n";
2108 foreach (sort keys %unified_info) {
2109 if (ref $unified_info{$_} eq "") {
2110 print OUT " "x4, quotify("perl", $_), " => ", quotify("perl", $unified_info{$_}), ",\n";
2112 print OUT " "x4, quotify("perl", $_), " =>\n";
2113 $recurse->(8, $unified_info{$_});
2125 print "PROCESSOR =$config{processor}\n" if $config{processor};
2126 print "PERL =$config{perl}\n";
2127 print "PERLVERSION =$Config{version} for $Config{archname}\n";
2128 print "HASHBANGPERL =$config{hashbangperl}\n";
2129 print "CC =$config{cross_compile_prefix}$target{cc}\n";
2130 print "CFLAG =$target{cflags} $config{cflags}\n";
2131 print "CXX =$config{cross_compile_prefix}$target{cxx}\n"
2132 if defined $target{cxx};
2133 print "CXXFLAG =$target{cxxflags} $config{cxxflags}\n"
2134 if defined $target{cxx};
2135 print "DEFINES =",join(" ", @{$target{defines}}, @{$config{defines}}),"\n";
2136 #print "RANLIB =", $target{ranlib} eq '$(CROSS_COMPILE)ranlib' ?
2137 # "$config{cross_compile_prefix}ranlib" :
2138 # "$target{ranlib}", "\n";
2139 print "EX_LIBS =$target{ex_libs} $config{ex_libs}\n";
2143 run_dofile(catfile($blddir, $target{build_file}),
2144 @{$config{build_file_templates}});
2148 $builders{$builder}->($builder_platform, @builder_opts);
2150 print <<"EOF" if ($disabled{threads} eq "unavailable");
2152 The library could not be configured for supporting multi-threaded
2153 applications as the compiler options required on this system are not known.
2154 See file INSTALL for details if you need multi-threading.
2157 print <<"EOF" if ($no_shared_warn);
2159 The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
2160 platform, so we will pretend you gave the option 'no-pic', which also disables
2161 'shared' and 'dynamic-engine'. If you know how to implement shared libraries
2162 or position independent code, please let us know (but please first make sure
2163 you have tried with a current version of OpenSSL).
2166 print <<"EOF" if (-f catfile($srcdir, "configdata.pm") && $srcdir ne $blddir);
2168 WARNING: there are indications that another build was made in the source
2169 directory. This build may have picked up artifacts from that build, the
2170 safest course of action is to clean the source directory and redo this
2176 ######################################################################
2178 # Helpers and utility functions
2181 # Configuration file reading #########################################
2183 # Note: All of the helper functions are for lazy evaluation. They all
2184 # return a CODE ref, which will return the intended value when evaluated.
2185 # Thus, whenever there's mention of a returned value, it's about that
2188 # Helper function to implement conditional inheritance depending on the
2189 # value of $disabled{asm}. Used in inherit_from values as follows:
2191 # inherit_from => [ "template", asm("asm_tmpl") ]
2196 $disabled{asm} ? () : @x;
2200 # Helper function to implement conditional value variants, with a default
2201 # plus additional values based on the value of $config{build_type}.
2202 # Arguments are given in hash table form:
2204 # picker(default => "Basic string: ",
2206 # release => "release")
2208 # When configuring with --debug, the resulting string will be
2209 # "Basic string: debug", and when not, it will be "Basic string: release"
2211 # This can be used to create variants of sets of flags according to the
2214 # cflags => picker(default => "-Wall",
2215 # debug => "-g -O0",
2220 return sub { add($opts{default} || (),
2221 $opts{$config{build_type}} || ())->(); }
2224 # Helper function to combine several values of different types into one.
2225 # This is useful if you want to combine a string with the result of a
2226 # lazy function, such as:
2228 # cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
2232 return sub { add(@stuff)->(); }
2235 # Helper function to implement conditional values depending on the value
2236 # of $disabled{threads}. Can be used as follows:
2238 # cflags => combine("-Wall", threads("-pthread"))
2242 return sub { add($disabled{threads} ? () : @flags)->(); }
2247 our $add_called = 0;
2248 # Helper function to implement adding values to already existing configuration
2249 # values. It handles elements that are ARRAYs, CODEs and scalars
2251 my $separator = shift;
2253 # If there's any ARRAY in the collection of values OR the separator
2254 # is undef, we will return an ARRAY of combined values, otherwise a
2255 # string of joined values with $separator as the separator.
2256 my $found_array = !defined($separator);
2261 while (ref($res) eq "CODE") {
2264 if (defined($res)) {
2265 if (ref($res) eq "ARRAY") {
2281 join($separator, grep { defined($_) && $_ ne "" } @values);
2285 my $separator = " ";
2286 if (ref($_[$#_]) eq "HASH") {
2288 $separator = $opts->{separator};
2291 sub { _add($separator, @x, @_) };
2294 my $separator = " ";
2295 if (ref($_[$#_]) eq "HASH") {
2297 $separator = $opts->{separator};
2300 sub { _add($separator, @_, @x) };
2303 # configuration reader, evaluates the input file as a perl script and expects
2304 # it to fill %targets with target configurations. Those are then added to
2308 open(CONFFILE, "< $fname")
2309 or die "Can't open configuration file '$fname'!\n";
2312 my $content = <CONFFILE>;
2317 # Protect certain tables from tampering
2318 local %table = %::table;
2324 # For each target, check that it's configured with a hash table.
2325 foreach (keys %targets) {
2326 if (ref($targets{$_}) ne "HASH") {
2327 if (ref($targets{$_}) eq "") {
2328 warn "Deprecated target configuration for $_, ignoring...\n";
2330 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
2332 delete $targets{$_};
2334 $targets{$_}->{_conf_fname_int} = add([ $fname ]);
2338 %table = (%table, %targets);
2342 # configuration resolver. Will only resolve all the lazy evaluation
2343 # codeblocks for the chosen target and all those it inherits from,
2345 sub resolve_config {
2347 my @breadcrumbs = @_;
2349 # my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
2351 if (grep { $_ eq $target } @breadcrumbs) {
2352 die "inherit_from loop! target backtrace:\n "
2353 ,$target,"\n ",join("\n ", @breadcrumbs),"\n";
2356 if (!defined($table{$target})) {
2357 warn "Warning! target $target doesn't exist!\n";
2360 # Recurse through all inheritances. They will be resolved on the
2361 # fly, so when this operation is done, they will all just be a
2362 # bunch of attributes with string values.
2363 # What we get here, though, are keys with references to lists of
2364 # the combined values of them all. We will deal with lists after
2365 # this stage is done.
2366 my %combined_inheritance = ();
2367 if ($table{$target}->{inherit_from}) {
2369 map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
2370 foreach (@inherit_from) {
2371 my %inherited_config = resolve_config($_, $target, @breadcrumbs);
2373 # 'template' is a marker that's considered private to
2374 # the config that had it.
2375 delete $inherited_config{template};
2377 foreach (keys %inherited_config) {
2378 if (!$combined_inheritance{$_}) {
2379 $combined_inheritance{$_} = [];
2381 push @{$combined_inheritance{$_}}, $inherited_config{$_};
2386 # We won't need inherit_from in this target any more, since we've
2387 # resolved all the inheritances that lead to this
2388 delete $table{$target}->{inherit_from};
2390 # Now is the time to deal with those lists. Here's the place to
2391 # decide what shall be done with those lists, all based on the
2392 # values of the target we're currently dealing with.
2393 # - If a value is a coderef, it will be executed with the list of
2394 # inherited values as arguments.
2395 # - If the corresponding key doesn't have a value at all or is the
2396 # empty string, the inherited value list will be run through the
2397 # default combiner (below), and the result becomes this target's
2399 # - Otherwise, this target's value is assumed to be a string that
2400 # will simply override the inherited list of values.
2401 my $default_combiner = add();
2404 map { $_ => 1 } (keys %combined_inheritance,
2405 keys %{$table{$target}});
2407 sub process_values {
2409 my $inherited = shift; # Always a [ list ]
2415 while(ref($object) eq "CODE") {
2416 $object = $object->(@$inherited);
2418 if (!defined($object)) {
2421 elsif (ref($object) eq "ARRAY") {
2422 local $add_called; # To make sure recursive calls don't affect it
2423 return [ map { process_values($_, $inherited, $target, $entry) }
2425 } elsif (ref($object) eq "") {
2428 die "cannot handle reference type ",ref($object)
2429 ," found in target ",$target," -> ",$entry,"\n";
2433 foreach (sort keys %all_keys) {
2434 my $previous = $combined_inheritance{$_};
2436 # Current target doesn't have a value for the current key?
2437 # Assign it the default combiner, the rest of this loop body
2438 # will handle it just like any other coderef.
2439 if (!exists $table{$target}->{$_}) {
2440 $table{$target}->{$_} = $default_combiner;
2443 $table{$target}->{$_} = process_values($table{$target}->{$_},
2444 $combined_inheritance{$_},
2446 unless(defined($table{$target}->{$_})) {
2447 delete $table{$target}->{$_};
2449 # if ($extra_checks &&
2450 # $previous && !($add_called || $previous ~~ $table{$target}->{$_})) {
2451 # warn "$_ got replaced in $target\n";
2455 # Finally done, return the result.
2456 return %{$table{$target}};
2461 print STDERR $usage;
2462 print STDERR "\npick os/compiler from:\n";
2466 foreach $i (sort keys %table)
2468 next if $table{$i}->{template};
2469 next if $i =~ /^debug/;
2470 $k += length($i) + 1;
2476 print STDERR $i . " ";
2478 foreach $i (sort keys %table)
2480 next if $table{$i}->{template};
2481 next if $i !~ /^debug/;
2482 $k += length($i) + 1;
2488 print STDERR $i . " ";
2490 print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
2499 unlink $out || warn "Can't remove $out, $!"
2501 foreach (@templates) {
2502 die "Can't open $_, $!" unless -f $_;
2504 my $perlcmd = (quotify("maybeshell", $config{perl}))[0];
2505 my $cmd = "$perlcmd \"-I.\" \"-Mconfigdata\" \"$dofile\" -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\"";
2506 #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
2509 rename("$out.new", $out) || die "Can't rename $out.new, $!";
2516 if (eval { require IPC::Cmd; 1; }) {
2518 return scalar IPC::Cmd::can_run($name);
2520 # if there is $directories component in splitpath,
2521 # then it's not something to test with $PATH...
2522 return $name if (File::Spec->splitpath($name))[1];
2524 foreach (File::Spec->path()) {
2525 my $fullpath = catfile($_, "$name$target{exe_extension}");
2526 if (-f $fullpath and -x $fullpath) {
2533 # Configuration printer ##############################################
2535 sub print_table_entry
2538 my %target = resolve_config($target);
2541 # Don't print the templates
2542 return if $target{template};
2603 if ($type eq "TABLE") {
2605 print "*** $target\n";
2606 foreach (@sequence) {
2607 if (ref($target{$_}) eq "ARRAY") {
2608 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
2610 printf "\$%-12s = %s\n", $_, $target{$_};
2613 } elsif ($type eq "HASH") {
2615 length((sort { length($a) <=> length($b) } @sequence)[-1]);
2616 print " '$target' => {\n";
2617 foreach (@sequence) {
2619 if (ref($target{$_}) eq "ARRAY") {
2620 print " '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
2622 print " '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
2630 # Utility routines ###################################################
2632 # On VMS, if the given file is a logical name, File::Spec::Functions
2633 # will consider it an absolute path. There are cases when we want a
2634 # purely syntactic check without checking the environment.
2638 # On non-platforms, we just use file_name_is_absolute().
2639 return file_name_is_absolute($file) unless $^O eq "VMS";
2641 # If the file spec includes a device or a directory spec,
2642 # file_name_is_absolute() is perfectly safe.
2643 return file_name_is_absolute($file) if $file =~ m|[:\[]|;
2645 # Here, we know the given file spec isn't absolute
2649 # Makes a directory absolute and cleans out /../ in paths like foo/../bar
2650 # On some platforms, this uses rel2abs(), while on others, realpath() is used.
2651 # realpath() requires that at least all path components except the last is an
2652 # existing directory. On VMS, the last component of the directory spec must
2657 # realpath() is quite buggy on VMS. It uses LIB$FID_TO_NAME, which
2658 # will return the volume name for the device, no matter what. Also,
2659 # it will return an incorrect directory spec if the argument is a
2660 # directory that doesn't exist.
2662 return rel2abs($dir);
2665 # We use realpath() on Unix, since no other will properly clean out
2667 use Cwd qw/realpath/;
2669 return realpath($dir);
2674 perl => sub { my $x = shift;
2675 $x =~ s/([\\\$\@"])/\\$1/g;
2676 return '"'.$x.'"'; },
2677 maybeshell => sub { my $x = shift;
2678 (my $y = $x) =~ s/([\\\"])/\\$1/g;
2679 if ($x ne $y || $x =~ m|\s|) {
2688 defined($processors{$for}) ? $processors{$for} : sub { shift; };
2690 return map { $processor->($_); } @_;
2693 # collect_from_file($filename, $line_concat_cond_re, $line_concat)
2694 # $filename is a file name to read from
2695 # $line_concat_cond_re is a regexp detecting a line continuation ending
2696 # $line_concat is a CODEref that takes care of concatenating two lines
2697 sub collect_from_file {
2698 my $filename = shift;
2699 my $line_concat_cond_re = shift;
2700 my $line_concat = shift;
2702 open my $fh, $filename || die "unable to read $filename: $!\n";
2704 my $saved_line = "";
2708 if (defined $line_concat) {
2709 $_ = $line_concat->($saved_line, $_);
2712 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2718 die "$filename ending with continuation line\n" if $_;
2724 # collect_from_array($array, $line_concat_cond_re, $line_concat)
2725 # $array is an ARRAYref of lines
2726 # $line_concat_cond_re is a regexp detecting a line continuation ending
2727 # $line_concat is a CODEref that takes care of concatenating two lines
2728 sub collect_from_array {
2730 my $line_concat_cond_re = shift;
2731 my $line_concat = shift;
2732 my @array = (@$array);
2735 my $saved_line = "";
2737 while (defined($_ = shift @array)) {
2739 if (defined $line_concat) {
2740 $_ = $line_concat->($saved_line, $_);
2743 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2749 die "input text ending with continuation line\n" if $_;
2754 # collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
2755 # $lineiterator is a CODEref that delivers one line at a time.
2756 # All following arguments are regex/CODEref pairs, where the regexp detects a
2757 # line and the CODEref does something with the result of the regexp.
2758 sub collect_information {
2759 my $lineiterator = shift;
2760 my %collectors = @_;
2762 while(defined($_ = $lineiterator->())) {
2765 if ($collectors{"BEFORE"}) {
2766 $collectors{"BEFORE"}->($_);
2768 foreach my $re (keys %collectors) {
2769 if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
2770 $collectors{$re}->($lineiterator);
2774 if ($collectors{"OTHERWISE"}) {
2775 $collectors{"OTHERWISE"}->($lineiterator, $_)
2776 unless $found || !defined $collectors{"OTHERWISE"};
2778 if ($collectors{"AFTER"}) {
2779 $collectors{"AFTER"}->($_);
2785 # $line is a line of text to split up into tokens
2786 # returns a list of tokens
2788 # Tokens are divided by spaces. If the tokens include spaces, they
2789 # have to be quoted with single or double quotes. Double quotes
2790 # inside a double quoted token must be escaped. Escaping is done
2792 # Basically, the same quoting rules apply for " and ' as in any
2795 my $line = my $debug_line = shift;
2798 while ($line =~ s|^\s+||, $line ne "") {
2800 while ($line ne "" && $line !~ m|^\s|) {
2801 if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
2804 } elsif ($line =~ m/^'([^']*)'/) {
2807 } elsif ($line =~ m/^(\S+)/) {
2812 push @result, $token;
2815 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
2816 print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
2817 print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";