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