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