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