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