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