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