Refactor config - split read_config into read_config and resolve_config
[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;
14
15 # see INSTALL for instructions.
16
17 my $usage="Usage: Configure [no-<cipher> ...] [enable-<cipher> ...] [experimental-<cipher> ...] [-Dxxx] [-lxxx] [-Lxxx] [-fxxx] [-Kxxx] [no-hw-xxx|no-hw] [[no-]threads] [[no-]shared] [[no-]zlib|zlib-dynamic] [no-asm] [no-dso] [no-egd] [sctp] [386] [--prefix=DIR] [--openssldir=OPENSSLDIR] [--with-xxx[=vvv]] [--test-sanity] [--config=FILE] os/compiler[:flags]\n";
18
19 # Options:
20 #
21 # --config      add the given configuration file, which will be read after
22 #               any "Configurations*" files that are found in the same
23 #               directory as this script.
24 # --openssldir  install OpenSSL in OPENSSLDIR (Default: DIR/ssl if the
25 #               --prefix option is given; /usr/local/ssl otherwise)
26 # --prefix      prefix for the OpenSSL include, lib and bin directories
27 #               (Default: the OPENSSLDIR directory)
28 #
29 # --install_prefix  Additional prefix for package builders (empty by
30 #               default).  This needn't be set in advance, you can
31 #               just as well use "make INSTALL_PREFIX=/whatever install".
32 #
33 # --test-sanity Make a number of sanity checks on the data in this file.
34 #               This is a debugging tool for OpenSSL developers.
35 #
36 # --cross-compile-prefix Add specified prefix to binutils components.
37 #
38 # --api         One of 0.9.8, 1.0.0 or 1.1.0.  Do not compile support for
39 #               interfaces deprecated as of the specified OpenSSL version.
40 #
41 # no-hw-xxx     do not compile support for specific crypto hardware.
42 #               Generic OpenSSL-style methods relating to this support
43 #               are always compiled but return NULL if the hardware
44 #               support isn't compiled.
45 # no-hw         do not compile support for any crypto hardware.
46 # [no-]threads  [don't] try to create a library that is suitable for
47 #               multithreaded applications (default is "threads" if we
48 #               know how to do it)
49 # [no-]shared   [don't] try to create shared libraries when supported.
50 # no-asm        do not use assembler
51 # no-dso        do not compile in any native shared-library methods. This
52 #               will ensure that all methods just return NULL.
53 # no-egd        do not compile support for the entropy-gathering daemon APIs
54 # [no-]zlib     [don't] compile support for zlib compression.
55 # zlib-dynamic  Like "zlib", but the zlib library is expected to be a shared
56 #               library and will be loaded in run-time by the OpenSSL library.
57 # sctp          include SCTP support
58 # 386           generate 80386 code
59 # no-sse2       disables IA-32 SSE2 code, above option implies no-sse2
60 # no-<cipher>   build without specified algorithm (rsa, idea, rc5, ...)
61 # -<xxx> +<xxx> compiler options are passed through
62 #
63 # DEBUG_SAFESTACK use type-safe stacks to enforce type-safety on stack items
64 #               provided to stack calls. Generates unique stack functions for
65 #               each possible stack type.
66 # DES_PTR       use pointer lookup vs arrays in the DES in crypto/des/des_locl.h
67 # DES_RISC1     use different DES_ENCRYPT macro that helps reduce register
68 #               dependancies but needs to more registers, good for RISC CPU's
69 # DES_RISC2     A different RISC variant.
70 # DES_UNROLL    unroll the inner DES loop, sometimes helps, somtimes hinders.
71 # DES_INT       use 'int' instead of 'long' for DES_LONG in crypto/des/des.h
72 #               This is used on the DEC Alpha where long is 8 bytes
73 #               and int is 4
74 # BN_LLONG      use the type 'long long' in crypto/bn/bn.h
75 # MD2_CHAR      use 'char' instead of 'int' for MD2_INT in crypto/md2/md2.h
76 # MD2_LONG      use 'long' instead of 'int' for MD2_INT in crypto/md2/md2.h
77 # IDEA_SHORT    use 'short' instead of 'int' for IDEA_INT in crypto/idea/idea.h
78 # IDEA_LONG     use 'long' instead of 'int' for IDEA_INT in crypto/idea/idea.h
79 # RC2_SHORT     use 'short' instead of 'int' for RC2_INT in crypto/rc2/rc2.h
80 # RC2_LONG      use 'long' instead of 'int' for RC2_INT in crypto/rc2/rc2.h
81 # RC4_CHAR      use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
82 # RC4_LONG      use 'long' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
83 # RC4_INDEX     define RC4_INDEX in crypto/rc4/rc4_locl.h.  This turns on
84 #               array lookups instead of pointer use.
85 # RC4_CHUNK     enables code that handles data aligned at long (natural CPU
86 #               word) boundary.
87 # RC4_CHUNK_LL  enables code that handles data aligned at long long boundary
88 #               (intended for 64-bit CPUs running 32-bit OS).
89 # BF_PTR        use 'pointer arithmatic' for Blowfish (unsafe on Alpha).
90 # BF_PTR2       intel specific version (generic version is more efficient).
91 #
92 # Following are set automatically by this script
93 #
94 # MD5_ASM       use some extra md5 assember,
95 # SHA1_ASM      use some extra sha1 assember, must define L_ENDIAN for x86
96 # RMD160_ASM    use some extra ripemd160 assember,
97 # SHA256_ASM    sha256_block is implemented in assembler
98 # SHA512_ASM    sha512_block is implemented in assembler
99 # AES_ASM       ASE_[en|de]crypt is implemented in assembler
100
101 # Minimum warning options... any contributions to OpenSSL should at least get
102 # past these.
103
104 my $gcc_devteam_warn = "-Wall -pedantic -DPEDANTIC -Wno-long-long -Wsign-compare -Wmissing-prototypes -Wshadow -Wformat -Wtype-limits -Werror -DREF_CHECK -DDEBUG_UNUSED";
105
106 # These are used in addition to $gcc_devteam_warn when the compiler is clang.
107 # TODO(openssl-team): fix problems and investigate if (at least) the
108 # following warnings can also be enabled:
109 # -Wswitch-enum, -Wunused-macros, -Wmissing-field-initializers,
110 # -Wcast-align,
111 # -Wunreachable-code -Wunused-parameter -Wlanguage-extension-token
112 # -Wextended-offsetof
113 my $clang_devteam_warn = "-Wno-unused-parameter -Wno-missing-field-initializers -Wno-language-extension-token -Wno-extended-offsetof -Wconditional-uninitialized -Qunused-arguments -Wincompatible-pointer-types-discards-qualifiers -Wmissing-variable-declarations";
114
115 # Warn that "make depend" should be run?
116 my $warn_make_depend = 0;
117
118 # These are used in addition to $gcc_devteam_warn unless this is a mingw build.
119 # This adds backtrace information to the memory leak info.
120 my $memleak_devteam_backtrace = "-rdynamic -DCRYPTO_MDEBUG_BACKTRACE";
121
122
123 my $strict_warnings = 0;
124
125 my $x86_gcc_des="DES_PTR DES_RISC1 DES_UNROLL";
126
127 # MD2_CHAR slags pentium pros
128 my $x86_gcc_opts="RC4_INDEX MD2_INT";
129
130 # As for $BSDthreads. Idea is to maintain "collective" set of flags,
131 # which would cover all BSD flavors. -pthread applies to them all,
132 # but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
133 # -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
134 # which has to be accompanied by explicit -D_THREAD_SAFE and
135 # sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
136 # seems to be sufficient?
137 my $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
138
139 #
140 # API compability name to version number mapping.
141 #
142 my $maxapi = "1.1.0";           # API for "no-deprecated" builds
143 my $apitable = {
144     "1.1.0" => "0x10100000L",
145     "1.0.0" => "0x10000000L",
146     "0.9.8" => "0x00908000L",
147 };
148
149 # table of known configurations, read in from files
150 #
151 # The content of each entry comes in the form of config hash table,
152 # which has additional attributes for debug and non-debug flags to be
153 # added to the common flags, for cflags and lflags:
154 #
155 #       {
156 #         cc => $cc,
157 #         cflags => $cflags,
158 #         debug_cflags => $debug_cflags,
159 #         release_cflags => $release_cflags,
160 #         unistd => $unistd,
161 #         thread_cflag => $thread_cflag,
162 #         sys_id => $sys_id,
163 #         lflags => $lflags,
164 #         debug_lflags => $debug_lflags,
165 #         release_lflags => $release_lflags,
166 #         bn_ops => $bn_ops,
167 #         cpuid_obj => $cpuid_obj,
168 #         bn_obj => $bn_obj,
169 #         ec_obj => $ec_obj,
170 #         des_obj => $des_obj,
171 #         aes_obj => $aes_obj,
172 #         bf_obj => $bf_obj,
173 #         md5_obj => $md5_obj,
174 #         sha1_obj => $sha1_obj,
175 #         cast_obj => $cast_obj,
176 #         rc4_obj => $rc4_obj,
177 #         rmd160_obj => $rmd160_obj,
178 #         rc5_obj => $rc5_obj,
179 #         wp_obj => $wp_obj,
180 #         cmll_obj => $cmll_obj,
181 #         modes_obj => $modes_obj,
182 #         engines_obj => $engines_obj,
183 #         chacha_obj => $wp_obj,
184 #         poly1305_obj => $cmll_obj,
185 #         dso_scheme => $dso_scheme,
186 #         shared_target => $shared_target,
187 #         shared_cflag => $shared_cflag,
188 #         shared_ldflag => $shared_ldflag,
189 #         shared_extension => $shared_extension,
190 #         ranlib => $ranlib,
191 #         arflags => $arflags,
192 #         multilib => $multilib
193 #       }
194 #
195 # The configuration hashes can refer to templates in two different manners:
196 #
197 # - as part of the hash, one can have a key called 'inherit_from' that
198 #   indicate what other configuration hashes to inherit data from.
199 #   These are resolved recursively.
200 #
201 #   Inheritance works as a set of default values that can be overriden
202 #   by corresponding attribute values in the inheriting configuration.
203 #
204 #   If several configurations are given in the 'inherit_from' array, the
205 #   values of same attribute are concatenated with space separation.
206 #   With this, it's possible to have several smaller templates for
207 #   different configuration aspects that can be combined into a complete
208 #   configuration.
209 #
210 #   Example:
211 #
212 #       "foo" => {
213 #               template => 1,
214 #               haha => "haha",
215 #               hoho => "ho"
216 #       },
217 #       "bar" => {
218 #               template => 1,
219 #               hoho => "ho",
220 #               hehe => "hehe"
221 #       },
222 #       "laughter" => {
223 #               inherit_from => [ "foo", "bar" ],
224 #       }
225 #
226 #       The entry for "foo" will become as follows after processing:
227 #
228 #       "laughter" => {
229 #               haha => "haha",
230 #               hoho => "ho ho",
231 #               hehe => "hehe"
232 #       }
233 #
234 #   Note 1: any entry from the table can be used as a template.
235 #   Note 2: pure templates have the attribute 'template => 1' and cannot
236 #           be used as targets.
237 #
238 # - instead of a string, one can have a code block of the form
239 #   'sub { /* your code here */ }', where the arguments are the list of
240 #   inherited values for that key.  In fact, the concatenation of strings
241 #   is really done by using 'sub { join(" ",@_) }' on the list of inherited
242 #   values.
243 #
244 #   Example:
245 #
246 #       "foo" => {
247 #               template => 1,
248 #               haha => "ha ha",
249 #               hoho => "ho",
250 #               ignored => "This should not appear in the end result",
251 #       },
252 #       "bar" => {
253 #               template => 1,
254 #               haha => "ah",
255 #               hoho => "haho",
256 #               hehe => "hehe"
257 #       },
258 #       "laughter" => {
259 #               inherit_from => [ "foo", "bar" ],
260 #               hehe => sub { join(" ",(@_,"!!!")) },
261 #               ignored => "",
262 #       }
263 #
264 #       The entry for "foo" will become as follows after processing:
265 #
266 #       "laughter" => {
267 #               haha => "ha ha ah",
268 #               hoho => "ho haho",
269 #               hehe => "hehe !!!",
270 #               ignored => ""
271 #       }
272 #
273
274 our %table=(
275
276     # All these templates are merely a translation of the corresponding
277     # variables further up.
278     #
279     # Note: as long as someone might use old style configuration strings,
280     # or we bother supporting that, those variables need to stay
281
282     x86_asm => {
283         template        => 1,
284         cpuid_obj       => "x86cpuid.o",
285         bn_obj          => "bn-586.o co-586.o x86-mont.o x86-gf2m.o",
286         ec_obj          => "ecp_nistz256.o ecp_nistz256-x86.o",
287         des_obj         => "des-586.o crypt586.o",
288         aes_obj         => "aes-586.o vpaes-x86.o aesni-x86.o",
289         bf_obj          => "bf-586.o",
290         md5_obj         => "md5-586.o",
291         sha1_obj        => "sha1-586.o sha256-586.o sha512-586.o",
292         rc4_obj         => "rc4-586.o",
293         rmd160_obj      => "rmd-586.o",
294         rc5_obj         => "rc5-586.o",
295         wp_obj          => "wp_block.o wp-mmx.o",
296         cmll_obj        => "cmll-x86.o",
297         modes_obj       => "ghash-x86.o",
298         engines_obj     => "e_padlock-x86.o"
299     },
300     x86_elf_asm => {
301         template        => 1,
302         inherit_from    => [ "x86_asm" ],
303         perlasm_scheme  => "elf"
304     },
305     x86_64_asm => {
306         template        => 1,
307         cpuid_obj       => "x86_64cpuid.o",
308         bn_obj          => "x86_64-gcc.o x86_64-mont.o x86_64-mont5.o x86_64-gf2m.o rsaz_exp.o rsaz-x86_64.o rsaz-avx2.o",
309         ec_obj          => "ecp_nistz256.o ecp_nistz256-x86_64.o",
310         aes_obj         => "aes-x86_64.o vpaes-x86_64.o bsaes-x86_64.o aesni-x86_64.o aesni-sha1-x86_64.o aesni-sha256-x86_64.o aesni-mb-x86_64.o",
311         md5_obj         => "md5-x86_64.o",
312         sha1_obj        => "sha1-x86_64.o sha256-x86_64.o sha512-x86_64.o sha1-mb-x86_64.o sha256-mb-x86_64.o",
313         rc4_obj         => "rc4-x86_64.o rc4-md5-x86_64.o",
314         wp_obj          => "wp-x86_64.o",
315         cmll_obj        => "cmll-x86_64.o cmll_misc.o",
316         modes_obj       => "ghash-x86_64.o aesni-gcm-x86_64.o",
317         engines_obj     => "e_padlock-x86_64.o"
318     },
319     ia64_asm => {
320         template        => 1,
321         cpuid_obj       => "ia64cpuid.o",
322         bn_obj          => "bn-ia64.o ia64-mont.o",
323         aes_obj         => "aes_core.o aes_cbc.o aes-ia64.o",
324         md5_obj         => "md5-ia64.o",
325         sha1_obj        => "sha1-ia64.o sha256-ia64.o sha512-ia64.o",
326         rc4_obj         => "rc4-ia64.o rc4_skey.o",
327         modes_obj       => "ghash-ia64.o",
328         perlasm_scheme  => "void"
329     },
330     sparcv9_asm => {
331         template        => 1,
332         cpuid_obj       => "sparcv9cap.o sparccpuid.o",
333         bn_obj          => "bn-sparcv9.o sparcv9-mont.o sparcv9a-mont.o vis3-mont.o sparct4-mont.o sparcv9-gf2m.o",
334         ec_obj          => "ecp_nistz256.o ecp_nistz256-sparcv9.o",
335         des_obj         => "des_enc-sparc.o fcrypt_b.o dest4-sparcv9.o",
336         aes_obj         => "aes_core.o aes_cbc.o aes-sparcv9.o aest4-sparcv9.o",
337         md5_obj         => "md5-sparcv9.o",
338         sha1_obj        => "sha1-sparcv9.o sha256-sparcv9.o sha512-sparcv9.o",
339         cmll_obj        => "camellia.o cmll_misc.o cmll_cbc.o cmllt4-sparcv9.o",
340         modes_obj       => "ghash-sparcv9.o",
341         perlasm_scheme  => "void"
342     },
343     sparcv8_asm => {
344         template        => 1,
345         cpuid_obj       => "",
346         bn_obj          => "sparcv8.o",
347         des_obj         => "des_enc-sparc.o fcrypt_b.o",
348         perlasm_scheme  => "void"
349     },
350     alpha_asm => {
351         template        => 1,
352         cpuid_obj       => "alphacpuid.o",
353         bn_obj          => "bn_asm.o alpha-mont.o",
354         sha1_obj        => "sha1-alpha.o",
355         modes_obj       => "ghash-alpha.o",
356         perlasm_scheme  => "void"
357     },
358     mips32_asm => {
359         template        => 1,
360         bn_obj          => "bn-mips.o mips-mont.o",
361         aes_obj         => "aes_cbc.o aes-mips.o",
362         sha1_obj        => "sha1-mips.o sha256-mips.o",
363     },
364     mips64_asm => {
365         inherit_from    => [ "mips32_asm" ],
366         template        => 1,
367         sha1_obj        => sub { join(" ", @_, "sha512-mips.o") }
368     },
369     s390x_asm => {
370         template        => 1,
371         cpuid_obj       => "s390xcap.o s390xcpuid.o",
372         bn_obj          => "bn-s390x.o s390x-mont.o s390x-gf2m.o",
373         aes_obj         => "aes-s390x.o aes-ctr.o aes-xts.o",
374         sha1_obj        => "sha1-s390x.o sha256-s390x.o sha512-s390x.o",
375         rc4_obj         => "rc4-s390x.o",
376         modes_obj       => "ghash-s390x.o",
377     },
378     armv4_asm => {
379         template        => 1,
380         cpuid_obj       => "armcap.o armv4cpuid.o",
381         bn_obj          => "bn_asm.o armv4-mont.o armv4-gf2m.o",
382         ec_obj          => "ecp_nistz256.o ecp_nistz256-armv4.o",
383         aes_obj         => "aes_cbc.o aes-armv4.o bsaes-armv7.o aesv8-armx.o",
384         sha1_obj        => "sha1-armv4-large.o sha256-armv4.o sha512-armv4.o",
385         modes_obj       => "ghash-armv4.o ghashv8-armx.o",
386         perlasm_scheme  => "void"
387     },
388     aarch64_asm => {
389         template        => 1,
390         cpuid_obj       => "armcap.o arm64cpuid.o mem_clr.o",
391         ec_obj          => "ecp_nistz256.o ecp_nistz256-armv8.o",
392         bn_obj          => "bn_asm.o armv8-mont.o",
393         aes_obj         => "aes_core.o aes_cbc.o aesv8-armx.o vpaes-armv8.o",
394         sha1_obj        => "sha1-armv8.o sha256-armv8.o sha512-armv8.o",
395         modes_obj       => "ghashv8-armx.o",
396     },
397     parisc11_asm => {
398         template        => 1,
399         cpuid_obj       => "pariscid.o",
400         bn_obj          => "bn_asm.o parisc-mont.o",
401         aes_obj         => "aes_core.o aes_cbc.o aes-parisc.o",
402         sha1_obj        => "sha1-parisc.o sha256-parisc.o sha512-parisc.o",
403         rc4_obj         => "rc4-parisc.o",
404         modes_obj       => "ghash-parisc.o",
405         perlasm_scheme  => "32"
406     },
407     parisc20_64_asm => {
408         template        => 1,
409         inherit_from    => [ "parisc11_asm" ],
410         bn_obj          => sub { my $r=join(" ",@_); $r=~s/bn_asm/pa-risc2W/; $r; },
411         perlasm_scheme  => "64",
412     },
413     ppc64_asm => {
414         template        => 1,
415         cpuid_obj       => "ppccpuid.o ppccap.o",
416         bn_obj          => "bn-ppc.o ppc-mont.o ppc64-mont.o",
417         aes_obj         => "aes_core.o aes_cbc.o aes-ppc.o vpaes-ppc.o aesp8-ppc.o",
418         sha1_obj        => "sha1-ppc.o sha256-ppc.o sha512-ppc.o sha256p8-ppc.o sha512p8-ppc.o",
419         modes_obj       => "ghashp8-ppc.o",
420     },
421     ppc32_asm => {
422         inherit_from    => [ "ppc64_asm" ],
423         template        => 1
424     },
425 );
426
427 # Forward declarations ###############################################
428
429 # read_config(filename)
430 #
431 # Reads a configuration file and populates %table with the contents
432 # (which the configuration file places in %targets).
433 sub read_config;
434
435 # resolve_config(target)
436 #
437 # Resolves all the late evalutations, inheritances and so on for the
438 # chosen target and any target it inherits from.
439 sub resolve_config;
440
441
442 my ($vol, $dir, $dummy) = File::Spec->splitpath($0);
443 my $pattern = File::Spec->catpath($vol, $dir, "Configurations/*.conf");
444 foreach (sort glob($pattern) ) {
445     &read_config($_);
446 }
447
448 my @MK1MF_Builds=qw(VC-WIN64I VC-WIN64A
449                     debug-VC-WIN64I debug-VC-WIN64A
450                     VC-NT VC-CE VC-WIN32 debug-VC-WIN32
451                     BC-32
452                     netware-clib netware-clib-bsdsock
453                     netware-libc netware-libc-bsdsock);
454
455 my $prefix="";
456 my $libdir="";
457 my $openssldir="";
458 my $exe_ext="";
459 my $install_prefix= "$ENV{'INSTALL_PREFIX'}";
460 my $cross_compile_prefix="";
461 my $fipslibdir="/usr/local/ssl/fips-2.0/lib/";
462 my $nofipscanistercheck=0;
463 my $baseaddr="0xFB00000";
464 my $no_threads=0;
465 my $threads=0;
466 my $no_shared=0; # but "no-shared" is default
467 my $zlib=1;      # but "no-zlib" is default
468 my $no_rfc3779=0;
469 my $no_asm=0;
470 my $no_dso=0;
471 my @skip=();
472 my $Makefile="Makefile";
473 my $des_locl="crypto/des/des_locl.h";
474 my $des ="include/openssl/des.h";
475 my $bn  ="include/openssl/bn.h";
476 my $md2 ="include/openssl/md2.h";
477 my $rc4 ="include/openssl/rc4.h";
478 my $rc4_locl="crypto/rc4/rc4_locl.h";
479 my $idea        ="include/openssl/idea.h";
480 my $rc2 ="include/openssl/rc2.h";
481 my $bf  ="crypto/bf/bf_locl.h";
482 my $bn_asm      ="bn_asm.o";
483 my $des_enc="des_enc.o fcrypt_b.o";
484 my $aes_enc="aes_core.o aes_cbc.o";
485 my $bf_enc      ="bf_enc.o";
486 my $cast_enc="c_enc.o";
487 my $rc4_enc="rc4_enc.o rc4_skey.o";
488 my $rc5_enc="rc5_enc.o";
489 my $cmll_enc="camellia.o cmll_misc.o cmll_cbc.o";
490 my $chacha_enc="chacha_enc.o";
491 my $processor="";
492 my $default_ranlib;
493 my $perl;
494 my $fips=0;
495
496 # Known TLS and DTLS protocols
497 my @tls = qw(ssl3 tls1 tls1_1 tls1_2);
498 my @dtls = qw(dtls1 dtls1_2);
499
500 # Explicitelly known options that are possible to disable.  They can
501 # be regexps, and will be used like this: /^no-${option}$/
502 # For developers: keep it sorted alphabetically
503
504 my @disablables = (
505     "aes",
506     "asm",
507     "bf",
508     "camellia",
509     "capieng",
510     "cast",
511     "chacha",
512     "cmac",
513     "cms",
514     "comp",
515     "crypto-mdebug",
516     "ct",
517     "deprecated",
518     "des",
519     "dgram",
520     "dh",
521     "dsa",
522     "dso",
523     "dtls",
524     "dynamic[-_]engine",
525     "ec",
526     "ec2m",
527     "ecdh",
528     "ecdsa",
529     "ec_nistp_64_gcc_128",
530     "engine",
531     "err",                      # Really???
532     "gost",
533     "heartbeats",
534     "hmac",
535     "hw(-.+)?",
536     "idea",
537     "jpake",
538     "locking",                  # Really???
539     "md2",
540     "md4",
541     "md5",
542     "mdc2",
543     "md[-_]ghost94",
544     "nextprotoneg",
545     "ocb",
546     "ocsp",
547     "poly1305",
548     "posix-io",
549     "psk",
550     "rc2",
551     "rc4",
552     "rc5",
553     "rdrand",
554     "rfc3779",
555     "rijndael",                 # Old AES name
556     "rmd160",
557     "rsa",
558     "scrypt",
559     "sct",
560     "sctp",
561     "seed",
562     "sha",
563     "shared",
564     "sock",
565     "srp",
566     "srtp",
567     "sse2",
568     "ssl",
569     "ssl-trace",
570     "static-engine",
571     "stdio",
572     "store",
573     "threads",
574     "tls",
575     "unit-test",
576     "whirlpool",
577     "zlib",
578     "zlib-dynamic",
579     );
580 foreach my $proto ((@tls, @dtls))
581         {
582         push(@disablables, $proto);
583         push(@disablables, "$proto-method");
584         }
585
586 # All of the following is disabled by default (RC5 was enabled before 0.9.8):
587
588 my %disabled = ( # "what"         => "comment" [or special keyword "experimental"]
589                  "ec_nistp_64_gcc_128" => "default",
590                  "egd"            => "default",
591                  "jpake"          => "experimental",
592                  "md2"            => "default",
593                  "rc5"            => "default",
594                  "sctp"           => "default",
595                  "shared"         => "default",
596                  "ssl-trace"      => "default",
597                  "store"          => "experimental",
598                  "unit-test"      => "default",
599                  "zlib"           => "default",
600                  "zlib-dynamic"   => "default",
601                  "crypto-mdebug"  => "default",
602                );
603 my @experimental = ();
604
605 # This is what $depflags will look like with the above defaults
606 # (we need this to see if we should advise the user to run "make depend"):
607 my $default_depflags = " -DOPENSSL_NO_CRYPTO_MDEBUG -DOPENSSL_NO_EC_NISTP_64_GCC_128 -DOPENSSL_NO_JPAKE -DOPENSSL_NO_MD2 -DOPENSSL_NO_RC5 -DOPENSSL_NO_SCTP -DOPENSSL_NO_SSL_TRACE -DOPENSSL_NO_STORE -DOPENSSL_NO_UNIT_TEST";
608
609 # Explicit "no-..." options will be collected in %disabled along with the defaults.
610 # To remove something from %disabled, use "enable-foo" (unless it's experimental).
611 # For symmetry, "disable-foo" is a synonym for "no-foo".
612
613 # For features called "experimental" here, a more explicit "experimental-foo" is needed to enable.
614 # We will collect such requests in @experimental.
615 # To avoid accidental use of experimental features, applications will have to use -DOPENSSL_EXPERIMENTAL_FOO.
616
617
618 my $no_sse2=0;
619
620 &usage if ($#ARGV < 0);
621
622 my $flags;
623 my $depflags;
624 my $openssl_experimental_defines;
625 my $openssl_algorithm_defines;
626 my $openssl_thread_defines;
627 my $openssl_sys_defines="";
628 my $openssl_other_defines;
629 my $libs;
630 my $target;
631 my $options;
632 my $api;
633 my $make_depend=0;
634 my %withargs=();
635 my $build_prefix = "release_";
636
637 my @argvcopy=@ARGV;
638 my $argvstring="";
639 my $argv_unprocessed=1;
640
641 while($argv_unprocessed)
642         {
643         $flags="";
644         $depflags="";
645         $openssl_experimental_defines="";
646         $openssl_algorithm_defines="";
647         $openssl_thread_defines="";
648         $openssl_sys_defines="";
649         $openssl_other_defines="";
650         $libs="";
651         $target="";
652         $options="";
653
654         $argv_unprocessed=0;
655         $argvstring=join(' ',@argvcopy);
656
657 PROCESS_ARGS:
658         {
659         my %unsupported_options = ();
660         foreach (@argvcopy)
661                 {
662                 s /^-no-/no-/; # some people just can't read the instructions
663
664                 # rewrite some options in "enable-..." form
665                 s /^-?-?shared$/enable-shared/;
666                 s /^sctp$/enable-sctp/;
667                 s /^threads$/enable-threads/;
668                 s /^zlib$/enable-zlib/;
669                 s /^zlib-dynamic$/enable-zlib-dynamic/;
670
671                 if (/^(no|disable|enable|experimental)-(.+)$/)
672                         {
673                         my $word = $2;
674                         if (!grep { $word =~ /^${_}$/ } @disablables)
675                                 {
676                                 $unsupported_options{$_} = 1;
677                                 next;
678                                 }
679                         }
680                 if (/^no-(.+)$/ || /^disable-(.+)$/)
681                         {
682                         if (!($disabled{$1} eq "experimental"))
683                                 {
684                                 foreach my $proto ((@tls, @dtls))
685                                         {
686                                         if ($1 eq "$proto-method")
687                                                 {
688                                                 $disabled{"$proto"} = "option($proto-method)";
689                                                 last;
690                                                 }
691                                         }
692                                 if ($1 eq "dtls")
693                                         {
694                                         foreach my $proto (@dtls)
695                                                 {
696                                                 $disabled{$proto} = "option(dtls)";
697                                                 }
698                                         }
699                                 elsif ($1 eq "ssl")
700                                         {
701                                         # Last one of its kind
702                                         $disabled{"ssl3"} = "option(ssl)";
703                                         }
704                                 elsif ($1 eq "tls")
705                                         {
706                                         # XXX: Tests will fail if all SSL/TLS
707                                         # protocols are disabled.
708                                         foreach my $proto (@tls)
709                                                 {
710                                                 $disabled{$proto} = "option(tls)";
711                                                 }
712                                         }
713                                 else
714                                         {
715                                         $disabled{$1} = "option";
716                                         }
717                                 }
718                         }
719                 elsif (/^enable-(.+)$/ || /^experimental-(.+)$/)
720                         {
721                         my $algo = $1;
722                         if ($disabled{$algo} eq "experimental")
723                                 {
724                                 die "You are requesting an experimental feature; please say 'experimental-$algo' if you are sure\n"
725                                         unless (/^experimental-/);
726                                 push @experimental, $algo;
727                                 }
728                         delete $disabled{$algo};
729
730                         $threads = 1 if ($algo eq "threads");
731                         }
732                 elsif (/^--strict-warnings$/)
733                         {
734                         $strict_warnings = 1;
735                         }
736                 elsif (/^--debug$/)
737                         {
738                         $build_prefix = "debug_";
739                         }
740                 elsif (/^--release$/)
741                         {
742                         $build_prefix = "release_";
743                         }
744                 elsif (/^reconfigure/ || /^reconf/)
745                         {
746                         if (open(IN,"<$Makefile"))
747                                 {
748                                 my $config_args_found=0;
749                                 while (<IN>)
750                                         {
751                                         chomp;
752                                         if (/^CONFIGURE_ARGS=(.*)/)
753                                                 {
754                                                 $argvstring=$1;
755                                                 @argvcopy=split(' ',$argvstring);
756                                                 die "Incorrect data to reconfigure, please do a normal configuration\n"
757                                                         if (grep(/^reconf/,@argvcopy));
758                                                 print "Reconfiguring with: $argvstring\n";
759                                                 $argv_unprocessed=1;
760                                                 $config_args_found=1;
761                                                 }
762                                         elsif (/^CROSS_COMPILE=\s*(.*)/)
763                                                 {
764                                                 $ENV{CROSS_COMPILE}=$1;
765                                                 }
766                                         elsif (/^CC=\s*(?:\$\(CROSS_COMPILE\))?(.*?)$/)
767                                                 {
768                                                 $ENV{CC}=$1;
769                                                 }
770                                         }
771                                 close(IN);
772                                 last PROCESS_ARGS if ($config_args_found);
773                                 }
774                         die "Insufficient data to reconfigure, please do a normal configuration\n";
775                         }
776                 elsif (/^386$/)
777                         { $processor=386; }
778                 elsif (/^fips$/)
779                         {
780                         $fips=1;
781                         }
782                 elsif (/^rsaref$/)
783                         {
784                         # No RSAref support any more since it's not needed.
785                         # The check for the option is there so scripts aren't
786                         # broken
787                         }
788                 elsif (/^nofipscanistercheck$/)
789                         {
790                         $fips = 1;
791                         $nofipscanistercheck = 1;
792                         }
793                 elsif (/^[-+]/)
794                         {
795                         if (/^--prefix=(.*)$/)
796                                 {
797                                 $prefix=$1;
798                                 }
799                         elsif (/^--api=(.*)$/)
800                                 {
801                                 $api=$1;
802                                 }
803                         elsif (/^--libdir=(.*)$/)
804                                 {
805                                 $libdir=$1;
806                                 }
807                         elsif (/^--openssldir=(.*)$/)
808                                 {
809                                 $openssldir=$1;
810                                 }
811                         elsif (/^--install.prefix=(.*)$/)
812                                 {
813                                 $install_prefix=$1;
814                                 }
815                         elsif (/^--with-zlib-lib=(.*)$/)
816                                 {
817                                 $withargs{"zlib-lib"}=$1;
818                                 }
819                         elsif (/^--with-zlib-include=(.*)$/)
820                                 {
821                                 $withargs{"zlib-include"}="-I$1";
822                                 }
823                         elsif (/^--with-fipslibdir=(.*)$/)
824                                 {
825                                 $fipslibdir="$1/";
826                                 }
827                         elsif (/^--with-baseaddr=(.*)$/)
828                                 {
829                                 $baseaddr="$1";
830                                 }
831                         elsif (/^--cross-compile-prefix=(.*)$/)
832                                 {
833                                 $cross_compile_prefix=$1;
834                                 }
835                         elsif (/^--config=(.*)$/)
836                                 {
837                                 read_config $1;
838                                 }
839                         elsif (/^-[lL](.*)$/ or /^-Wl,/)
840                                 {
841                                 $libs.=$_." ";
842                                 }
843                         else    # common if (/^[-+]/), just pass down...
844                                 {
845                                 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
846                                 $flags.=$_." ";
847                                 }
848                         }
849                 elsif ($_ =~ /^([^:]+):(.+)$/)
850                         {
851                         eval "\$table{\$1} = \"$2\""; # allow $xxx constructs in the string
852                         $target=$1;
853                         }
854                 else
855                         {
856                         die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
857                         $target=$_;
858                         }
859
860                 unless ($_ eq $target || /^no-/ || /^disable-/)
861                         {
862                         # "no-..." follows later after implied disactivations
863                         # have been derived.  (Don't take this too seroiusly,
864                         # we really only write OPTIONS to the Makefile out of
865                         # nostalgia.)
866
867                         if ($options eq "")
868                                 { $options = $_; }
869                         else
870                                 { $options .= " ".$_; }
871                         }
872                 }
873
874         if (defined($api) && !exists $apitable->{$api}) {
875                 die "***** Unsupported api compatibility level: $api\n",
876         }
877
878         if (keys %unsupported_options)
879                 {
880                 die "***** Unsupported options: ",
881                         join(", ", keys %unsupported_options), "\n";
882                 }
883         }
884         }
885
886
887 if ($processor eq "386")
888         {
889         $disabled{"sse2"} = "forced";
890         }
891
892 if (!defined($disabled{"zlib-dynamic"}))
893         {
894         # "zlib-dynamic" was specifically enabled, so enable "zlib"
895         delete $disabled{"zlib"};
896         }
897
898 if (defined($disabled{"rijndael"}))
899         {
900         $disabled{"aes"} = "forced";
901         }
902 if (defined($disabled{"des"}))
903         {
904         $disabled{"mdc2"} = "forced";
905         }
906 if (defined($disabled{"ec"}))
907         {
908         $disabled{"ecdsa"} = "forced";
909         $disabled{"ecdh"} = "forced";
910         }
911
912 # SSL 3.0 requires MD5 and SHA and either RSA or DSA+DH
913 if (defined($disabled{"md5"}) || defined($disabled{"sha"})
914     || (defined($disabled{"rsa"})
915         && (defined($disabled{"dsa"}) || defined($disabled{"dh"}))))
916         {
917         $disabled{"ssl3"} = "forced";
918         $disabled{"ssl"} = "forced";
919         }
920
921 # (D)TLS 1.0 and TLS 1.1 require MD5 and SHA and either RSA or DSA+DH
922 # or ECDSA + ECDH.  (XXX: We don't support PSK-only builds).
923 #
924 if (defined($disabled{"md5"}) || defined($disabled{"sha"})
925     || (defined($disabled{"rsa"})
926         && (defined($disabled{"dsa"}) || defined($disabled{"dh"}))
927         && (defined($disabled{"ecdsa"}) || defined($disabled{"ecdh"}))))
928         {
929         $disabled{"tls1"} = "forced";
930         $disabled{"dtls1"} = "forced";
931         $disabled{"tls1_1"} = "forced";
932         }
933
934 # (D)TLS 1.2 requires either RSA or DSA+DH or ECDSA + ECDH
935 # So if all are missing, we can't do either TLS or DTLS.
936 # (XXX: We don't support PSK-only builds).
937 #
938 if (defined($disabled{"rsa"})
939     && (defined($disabled{"dsa"}) || defined($disabled{"dh"}))
940     && (defined($disabled{"ecdsa"}) || defined($disabled{"ecdh"})))
941         {
942         $disabled{"tls"} = "forced";
943         $disabled{"dtls"} = "forced";
944         foreach my $proto ((@tls, @dtls))
945                 {
946                 $disabled{"$proto"} = "forced";
947                 }
948         }
949
950
951 # Avoid protocol support holes.  Also disable all versions below N, if version
952 # N is disabled while N+1 is enabled.
953 #
954 my $prev_disabled = 1;
955 my $force_disable = 0;
956 foreach my $proto (reverse(@tls))
957         {
958         if ($force_disable)
959                 {
960                 $disabled{$proto} = 1;
961                 }
962         elsif (! defined($disabled{$proto}))
963                 {
964                 $prev_disabled = 0;
965                 }
966         elsif (! $prev_disabled)
967                 {
968                 $force_disable = 1;
969                 }
970         }
971 my $prev_disabled = 1;
972 my $force_disable = 0;
973 foreach my $proto (reverse(@dtls))
974         {
975         if ($force_disable)
976                 {
977                 $disabled{$proto} = 1;
978                 }
979         elsif (! defined($disabled{$proto}))
980                 {
981                 $prev_disabled = 0;
982                 }
983         elsif (! $prev_disabled)
984                 {
985                 $force_disable = 1;
986                 }
987         }
988
989 if (defined($disabled{"dgram"}))
990         {
991         $disabled{"dtls"} = "forced";
992         $disabled{"dtls1"} = "forced";
993         $disabled{"dtls1_2"} = "forced";
994         }
995
996 if (defined($disabled{"ec"}) || defined($disabled{"dsa"})
997     || defined($disabled{"dh"}) || defined($disabled{"stdio"}))
998         {
999         $disabled{"gost"} = "forced";
1000         }
1001
1002
1003 if ($target eq "TABLE") {
1004         foreach $target (sort keys %table) {
1005                 print_table_entry($target, "TABLE");
1006         }
1007         exit 0;
1008 }
1009
1010 if ($target eq "LIST") {
1011         foreach (sort keys %table) {
1012                 print;
1013                 print "\n";
1014         }
1015         exit 0;
1016 }
1017
1018 if ($target eq "HASH") {
1019         print "%table = (\n";
1020         foreach (sort keys %table) {
1021                 print_table_entry($_, "HASH");
1022         }
1023         exit 0;
1024 }
1025
1026 if ($target =~ m/^CygWin32(-.*)$/) {
1027         $target = "Cygwin".$1;
1028 }
1029
1030 print "Configuring for $target\n";
1031
1032 # Support for legacy targets having a name starting with 'debug-'
1033 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
1034 if ($d) {
1035     $build_prefix = "debug_";
1036
1037     # If we do not find debug-foo in the table, the target is set to foo,
1038     # but only if the foo target has a noon-empty debug_cflags or debug_lflags
1039     # attribute.
1040     if (!$table{$target}) {
1041         $target = $t;
1042     }
1043 }
1044 my %target = resolve_config($target);
1045
1046 &usage if (!%target || $target{template});
1047
1048 if ($fips)
1049         {
1050         delete $disabled{"shared"} if ($disabled{"shared"} eq "default");
1051         }
1052
1053 foreach (sort (keys %disabled))
1054         {
1055         $options .= " no-$_";
1056
1057         printf "    no-%-12s %-10s", $_, "[$disabled{$_}]";
1058
1059         if (/^dso$/)
1060                 { $no_dso = 1; }
1061         elsif (/^threads$/)
1062                 { $no_threads = 1; }
1063         elsif (/^shared$/)
1064                 { $no_shared = 1; }
1065         elsif (/^zlib$/)
1066                 { $zlib = 0; }
1067         elsif (/^static-engine$/)
1068                 { }
1069         elsif (/^zlib-dynamic$/)
1070                 { }
1071         elsif (/^sse2$/)
1072                 { $no_sse2 = 1; }
1073         else
1074                 {
1075                 my ($ALGO, $algo);
1076                 ($ALGO = $algo = $_) =~ tr/[\-a-z]/[_A-Z]/;
1077
1078                 if (/^asm$/ || /^err$/ || /^hw$/ || /^hw-/)
1079                         {
1080                         $openssl_other_defines .= "#define OPENSSL_NO_$ALGO\n";
1081                         print " OPENSSL_NO_$ALGO";
1082
1083                         if (/^err$/)    { $flags .= "-DOPENSSL_NO_ERR "; }
1084                         elsif (/^asm$/) { $no_asm = 1; }
1085                         }
1086                 else
1087                         {
1088                         ($ALGO,$algo) = ("RMD160","rmd160") if ($algo eq "ripemd");
1089
1090                         $openssl_algorithm_defines .= "#define OPENSSL_NO_$ALGO\n";
1091                         print " OPENSSL_NO_$ALGO";
1092
1093                         push @skip, $algo;
1094                         # fix-up crypto/directory name(s)
1095                         $skip[$#skip]="whrlpool" if $algo eq "whirlpool";
1096                         $skip[$#skip]="ripemd" if $algo eq "rmd160";
1097
1098                         print " (skip dir)";
1099
1100                         $depflags .= " -DOPENSSL_NO_$ALGO";
1101                         }
1102                 }
1103
1104         print "\n";
1105         }
1106
1107 my $exp_cflags = "";
1108
1109 foreach (sort @experimental)
1110         {
1111         my $ALGO;
1112         ($ALGO = $_) =~ tr/[a-z]/[A-Z]/;
1113
1114         # opensslconf.h will set OPENSSL_NO_... unless OPENSSL_EXPERIMENTAL_... is defined
1115         $openssl_experimental_defines .= "#define OPENSSL_NO_$ALGO\n";
1116         $exp_cflags .= " -DOPENSSL_EXPERIMENTAL_$ALGO";
1117         }
1118
1119 my $IsMK1MF=scalar grep /^$target$/,@MK1MF_Builds;
1120
1121 $exe_ext=".exe" if ($target eq "Cygwin" || $target eq "DJGPP" || $target =~ /^mingw/);
1122 $exe_ext=".nlm" if ($target =~ /netware/);
1123 $exe_ext=".pm"  if ($target =~ /vos/);
1124 $openssldir="/usr/local/ssl" if ($openssldir eq "" and $prefix eq "");
1125 $prefix=$openssldir if $prefix eq "";
1126
1127 $default_ranlib= &which("ranlib") or $default_ranlib="true";
1128 $perl=$ENV{'PERL'} or $perl=&which("perl5") or $perl=&which("perl")
1129   or $perl="perl";
1130 my $make = $ENV{'MAKE'} || "make";
1131
1132 $cross_compile_prefix=$ENV{'CROSS_COMPILE'} if $cross_compile_prefix eq "";
1133
1134 chop $openssldir if $openssldir =~ /\/$/;
1135 chop $prefix if $prefix =~ /.\/$/;
1136
1137 $openssldir=$prefix . "/ssl" if $openssldir eq "";
1138 $openssldir=$prefix . "/" . $openssldir if $openssldir !~ /(^\/|^[a-zA-Z]:[\\\/])/;
1139
1140
1141 print "IsMK1MF=$IsMK1MF\n";
1142
1143 # Allow environment CC to override compiler...
1144 my $cc = $ENV{CC} || $target{cc};
1145
1146 # For cflags and lflags, add the debug_ or release_ attributes
1147 # Do it in such a way that no spurious space is appended (hence the grep).
1148 my $cflags = join(" ",
1149                   grep { $_ } ($target{cflags},
1150                                $target{$build_prefix."cflags"}));
1151 my $lflags = join(" ",
1152                   grep { $_ } ($target{lflags},
1153                                $target{$build_prefix."lflags"}));
1154
1155 my $unistd = $target{unistd};
1156 my $thread_cflag = $target{thread_cflag};
1157 my $sys_id = $target{sys_id};
1158 my $bn_ops = $target{bn_ops};
1159 my $cpuid_obj = $target{cpuid_obj};
1160 my $bn_obj = $target{bn_obj};
1161 my $ec_obj = $target{ec_obj};
1162 my $des_obj = $target{des_obj};
1163 my $aes_obj = $target{aes_obj};
1164 my $bf_obj = $target{bf_obj};
1165 my $md5_obj = $target{md5_obj};
1166 my $sha1_obj = $target{sha1_obj};
1167 my $cast_obj = $target{cast_obj};
1168 my $rc4_obj = $target{rc4_obj};
1169 my $rmd160_obj = $target{rmd160_obj};
1170 my $rc5_obj = $target{rc5_obj};
1171 my $wp_obj = $target{wp_obj};
1172 my $cmll_obj = $target{cmll_obj};
1173 my $modes_obj = $target{modes_obj};
1174 my $engines_obj = $target{engines_obj};
1175 my $chacha_obj = $target{chacha_obj};
1176 my $poly1305_obj = $target{poly1305_obj};
1177 my $perlasm_scheme = $target{perlasm_scheme};
1178 my $dso_scheme = $target{dso_scheme};
1179 my $shared_target = $target{shared_target};
1180 my $shared_cflag = $target{shared_cflag};
1181 my $shared_ldflag = $target{shared_ldflag};
1182 my $shared_extension = $target{shared_extension};
1183 my $ranlib = $ENV{'RANLIB'} || $target{ranlib};
1184 my $ar = $ENV{'AR'} || "ar";
1185 my $arflags = $target{arflags};
1186 my $multilib = $target{multilib};
1187
1188 # if $prefix/lib$multilib is not an existing directory, then
1189 # assume that it's not searched by linker automatically, in
1190 # which case adding $multilib suffix causes more grief than
1191 # we're ready to tolerate, so don't...
1192 $multilib="" if !-d "$prefix/lib$multilib";
1193
1194 $libdir="lib$multilib" if $libdir eq "";
1195
1196 $cflags = "$cflags$exp_cflags";
1197
1198 # '%' in $lflags is used to split flags to "pre-" and post-flags
1199 my ($prelflags,$postlflags)=split('%',$lflags);
1200 if (defined($postlflags))       { $lflags=$postlflags;  }
1201 else                            { $lflags=$prelflags; undef $prelflags; }
1202
1203 if ($target =~ /^mingw/ && `$cc --target-help 2>&1` !~ m/\-mno\-cygwin/m)
1204         {
1205         $cflags =~ s/\-mno\-cygwin\s*//;
1206         $shared_ldflag =~ s/\-mno\-cygwin\s*//;
1207         }
1208
1209 if ($target =~ /linux.*\-mips/ && !$no_asm && $flags !~ /\-m(ips|arch=)/) {
1210         # minimally required architecture flags for assembly modules
1211         $cflags="-mips2 $cflags" if ($target =~ /mips32/);
1212         $cflags="-mips3 $cflags" if ($target =~ /mips64/);
1213 }
1214
1215 my $no_shared_warn=0;
1216 my $no_user_cflags=0;
1217
1218 if ($flags ne "")       { $cflags="$flags$cflags"; }
1219 else                    { $no_user_cflags=1;       }
1220
1221 # The DSO code currently always implements all functions so that no
1222 # applications will have to worry about that from a compilation point
1223 # of view. However, the "method"s may return zero unless that platform
1224 # has support compiled in for them. Currently each method is enabled
1225 # by a define "DSO_<name>" ... we translate the "dso_scheme" config
1226 # string entry into using the following logic;
1227 my $dso_cflags;
1228 if (!$no_dso && $dso_scheme ne "")
1229         {
1230         $dso_scheme =~ tr/[a-z]/[A-Z]/;
1231         if ($dso_scheme eq "DLFCN")
1232                 {
1233                 $dso_cflags = "-DDSO_DLFCN -DHAVE_DLFCN_H";
1234                 }
1235         elsif ($dso_scheme eq "DLFCN_NO_H")
1236                 {
1237                 $dso_cflags = "-DDSO_DLFCN";
1238                 }
1239         else
1240                 {
1241                 $dso_cflags = "-DDSO_$dso_scheme";
1242                 }
1243         $cflags = "$dso_cflags $cflags";
1244         }
1245
1246 my $thread_cflags;
1247 my $thread_defines;
1248 if ($thread_cflag ne "(unknown)" && !$no_threads)
1249         {
1250         # If we know how to do it, support threads by default.
1251         $threads = 1;
1252         }
1253 if ($thread_cflag eq "(unknown)" && $threads)
1254         {
1255         # If the user asked for "threads", [s]he is also expected to
1256         # provide any system-dependent compiler options that are
1257         # necessary.
1258         if ($no_user_cflags)
1259                 {
1260                 print "You asked for multi-threading support, but didn't\n";
1261                 print "provide any system-specific compiler options\n";
1262                 exit(1);
1263                 }
1264         $thread_cflags="-DOPENSSL_THREADS $cflags" ;
1265         $thread_defines .= "#define OPENSSL_THREADS\n";
1266         }
1267 else
1268         {
1269         $thread_cflags="-DOPENSSL_THREADS $thread_cflag $cflags";
1270         $thread_defines .= "#define OPENSSL_THREADS\n";
1271 #       my $def;
1272 #       foreach $def (split ' ',$thread_cflag)
1273 #               {
1274 #               if ($def =~ s/^-D// && $def !~ /^_/)
1275 #                       {
1276 #                       $thread_defines .= "#define $def\n";
1277 #                       }
1278 #               }
1279         }
1280
1281 $lflags="$libs$lflags" if ($libs ne "");
1282
1283 if ($no_asm)
1284         {
1285         $cpuid_obj=$bn_obj=$ec_obj=
1286         $des_obj=$aes_obj=$bf_obj=$cast_obj=$rc4_obj=$rc5_obj=$cmll_obj=
1287         $modes_obj=$sha1_obj=$md5_obj=$rmd160_obj=$wp_obj=$engines_obj=
1288         $chacha_obj=$poly1305_obj="";
1289         $cflags=~s/\-D[BL]_ENDIAN//             if ($fips);
1290         $thread_cflags=~s/\-D[BL]_ENDIAN//      if ($fips);
1291         }
1292 elsif (defined($disabled{ec2m}))
1293         {
1294         $bn_obj =~ s/\w+-gf2m.o//;
1295         }
1296
1297 if (!$no_shared)
1298         {
1299         $cast_obj="";   # CAST assembler is not PIC
1300         }
1301
1302 if ($threads)
1303         {
1304         $cflags=$thread_cflags;
1305         $openssl_thread_defines .= $thread_defines;
1306         }
1307
1308 if ($zlib)
1309         {
1310         $cflags = "-DZLIB $cflags";
1311         if (defined($disabled{"zlib-dynamic"}))
1312                 {
1313                 if (defined($withargs{"zlib-lib"}))
1314                         {
1315                         $lflags = "$lflags -L" . $withargs{"zlib-lib"} . " -lz";
1316                         }
1317                 else
1318                         {
1319                         $lflags = "$lflags -lz";
1320                         }
1321                 }
1322         else
1323                 {
1324                 $cflags = "-DZLIB_SHARED $cflags";
1325                 }
1326         }
1327
1328 # With "deprecated" disable all deprecated features.
1329 if (defined($disabled{"deprecated"})) {
1330         $api = $maxapi;
1331 }
1332
1333 # You will find shlib_mark1 and shlib_mark2 explained in Makefile.in
1334 my $shared_mark = "";
1335 if ($shared_target eq "")
1336         {
1337         $no_shared_warn = 1 if !$no_shared && !$fips;
1338         $no_shared = 1;
1339         }
1340 if (!$no_shared)
1341         {
1342         if ($shared_cflag ne "")
1343                 {
1344                 $cflags = "$shared_cflag -DOPENSSL_PIC $cflags";
1345                 }
1346         }
1347
1348 if (!$IsMK1MF)
1349         {
1350         # add {no-}static-engine to options to allow mkdef.pl to work without extra arguments
1351         if ($no_shared)
1352                 {
1353                 $openssl_other_defines.="#define OPENSSL_NO_DYNAMIC_ENGINE\n";
1354                 $options.=" static-engine";
1355                 }
1356         else
1357                 {
1358                 $openssl_other_defines.="#define OPENSSL_NO_STATIC_ENGINE\n";
1359                 $options.=" no-static-engine";
1360                 }
1361         }
1362
1363 $cpuid_obj.=" uplink.o uplink-x86.o" if ($cflags =~ /\-DOPENSSL_USE_APPLINK/);
1364
1365 #
1366 # Platform fix-ups
1367 #
1368 if ($target =~ /\-icc$/)        # Intel C compiler
1369         {
1370         my $iccver=0;
1371         if (open(FD,"$cc -V 2>&1 |"))
1372                 {
1373                 while(<FD>) { $iccver=$1 if (/Version ([0-9]+)\./); }
1374                 close(FD);
1375                 }
1376         if ($iccver>=8)
1377                 {
1378                 $cflags=~s/\-KPIC/-fPIC/;
1379                 # Eliminate unnecessary dependency from libirc.a. This is
1380                 # essential for shared library support, as otherwise
1381                 # apps/openssl can end up in endless loop upon startup...
1382                 $cflags.=" -Dmemcpy=__builtin_memcpy -Dmemset=__builtin_memset";
1383                 }
1384         if ($iccver>=9)
1385                 {
1386                 $lflags.=" -i-static";
1387                 $lflags=~s/\-no_cpprt/-no-cpprt/;
1388                 }
1389         if ($iccver>=10)
1390                 {
1391                 $lflags=~s/\-i\-static/-static-intel/;
1392                 }
1393         if ($iccver>=11)
1394                 {
1395                 $cflags.=" -no-intel-extensions";       # disable Cilk
1396                 $lflags=~s/\-no\-cpprt/-no-cxxlib/;
1397                 }
1398         }
1399
1400 # Unlike other OSes (like Solaris, Linux, Tru64, IRIX) BSD run-time
1401 # linkers (tested OpenBSD, NetBSD and FreeBSD) "demand" RPATH set on
1402 # .so objects. Apparently application RPATH is not global and does
1403 # not apply to .so linked with other .so. Problem manifests itself
1404 # when libssl.so fails to load libcrypto.so. One can argue that we
1405 # should engrave this into Makefile.shared rules or into BSD-* config
1406 # lines above. Meanwhile let's try to be cautious and pass -rpath to
1407 # linker only when --prefix is not /usr.
1408 if ($target =~ /^BSD\-/)
1409         {
1410         $shared_ldflag.=" -Wl,-rpath,\$\$(LIBRPATH)" if ($prefix !~ m|^/usr[/]*$|);
1411         }
1412
1413 if ($sys_id ne "")
1414         {
1415         #$cflags="-DOPENSSL_SYS_$sys_id $cflags";
1416         $openssl_sys_defines="#define OPENSSL_SYS_$sys_id\n";
1417         }
1418
1419 if ($ranlib eq "")
1420         {
1421         $ranlib = $default_ranlib;
1422         }
1423
1424 #my ($bn1)=split(/\s+/,$bn_obj);
1425 #$bn1 = "" unless defined $bn1;
1426 #$bn1=$bn_asm unless ($bn1 =~ /\.o$/);
1427 #$bn_obj="$bn1";
1428
1429 $cpuid_obj="" if ($processor eq "386");
1430
1431 $bn_obj = $bn_asm unless $bn_obj ne "";
1432 # bn-586 is the only one implementing bn_*_part_words
1433 $cflags.=" -DOPENSSL_BN_ASM_PART_WORDS" if ($bn_obj =~ /bn-586/);
1434 $cflags.=" -DOPENSSL_IA32_SSE2" if (!$no_sse2 && $bn_obj =~ /86/);
1435
1436 $cflags.=" -DOPENSSL_BN_ASM_MONT" if ($bn_obj =~ /-mont/);
1437 $cflags.=" -DOPENSSL_BN_ASM_MONT5" if ($bn_obj =~ /-mont5/);
1438 $cflags.=" -DOPENSSL_BN_ASM_GF2m" if ($bn_obj =~ /-gf2m/);
1439
1440 if ($fips)
1441         {
1442         $openssl_other_defines.="#define OPENSSL_FIPS\n";
1443         }
1444
1445 $cpuid_obj="mem_clr.o"  unless ($cpuid_obj =~ /\.o$/);
1446 $des_obj=$des_enc       unless ($des_obj =~ /\.o$/);
1447 $bf_obj=$bf_enc         unless ($bf_obj =~ /\.o$/);
1448 $cast_obj=$cast_enc     unless ($cast_obj =~ /\.o$/);
1449 $rc4_obj=$rc4_enc       unless ($rc4_obj =~ /\.o$/);
1450 $rc5_obj=$rc5_enc       unless ($rc5_obj =~ /\.o$/);
1451 if ($sha1_obj =~ /\.o$/)
1452         {
1453 #       $sha1_obj=$sha1_enc;
1454         $cflags.=" -DSHA1_ASM"   if ($sha1_obj =~ /sx86/ || $sha1_obj =~ /sha1/);
1455         $cflags.=" -DSHA256_ASM" if ($sha1_obj =~ /sha256/);
1456         $cflags.=" -DSHA512_ASM" if ($sha1_obj =~ /sha512/);
1457         if ($sha1_obj =~ /sse2/)
1458             {   if ($no_sse2)
1459                 {   $sha1_obj =~ s/\S*sse2\S+//;        }
1460                 elsif ($cflags !~ /OPENSSL_IA32_SSE2/)
1461                 {   $cflags.=" -DOPENSSL_IA32_SSE2";    }
1462             }
1463         }
1464 if ($md5_obj =~ /\.o$/)
1465         {
1466 #       $md5_obj=$md5_enc;
1467         $cflags.=" -DMD5_ASM";
1468         }
1469 if ($rmd160_obj =~ /\.o$/)
1470         {
1471 #       $rmd160_obj=$rmd160_enc;
1472         $cflags.=" -DRMD160_ASM";
1473         }
1474 if ($aes_obj =~ /\.o$/)
1475         {
1476         $cflags.=" -DAES_ASM" if ($aes_obj =~ m/\baes\-/);;
1477         # aes-ctr.o is not a real file, only indication that assembler
1478         # module implements AES_ctr32_encrypt...
1479         $cflags.=" -DAES_CTR_ASM" if ($aes_obj =~ s/\s*aes\-ctr\.o//);
1480         # aes-xts.o indicates presence of AES_xts_[en|de]crypt...
1481         $cflags.=" -DAES_XTS_ASM" if ($aes_obj =~ s/\s*aes\-xts\.o//);
1482         $aes_obj =~ s/\s*(vpaes|aesni)\-x86\.o//g if ($no_sse2);
1483         $cflags.=" -DVPAES_ASM" if ($aes_obj =~ m/vpaes/);
1484         $cflags.=" -DBSAES_ASM" if ($aes_obj =~ m/bsaes/);
1485         }
1486 else    {
1487         $aes_obj=$aes_enc;
1488         }
1489 $wp_obj="" if ($wp_obj =~ /mmx/ && $processor eq "386");
1490 if ($wp_obj =~ /\.o$/ && !$disabled{"whirlpool"})
1491         {
1492         $cflags.=" -DWHIRLPOOL_ASM";
1493         }
1494 else    {
1495         $wp_obj="wp_block.o";
1496         }
1497 $cmll_obj=$cmll_enc     unless ($cmll_obj =~ /.o$/);
1498 if ($modes_obj =~ /ghash\-/)
1499         {
1500         $cflags.=" -DGHASH_ASM";
1501         }
1502 if ($ec_obj =~ /ecp_nistz256/)
1503         {
1504         $cflags.=" -DECP_NISTZ256_ASM";
1505         }
1506 $chacha_obj=$chacha_enc unless ($chacha_obj =~ /\.o$/);
1507 if ($poly1305_obj =~ /\.o$/)
1508         {
1509         $cflags.=" -DPOLY1305_ASM";
1510         }
1511
1512 # "Stringify" the C flags string.  This permits it to be made part of a string
1513 # and works as well on command lines.
1514 $cflags =~ s/([\\\"])/\\\1/g;
1515
1516 my $version = "unknown";
1517 my $version_num = "unknown";
1518 my $major = "unknown";
1519 my $minor = "unknown";
1520 my $shlib_version_number = "unknown";
1521 my $shlib_version_history = "unknown";
1522 my $shlib_major = "unknown";
1523 my $shlib_minor = "unknown";
1524
1525 open(IN,'<include/openssl/opensslv.h') || die "unable to read opensslv.h:$!\n";
1526 while (<IN>)
1527         {
1528         $version=$1 if /OPENSSL.VERSION.TEXT.*OpenSSL (\S+) /;
1529         $version_num=$1 if /OPENSSL.VERSION.NUMBER.*(0x\S+)/;
1530         $shlib_version_number=$1 if /SHLIB_VERSION_NUMBER *"([^"]+)"/;
1531         $shlib_version_history=$1 if /SHLIB_VERSION_HISTORY *"([^"]*)"/;
1532         }
1533 close(IN);
1534 if ($shlib_version_history ne "") { $shlib_version_history .= ":"; }
1535
1536 if ($version =~ /(^[0-9]*)\.([0-9\.]*)/)
1537         {
1538         $major=$1;
1539         $minor=$2;
1540         }
1541
1542 if ($shlib_version_number =~ /(^[0-9]*)\.([0-9\.]*)/)
1543         {
1544         $shlib_major=$1;
1545         $shlib_minor=$2;
1546         }
1547
1548 if (defined($api)) {
1549     my $apiflag = sprintf("-DOPENSSL_API_COMPAT=%s", $apitable->{$api});
1550     $default_depflags .= " $apiflag";
1551     $cflags .= " $apiflag";
1552 }
1553
1554 my $ecc = $cc;
1555 $ecc = "clang" if `$cc --version 2>&1` =~ /clang/;
1556
1557 if ($strict_warnings)
1558         {
1559         my $wopt;
1560         die "ERROR --strict-warnings requires gcc or clang" unless ($ecc =~ /gcc(-\d(\.\d)*)?$/ or $ecc =~ /clang$/);
1561         foreach $wopt (split /\s+/, $gcc_devteam_warn)
1562                 {
1563                 $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/)
1564                 }
1565         if ($ecc eq "clang")
1566                 {
1567                 foreach $wopt (split /\s+/, $clang_devteam_warn)
1568                         {
1569                         $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/)
1570                         }
1571                 }
1572         if ($target !~ /^mingw/)
1573                 {
1574                 foreach $wopt (split /\s+/, $memleak_devteam_backtrace)
1575                         {
1576                         $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/)
1577                         }
1578                 if ($target =~ /^BSD-/)
1579                         {
1580                         $lflags .= " -lexecinfo";
1581                         }
1582                 }
1583         }
1584
1585 open(IN,"<Makefile.in") || die "unable to read Makefile.in$!\n";
1586 unlink("$Makefile.new") || die "unable to remove old $Makefile.new:$!\n" if -e "$Makefile.new";
1587 open(OUT,">$Makefile.new") || die "unable to create $Makefile.new:$!\n";
1588 print OUT "### Generated automatically from Makefile.in by Configure.\n\n";
1589 my $sdirs=0;
1590
1591 while (<IN>)
1592         {
1593         chomp;
1594         $sdirs = 1 if /^SDIRS=/;
1595         if ($sdirs) {
1596                 my $dir;
1597                 foreach $dir (@skip) {
1598                         s/(\s)$dir /$1/;
1599                         s/\s$dir$//;
1600                         }
1601                 }
1602         $sdirs = 0 unless /\\$/;
1603         s/fips // if (/^DIRS=/ && !$fips);
1604         s/engines // if (/^DIRS=/ && $disabled{"engine"});
1605         s/^VERSION=.*/VERSION=$version/;
1606         s/^MAJOR=.*/MAJOR=$major/;
1607         s/^MINOR=.*/MINOR=$minor/;
1608         s/^SHLIB_VERSION_NUMBER=.*/SHLIB_VERSION_NUMBER=$shlib_version_number/;
1609         s/^SHLIB_VERSION_HISTORY=.*/SHLIB_VERSION_HISTORY=$shlib_version_history/;
1610         s/^SHLIB_MAJOR=.*/SHLIB_MAJOR=$shlib_major/;
1611         s/^SHLIB_MINOR=.*/SHLIB_MINOR=$shlib_minor/;
1612         s/^SHLIB_EXT=.*/SHLIB_EXT=$shared_extension/;
1613         s/^INSTALLTOP=.*$/INSTALLTOP=$prefix/;
1614         s/^MULTILIB=.*$/MULTILIB=$multilib/;
1615         s/^OPENSSLDIR=.*$/OPENSSLDIR=$openssldir/;
1616         s/^LIBDIR=.*$/LIBDIR=$libdir/;
1617         s/^INSTALL_PREFIX=.*$/INSTALL_PREFIX=$install_prefix/;
1618         s/^PLATFORM=.*$/PLATFORM=$target/;
1619         s/^OPTIONS=.*$/OPTIONS=$options/;
1620         s/^CONFIGURE_ARGS=.*$/CONFIGURE_ARGS=$argvstring/;
1621         if ($cross_compile_prefix)
1622                 {
1623                 s/^CC=.*$/CROSS_COMPILE= $cross_compile_prefix\nCC= \$\(CROSS_COMPILE\)$cc/;
1624                 s/^AR=\s*/AR= \$\(CROSS_COMPILE\)/;
1625                 s/^NM=\s*/NM= \$\(CROSS_COMPILE\)/;
1626                 s/^RANLIB=\s*/RANLIB= \$\(CROSS_COMPILE\)/;
1627                 s/^MAKEDEPPROG=.*$/MAKEDEPPROG= \$\(CROSS_COMPILE\)$cc/ if $cc eq "gcc";
1628                 }
1629         else    {
1630                 s/^CC=.*$/CC= $cc/;
1631                 s/^AR=\s*ar/AR= $ar/;
1632                 s/^RANLIB=.*/RANLIB= $ranlib/;
1633                 s/^MAKEDEPPROG=.*$/MAKEDEPPROG= $cc/ if $ecc eq "gcc" || $ecc eq "clang";
1634                 }
1635         s/^CFLAG=.*$/CFLAG= $cflags/;
1636         s/^DEPFLAG=.*$/DEPFLAG=$depflags/;
1637         s/^PEX_LIBS=.*$/PEX_LIBS= $prelflags/;
1638         s/^EX_LIBS=.*$/EX_LIBS= $lflags/;
1639         s/^EXE_EXT=.*$/EXE_EXT= $exe_ext/;
1640         s/^CPUID_OBJ=.*$/CPUID_OBJ= $cpuid_obj/;
1641         s/^BN_ASM=.*$/BN_ASM= $bn_obj/;
1642         s/^EC_ASM=.*$/EC_ASM= $ec_obj/;
1643         s/^DES_ENC=.*$/DES_ENC= $des_obj/;
1644         s/^AES_ENC=.*$/AES_ENC= $aes_obj/;
1645         s/^BF_ENC=.*$/BF_ENC= $bf_obj/;
1646         s/^CAST_ENC=.*$/CAST_ENC= $cast_obj/;
1647         s/^RC4_ENC=.*$/RC4_ENC= $rc4_obj/;
1648         s/^RC5_ENC=.*$/RC5_ENC= $rc5_obj/;
1649         s/^MD5_ASM_OBJ=.*$/MD5_ASM_OBJ= $md5_obj/;
1650         s/^SHA1_ASM_OBJ=.*$/SHA1_ASM_OBJ= $sha1_obj/;
1651         s/^RMD160_ASM_OBJ=.*$/RMD160_ASM_OBJ= $rmd160_obj/;
1652         s/^WP_ASM_OBJ=.*$/WP_ASM_OBJ= $wp_obj/;
1653         s/^CMLL_ENC=.*$/CMLL_ENC= $cmll_obj/;
1654         s/^MODES_ASM_OBJ.=*$/MODES_ASM_OBJ= $modes_obj/;
1655         s/^CHACHA_ENC=.*$/CHACHA_ENC= $chacha_obj/;
1656         s/^POLY1305_ASM_OBJ=.*$/POLY1305_ASM_OBJ= $poly1305_obj/;
1657         s/^ENGINES_ASM_OBJ.=*$/ENGINES_ASM_OBJ= $engines_obj/;
1658         s/^PERLASM_SCHEME=.*$/PERLASM_SCHEME= $perlasm_scheme/;
1659         s/^PROCESSOR=.*/PROCESSOR= $processor/;
1660         s/^ARFLAGS=.*/ARFLAGS= $arflags/;
1661         s/^PERL=.*/PERL= $perl/;
1662         s/^LIBZLIB=.*/LIBZLIB=$withargs{"zlib-lib"}/;
1663         s/^ZLIB_INCLUDE=.*/ZLIB_INCLUDE=$withargs{"zlib-include"}/;
1664         s/^FIPSLIBDIR=.*/FIPSLIBDIR=$fipslibdir/;
1665         s/^FIPSCANLIB=.*/FIPSCANLIB=libcrypto/ if $fips;
1666         s/^SHARED_FIPS=.*/SHARED_FIPS=/;
1667         s/^SHLIBDIRS=.*/SHLIBDIRS= crypto ssl/;
1668         s/^BASEADDR=.*/BASEADDR=$baseaddr/;
1669         s/^SHLIB_TARGET=.*/SHLIB_TARGET=$shared_target/;
1670         s/^SHLIB_MARK=.*/SHLIB_MARK=$shared_mark/;
1671         s/^SHARED_LIBS=.*/SHARED_LIBS=\$(SHARED_CRYPTO) \$(SHARED_SSL)/ if (!$no_shared);
1672         if ($shared_extension ne "" && $shared_extension =~ /^\.s([ol])\.[^\.]*$/)
1673                 {
1674                 my $sotmp = $1;
1675                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.s$sotmp/;
1676                 }
1677         elsif ($shared_extension ne "" && $shared_extension =~ /^\.[^\.]*\.dylib$/)
1678                 {
1679                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.dylib/;
1680                 }
1681         elsif ($shared_extension ne "" && $shared_extension =~ /^\.s([ol])\.[^\.]*\.[^\.]*$/)
1682                 {
1683                 my $sotmp = $1;
1684                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.s$sotmp.\$(SHLIB_MAJOR) .s$sotmp/;
1685                 }
1686         elsif ($shared_extension ne "" && $shared_extension =~ /^\.[^\.]*\.[^\.]*\.dylib$/)
1687                 {
1688                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.\$(SHLIB_MAJOR).dylib .dylib/;
1689                 }
1690         s/^SHARED_LDFLAGS=.*/SHARED_LDFLAGS=$shared_ldflag/;
1691         print OUT $_."\n";
1692         }
1693 close(IN);
1694 close(OUT);
1695 rename($Makefile,"$Makefile.orig") || die "unable to rename $Makefile\n" if -e $Makefile;
1696 rename("$Makefile.new",$Makefile) || die "unable to rename $Makefile.new\n";
1697
1698 print "CC            =$cc\n";
1699 print "CFLAG         =$cflags\n";
1700 print "EX_LIBS       =$lflags\n";
1701 print "CPUID_OBJ     =$cpuid_obj\n";
1702 print "BN_ASM        =$bn_obj\n";
1703 print "EC_ASM        =$ec_obj\n";
1704 print "DES_ENC       =$des_obj\n";
1705 print "AES_ENC       =$aes_obj\n";
1706 print "BF_ENC        =$bf_obj\n";
1707 print "CAST_ENC      =$cast_obj\n";
1708 print "RC4_ENC       =$rc4_obj\n";
1709 print "RC5_ENC       =$rc5_obj\n";
1710 print "MD5_OBJ_ASM   =$md5_obj\n";
1711 print "SHA1_OBJ_ASM  =$sha1_obj\n";
1712 print "RMD160_OBJ_ASM=$rmd160_obj\n";
1713 print "CMLL_ENC      =$cmll_obj\n";
1714 print "MODES_OBJ     =$modes_obj\n";
1715 print "ENGINES_OBJ   =$engines_obj\n";
1716 print "CHACHA_ENC    =$chacha_obj\n";
1717 print "POLY1305_OBJ  =$poly1305_obj\n";
1718 print "PROCESSOR     =$processor\n";
1719 print "RANLIB        =$ranlib\n";
1720 print "ARFLAGS       =$arflags\n";
1721 print "PERL          =$perl\n";
1722
1723 my $des_ptr=0;
1724 my $des_risc1=0;
1725 my $des_risc2=0;
1726 my $des_unroll=0;
1727 my $bn_ll=0;
1728 my $def_int=2;
1729 my $rc4_int=$def_int;
1730 my $md2_int=$def_int;
1731 my $idea_int=$def_int;
1732 my $rc2_int=$def_int;
1733 my $rc4_idx=0;
1734 my $rc4_chunk=0;
1735 my $bf_ptr=0;
1736 my @type=("char","short","int","long");
1737 my ($b64l,$b64,$b32,$b16,$b8)=(0,0,1,0,0);
1738 my $export_var_as_fn=0;
1739
1740 my $des_int;
1741
1742 foreach (sort split(/\s+/,$bn_ops))
1743         {
1744         $des_ptr=1 if /DES_PTR/;
1745         $des_risc1=1 if /DES_RISC1/;
1746         $des_risc2=1 if /DES_RISC2/;
1747         $des_unroll=1 if /DES_UNROLL/;
1748         $des_int=1 if /DES_INT/;
1749         $bn_ll=1 if /BN_LLONG/;
1750         $rc4_int=0 if /RC4_CHAR/;
1751         $rc4_int=3 if /RC4_LONG/;
1752         $rc4_idx=1 if /RC4_INDEX/;
1753         $rc4_chunk=1 if /RC4_CHUNK/;
1754         $rc4_chunk=2 if /RC4_CHUNK_LL/;
1755         $md2_int=0 if /MD2_CHAR/;
1756         $md2_int=3 if /MD2_LONG/;
1757         $idea_int=1 if /IDEA_SHORT/;
1758         $idea_int=3 if /IDEA_LONG/;
1759         $rc2_int=1 if /RC2_SHORT/;
1760         $rc2_int=3 if /RC2_LONG/;
1761         $bf_ptr=1 if $_ eq "BF_PTR";
1762         $bf_ptr=2 if $_ eq "BF_PTR2";
1763         ($b64l,$b64,$b32,$b16,$b8)=(0,1,0,0,0) if /SIXTY_FOUR_BIT/;
1764         ($b64l,$b64,$b32,$b16,$b8)=(1,0,0,0,0) if /SIXTY_FOUR_BIT_LONG/;
1765         ($b64l,$b64,$b32,$b16,$b8)=(0,0,1,0,0) if /THIRTY_TWO_BIT/;
1766         ($b64l,$b64,$b32,$b16,$b8)=(0,0,0,1,0) if /SIXTEEN_BIT/;
1767         ($b64l,$b64,$b32,$b16,$b8)=(0,0,0,0,1) if /EIGHT_BIT/;
1768         $export_var_as_fn=1 if /EXPORT_VAR_AS_FN/;
1769         }
1770
1771 open(IN,'<crypto/opensslconf.h.in') || die "unable to read crypto/opensslconf.h.in:$!\n";
1772 unlink("include/openssl/opensslconf.h.new") || die "unable to remove old include/openssl/opensslconf.h.new:$!\n" if -e "include/openssl/opensslconf.h.new";
1773 open(OUT,'>include/openssl/opensslconf.h.new') || die "unable to create include/openssl/opensslconf.h.new:$!\n";
1774 print OUT "/* opensslconf.h */\n";
1775 print OUT "/* WARNING: Generated automatically from opensslconf.h.in by Configure. */\n\n";
1776
1777 print OUT "#ifdef  __cplusplus\n";
1778 print OUT "extern \"C\" {\n";
1779 print OUT "#endif\n";
1780 print OUT "/* OpenSSL was configured with the following options: */\n";
1781
1782 my $openssl_api_defines = "";
1783 if (defined($api)) {
1784     $openssl_api_defines = sprintf "#define OPENSSL_MIN_API %s\n", $apitable->{$api};
1785 }
1786 my $openssl_algorithm_defines_trans = $openssl_algorithm_defines;
1787 $openssl_experimental_defines =~ s/^\s*#\s*define\s+OPENSSL_NO_(.*)/#ifndef OPENSSL_EXPERIMENTAL_$1\n# ifndef OPENSSL_NO_$1\n#  define OPENSSL_NO_$1\n# endif\n#endif/mg;
1788 $openssl_algorithm_defines_trans =~ s/^\s*#\s*define\s+OPENSSL_(.*)/# if defined(OPENSSL_$1) \&\& !defined($1)\n#  define $1\n# endif/mg;
1789 $openssl_algorithm_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1790 $openssl_algorithm_defines = "   /* no ciphers excluded */\n" if $openssl_algorithm_defines eq "";
1791 $openssl_thread_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1792 $openssl_sys_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1793 $openssl_other_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1794
1795 print OUT $openssl_sys_defines;
1796 print OUT "#ifndef OPENSSL_DOING_MAKEDEPEND\n\n";
1797 print OUT $openssl_experimental_defines;
1798 print OUT $openssl_api_defines;
1799 print OUT "\n";
1800 print OUT $openssl_algorithm_defines;
1801 print OUT "\n#endif /* OPENSSL_DOING_MAKEDEPEND */\n\n";
1802 print OUT $openssl_thread_defines;
1803 print OUT $openssl_other_defines,"\n";
1804
1805 print OUT "/* The OPENSSL_NO_* macros are also defined as NO_* if the application\n";
1806 print OUT "   asks for it.  This is a transient feature that is provided for those\n";
1807 print OUT "   who haven't had the time to do the appropriate changes in their\n";
1808 print OUT "   applications.  */\n";
1809 print OUT "#ifdef OPENSSL_ALGORITHM_DEFINES\n";
1810 print OUT $openssl_algorithm_defines_trans;
1811 print OUT "#endif\n\n";
1812
1813 print OUT "#define OPENSSL_CPUID_OBJ\n\n" if ($cpuid_obj ne "mem_clr.o");
1814
1815 while (<IN>)
1816         {
1817         if      (/^#define\s+OPENSSLDIR/)
1818                 {
1819                 my $foo = $openssldir;
1820                 $foo =~ s/\\/\\\\/g;
1821                 print OUT "#define OPENSSLDIR \"$foo\"\n";
1822                 }
1823         elsif   (/^#define\s+ENGINESDIR/)
1824                 {
1825                 my $foo = "$prefix/$libdir/engines";
1826                 $foo =~ s/\\/\\\\/g;
1827                 print OUT "#define ENGINESDIR \"$foo\"\n";
1828                 }
1829         elsif   (/^#((define)|(undef))\s+OPENSSL_EXPORT_VAR_AS_FUNCTION/)
1830                 { printf OUT "#undef OPENSSL_EXPORT_VAR_AS_FUNCTION\n"
1831                         if $export_var_as_fn;
1832                   printf OUT "#%s OPENSSL_EXPORT_VAR_AS_FUNCTION\n",
1833                         ($export_var_as_fn)?"define":"undef"; }
1834         elsif   (/^#define\s+OPENSSL_UNISTD/)
1835                 {
1836                 $unistd = "<unistd.h>" if $unistd eq "";
1837                 print OUT "#define OPENSSL_UNISTD $unistd\n";
1838                 }
1839         elsif   (/^#((define)|(undef))\s+SIXTY_FOUR_BIT_LONG/)
1840                 { printf OUT "#%s SIXTY_FOUR_BIT_LONG\n",($b64l)?"define":"undef"; }
1841         elsif   (/^#((define)|(undef))\s+SIXTY_FOUR_BIT/)
1842                 { printf OUT "#%s SIXTY_FOUR_BIT\n",($b64)?"define":"undef"; }
1843         elsif   (/^#((define)|(undef))\s+THIRTY_TWO_BIT/)
1844                 { printf OUT "#%s THIRTY_TWO_BIT\n",($b32)?"define":"undef"; }
1845         elsif   (/^#((define)|(undef))\s+SIXTEEN_BIT/)
1846                 { printf OUT "#%s SIXTEEN_BIT\n",($b16)?"define":"undef"; }
1847         elsif   (/^#((define)|(undef))\s+EIGHT_BIT/)
1848                 { printf OUT "#%s EIGHT_BIT\n",($b8)?"define":"undef"; }
1849         elsif   (/^#((define)|(undef))\s+BN_LLONG\s*$/)
1850                 { printf OUT "#%s BN_LLONG\n",($bn_ll)?"define":"undef"; }
1851         elsif   (/^\#define\s+OSSL_DES_LONG\s+.*/)
1852                 { printf OUT "#define OSSL_DES_LONG unsigned %s\n",
1853                         ($des_int)?'int':'long'; }
1854         elsif   (/^\#(define|undef)\s+DES_PTR/)
1855                 { printf OUT "#%s DES_PTR\n",($des_ptr)?'define':'undef'; }
1856         elsif   (/^\#(define|undef)\s+DES_RISC1/)
1857                 { printf OUT "#%s DES_RISC1\n",($des_risc1)?'define':'undef'; }
1858         elsif   (/^\#(define|undef)\s+DES_RISC2/)
1859                 { printf OUT "#%s DES_RISC2\n",($des_risc2)?'define':'undef'; }
1860         elsif   (/^\#(define|undef)\s+DES_UNROLL/)
1861                 { printf OUT "#%s DES_UNROLL\n",($des_unroll)?'define':'undef'; }
1862         elsif   (/^#define\s+RC4_INT\s/)
1863                 { printf OUT "#define RC4_INT unsigned %s\n",$type[$rc4_int]; }
1864         elsif   (/^#undef\s+RC4_CHUNK/)
1865                 {
1866                 printf OUT "#undef RC4_CHUNK\n" if $rc4_chunk==0;
1867                 printf OUT "#define RC4_CHUNK unsigned long\n" if $rc4_chunk==1;
1868                 printf OUT "#define RC4_CHUNK unsigned long long\n" if $rc4_chunk==2;
1869                 }
1870         elsif   (/^#((define)|(undef))\s+RC4_INDEX/)
1871                 { printf OUT "#%s RC4_INDEX\n",($rc4_idx)?"define":"undef"; }
1872         elsif (/^#(define|undef)\s+I386_ONLY/)
1873                 { printf OUT "#%s I386_ONLY\n", ($processor eq "386")?
1874                         "define":"undef"; }
1875         elsif   (/^#define\s+MD2_INT\s/)
1876                 { printf OUT "#define MD2_INT unsigned %s\n",$type[$md2_int]; }
1877         elsif   (/^#define\s+IDEA_INT\s/)
1878                 {printf OUT "#define IDEA_INT unsigned %s\n",$type[$idea_int];}
1879         elsif   (/^#define\s+RC2_INT\s/)
1880                 {printf OUT "#define RC2_INT unsigned %s\n",$type[$rc2_int];}
1881         elsif (/^#(define|undef)\s+BF_PTR/)
1882                 {
1883                 printf OUT "#undef BF_PTR\n" if $bf_ptr == 0;
1884                 printf OUT "#define BF_PTR\n" if $bf_ptr == 1;
1885                 printf OUT "#define BF_PTR2\n" if $bf_ptr == 2;
1886                 }
1887         else
1888                 { print OUT $_; }
1889         }
1890 close(IN);
1891 print OUT "#ifdef  __cplusplus\n";
1892 print OUT "}\n";
1893 print OUT "#endif\n";
1894 close(OUT);
1895 rename("include/openssl/opensslconf.h","include/openssl/opensslconf.h.bak") || die "unable to rename include/openssl/opensslconf.h\n" if -e "include/openssl/opensslconf.h";
1896 rename("include/openssl/opensslconf.h.new","include/openssl/opensslconf.h") || die "unable to rename include/openssl/opensslconf.h.new\n";
1897
1898
1899 # Fix the date
1900
1901 print "SIXTY_FOUR_BIT_LONG mode\n" if $b64l;
1902 print "SIXTY_FOUR_BIT mode\n" if $b64;
1903 print "THIRTY_TWO_BIT mode\n" if $b32;
1904 print "SIXTEEN_BIT mode\n" if $b16;
1905 print "EIGHT_BIT mode\n" if $b8;
1906 print "DES_PTR used\n" if $des_ptr;
1907 print "DES_RISC1 used\n" if $des_risc1;
1908 print "DES_RISC2 used\n" if $des_risc2;
1909 print "DES_UNROLL used\n" if $des_unroll;
1910 print "DES_INT used\n" if $des_int;
1911 print "BN_LLONG mode\n" if $bn_ll;
1912 print "RC4 uses u$type[$rc4_int]\n" if $rc4_int != $def_int;
1913 print "RC4_INDEX mode\n" if $rc4_idx;
1914 print "RC4_CHUNK is undefined\n" if $rc4_chunk==0;
1915 print "RC4_CHUNK is unsigned long\n" if $rc4_chunk==1;
1916 print "RC4_CHUNK is unsigned long long\n" if $rc4_chunk==2;
1917 print "MD2 uses u$type[$md2_int]\n" if $md2_int != $def_int;
1918 print "IDEA uses u$type[$idea_int]\n" if $idea_int != $def_int;
1919 print "RC2 uses u$type[$rc2_int]\n" if $rc2_int != $def_int;
1920 print "BF_PTR used\n" if $bf_ptr == 1;
1921 print "BF_PTR2 used\n" if $bf_ptr == 2;
1922
1923 # Copy all Makefile.in to Makefile (except top-level)
1924 use File::Find;
1925 use IO::File;
1926 find(sub {
1927         return if ($_ ne "Makefile.in" || $File::Find::dir eq ".");
1928         my $in = IO::File->new($_, "r") or
1929             die sprintf "Error reading Makefile.in in %s: !$\n",
1930                 $File::Find::dir;
1931         my $out = IO::File->new("Makefile", "w") or
1932             die sprintf "Error writing Makefile in %s: !$\n",
1933                 $File::Find::dir;
1934         print $out "# Generated from $_, do not edit\n";
1935         while (my $line = <$in>) { print $out $line }
1936         $in->close() or
1937             die sprintf "Error reading Makefile.in in %s: !$\n",
1938                 $File::Find::dir;
1939         $out->close() or
1940             die sprintf "Error writing Makefile in %s: !$\n",
1941                 $File::Find::dir;
1942     }, ".");
1943
1944 {
1945     my $perlguess = $perl =~ m@^/@ ? $perl : '/usr/local/bin/perl';
1946
1947     &dofile("tools/c_rehash",$perlguess,
1948             '^#!/'              => '#!%s',
1949             '^my \$dir;$'       => 'my $dir = "' . $openssldir . '";',
1950             '^my \$prefix;$'    => 'my $prefix = "' . $prefix . '";');
1951     &dofile("apps/CA.pl",$perl,
1952             '^#!/'              => '#!%s');
1953 }
1954 if($IsMK1MF) {
1955         open (OUT,">crypto/buildinf.h") || die "Can't open buildinf.h";
1956         printf OUT <<"EOF";
1957 #ifndef MK1MF_BUILD
1958   /* auto-generated by Configure for crypto/cversion.c:
1959    * for Unix builds, crypto/Makefile.ssl generates functional definitions;
1960    * Windows builds (and other mk1mf builds) compile cversion.c with
1961    * -DMK1MF_BUILD and use definitions added to this file by util/mk1mf.pl. */
1962   #error "Windows builds (PLATFORM=$target) use mk1mf.pl-created Makefiles"
1963 #endif
1964 EOF
1965         close(OUT);
1966 } else {
1967         my $make_command = "$make PERL=\'$perl\'";
1968         my $make_targets = "";
1969         $make_targets .= " depend" if $depflags ne $default_depflags && $make_depend;
1970         (system $make_command.$make_targets) == 0 or die "make $make_targets failed"
1971                 if $make_targets ne "";
1972         if ($depflags ne $default_depflags && !$make_depend) {
1973             $warn_make_depend++;
1974         }
1975 }
1976
1977 # create the ms/version32.rc file if needed
1978 if ($IsMK1MF && ($target !~ /^netware/)) {
1979         my ($v1, $v2, $v3, $v4);
1980         if ($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) {
1981                 $v1=hex $1;
1982                 $v2=hex $2;
1983                 $v3=hex $3;
1984                 $v4=hex $4;
1985         }
1986         open (OUT,">ms/version32.rc") || die "Can't open ms/version32.rc";
1987         print OUT <<"EOF";
1988 #include <winver.h>
1989
1990 LANGUAGE 0x09,0x01
1991
1992 1 VERSIONINFO
1993   FILEVERSION $v1,$v2,$v3,$v4
1994   PRODUCTVERSION $v1,$v2,$v3,$v4
1995   FILEFLAGSMASK 0x3fL
1996 #ifdef _DEBUG
1997   FILEFLAGS 0x01L
1998 #else
1999   FILEFLAGS 0x00L
2000 #endif
2001   FILEOS VOS__WINDOWS32
2002   FILETYPE VFT_DLL
2003   FILESUBTYPE 0x0L
2004 BEGIN
2005     BLOCK "StringFileInfo"
2006     BEGIN
2007         BLOCK "040904b0"
2008         BEGIN
2009             // Required:
2010             VALUE "CompanyName", "The OpenSSL Project, http://www.openssl.org/\\0"
2011             VALUE "FileDescription", "OpenSSL Shared Library\\0"
2012             VALUE "FileVersion", "$version\\0"
2013 #if defined(CRYPTO)
2014             VALUE "InternalName", "libeay32\\0"
2015             VALUE "OriginalFilename", "libeay32.dll\\0"
2016 #elif defined(SSL)
2017             VALUE "InternalName", "ssleay32\\0"
2018             VALUE "OriginalFilename", "ssleay32.dll\\0"
2019 #endif
2020             VALUE "ProductName", "The OpenSSL Toolkit\\0"
2021             VALUE "ProductVersion", "$version\\0"
2022             // Optional:
2023             //VALUE "Comments", "\\0"
2024             VALUE "LegalCopyright", "Copyright © 1998-2015 The OpenSSL Project. Copyright © 1995-1998 Eric A. Young, Tim J. Hudson. All rights reserved.\\0"
2025             //VALUE "LegalTrademarks", "\\0"
2026             //VALUE "PrivateBuild", "\\0"
2027             //VALUE "SpecialBuild", "\\0"
2028         END
2029     END
2030     BLOCK "VarFileInfo"
2031     BEGIN
2032         VALUE "Translation", 0x409, 0x4b0
2033     END
2034 END
2035 EOF
2036         close(OUT);
2037   }
2038
2039 print <<"EOF";
2040
2041 Configured for $target.
2042 EOF
2043
2044 print <<"EOF" if (!$no_threads && !$threads);
2045
2046 The library could not be configured for supporting multi-threaded
2047 applications as the compiler options required on this system are not known.
2048 See file INSTALL for details if you need multi-threading.
2049 EOF
2050
2051 print <<"EOF" if ($no_shared_warn);
2052
2053 You gave the option 'shared', which is not supported on this platform, so
2054 we will pretend you gave the option 'no-shared'.  If you know how to implement
2055 shared libraries, please let us know (but please first make sure you have
2056 tried with a current version of OpenSSL).
2057 EOF
2058
2059 print <<"EOF" if ($warn_make_depend);
2060
2061 *** Because of configuration changes, you MUST do the following before
2062 *** building:
2063
2064         make depend
2065 EOF
2066
2067 exit(0);
2068
2069 ######################################################################
2070 #
2071 # Helpers and utility functions
2072 #
2073
2074 # Configuration file reading #########################################
2075
2076 # Helper function to implement conditional inheritance depending on the
2077 # value of $no_asm.  Used in inherit_from values as follows:
2078 #
2079 #      inherit_from => [ "template", asm("asm_tmpl") ]
2080 #
2081 sub asm {
2082     my @x = @_;
2083     sub {
2084         $no_asm ? () : @x;
2085     }
2086 }
2087
2088 # configuration reader, evaluates the input file as a perl script and expects
2089 # it to fill %targets with target configurations.  Those are then added to
2090 # %table.
2091 sub read_config {
2092     my $fname = shift;
2093     open(CONFFILE, "< $fname")
2094         or die "Can't open configuration file '$fname'!\n";
2095     my $x = $/;
2096     undef $/;
2097     my $content = <CONFFILE>;
2098     $/ = $x;
2099     close(CONFFILE);
2100     my %targets = ();
2101     {
2102         local %table = %::table;    # Protect %table from tampering
2103
2104         eval $content;
2105         warn $@ if $@;
2106     }
2107
2108     # For each target, check that it's configured with a hash table.
2109     foreach (keys %targets) {
2110         if (ref($targets{$_}) ne "HASH") {
2111             if (ref($targets{$_}) eq "") {
2112                 warn "Deprecated target configuration for $_, ignoring...\n";
2113             } else {
2114                 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
2115             }
2116             delete $targets{$_};
2117         }
2118     }
2119
2120     %table = (%table, %targets);
2121
2122 }
2123
2124 # configuration resolver.  Will only resolve all the lazy evalutation
2125 # codeblocks for the chozen target and all those it inherits from,
2126 # recursively
2127 sub resolve_config {
2128     my $target = shift;
2129     my @breadcrumbs = @_;
2130
2131     if (grep { $_ eq $target } @breadcrumbs) {
2132         die "inherit_from loop!  target backtrace:\n  "
2133             ,$target,"\n  ",join("\n  ", @breadcrumbs),"\n";
2134     }
2135
2136     if (!defined($table{$target})) {
2137         warn "Warning! target $target doesn't exist!\n";
2138         return ();
2139     }
2140     # Recurse through all inheritances.  They will be resolved on the
2141     # fly, so when this operation is done, they will all just be a
2142     # bunch of attributes with string values.
2143     # What we get here, though, are keys with references to lists of
2144     # the combined values of them all.  We will deal with lists after
2145     # this stage is done.
2146     my %combined_inheritance = ();
2147     if ($table{$target}->{inherit_from}) {
2148         my @inherit_from =
2149             map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
2150         foreach (@inherit_from) {
2151             my %inherited_config = resolve_config($_, $target, @breadcrumbs);
2152
2153             # 'template' is a marker that's considered private to
2154             # the config that had it.
2155             delete $inherited_config{template};
2156
2157             map {
2158                 if (!$combined_inheritance{$_}) {
2159                     $combined_inheritance{$_} = [];
2160                 }
2161                 push @{$combined_inheritance{$_}}, $inherited_config{$_};
2162             } keys %inherited_config;
2163         }
2164     }
2165
2166     # We won't need inherit_from in this target any more, since we've
2167     # resolved all the inheritances that lead to this
2168     delete $table{$target}->{inherit_from};
2169
2170     # Now is the time to deal with those lists.  Here's the place to
2171     # decide what shall be done with those lists, all based on the
2172     # values of the target we're currently dealing with.
2173     # - If a value is a coderef, it will be executed with the list of
2174     #   inherited values as arguments.
2175     # - If the corresponding key doesn't have a value at all or is the
2176     #   emoty string, the inherited value list will be run through the
2177     #   default combiner (below), and the result becomes this target's
2178     #   value.
2179     # - Otherwise, this target's value is assumed to be a string that
2180     #   will simply override the inherited list of values.
2181     my $default_combiner = sub { join(' ',@_) };
2182
2183     my %all_keys =
2184         map { $_ => 1 } (keys %combined_inheritance,
2185                          keys %{$table{$target}});
2186     foreach (sort keys %all_keys) {
2187
2188         # Current target doesn't have a value for the current key?
2189         # Assign it the default combiner, the rest of this loop body
2190         # will handle it just like any other coderef.
2191         if (!exists $table{$target}->{$_}) {
2192             $table{$target}->{$_} = $default_combiner;
2193         }
2194
2195         my $valuetype = ref($table{$target}->{$_});
2196         if ($valuetype eq "CODE") {
2197             # CODE reference, execute it with the inherited values as
2198             # arguments.
2199             $table{$target}->{$_} =
2200                 $table{$target}->{$_}->(@{$combined_inheritance{$_}});
2201         } elsif ($valuetype eq "") {
2202             # Scalar, just leave it as is.
2203         } else {
2204             # Some other type of reference that we don't handle.
2205             # Better to abort at this point.
2206             die "cannot handle reference type $valuetype,"
2207                 ," found in target $target -> $_\n";
2208         }
2209     }
2210
2211     # Finally done, return the result.
2212     return %{$table{$target}};
2213 }
2214
2215 sub usage
2216         {
2217         print STDERR $usage;
2218         print STDERR "\npick os/compiler from:\n";
2219         my $j=0;
2220         my $i;
2221         my $k=0;
2222         foreach $i (sort keys %table)
2223                 {
2224                 next if $table{$i}->{template};
2225                 next if $i =~ /^debug/;
2226                 $k += length($i) + 1;
2227                 if ($k > 78)
2228                         {
2229                         print STDERR "\n";
2230                         $k=length($i);
2231                         }
2232                 print STDERR $i . " ";
2233                 }
2234         foreach $i (sort keys %table)
2235                 {
2236                 next if $table{$i}->{template};
2237                 next if $i !~ /^debug/;
2238                 $k += length($i) + 1;
2239                 if ($k > 78)
2240                         {
2241                         print STDERR "\n";
2242                         $k=length($i);
2243                         }
2244                 print STDERR $i . " ";
2245                 }
2246         print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
2247         exit(1);
2248         }
2249
2250 sub which
2251         {
2252         my($name)=@_;
2253         my $path;
2254         foreach $path (split /:/, $ENV{PATH})
2255                 {
2256                 if (-f "$path/$name$exe_ext" and -x _)
2257                         {
2258                         return "$path/$name$exe_ext" unless ($name eq "perl" and
2259                          system("$path/$name$exe_ext -e " . '\'exit($]<5.0);\''));
2260                         }
2261                 }
2262         }
2263
2264 sub dofile
2265         {
2266         my $f; my $p; my %m; my @a; my $k; my $ff;
2267         ($f,$p,%m)=@_;
2268
2269         open(IN,"<$f.in") || open(IN,"<$f") || die "unable to open $f:$!\n";
2270         @a=<IN>;
2271         close(IN);
2272         foreach $k (keys %m)
2273                 {
2274                 grep(/$k/ && ($_=sprintf($m{$k}."\n",$p)),@a);
2275                 }
2276         open(OUT,">$f.new") || die "unable to open $f.new:$!\n";
2277         print OUT @a;
2278         close(OUT);
2279         rename($f,"$f.bak") || die "unable to rename $f\n" if -e $f;
2280         rename("$f.new",$f) || die "unable to rename $f.new\n";
2281         }
2282
2283 sub print_table_entry
2284         {
2285         my $target = shift;
2286         my %target = resolve_config($target);
2287         my $type = shift;
2288
2289         # Don't print the templates
2290         return if $target{template};
2291
2292         if ($type eq "TABLE") {
2293             print <<"EOF"
2294
2295 *** $target
2296 \$cc           = $target{cc}
2297 \$cflags       = $target{cflags}
2298 \$debug_cflags   = $target{debug_cflags}
2299 \$release_cflags = $target{release_cflags}
2300 \$unistd       = $target{unistd}
2301 \$thread_cflag = $target{thread_cflag}
2302 \$sys_id       = $target{sys_id}
2303 \$lflags       = $target{lflags}
2304 \$debug_lflags   = $target{debug_lflags}
2305 \$release_lflags = $target{release_lflags}
2306 \$bn_ops       = $target{bn_ops}
2307 \$cpuid_obj    = $target{cpuid_obj}
2308 \$bn_obj       = $target{bn_obj}
2309 \$ec_obj       = $target{ec_obj}
2310 \$des_obj      = $target{des_obj}
2311 \$aes_obj      = $target{aes_obj}
2312 \$bf_obj       = $target{bf_obj}
2313 \$md5_obj      = $target{md5_obj}
2314 \$sha1_obj     = $target{sha1_obj}
2315 \$cast_obj     = $target{cast_obj}
2316 \$rc4_obj      = $target{rc4_obj}
2317 \$rmd160_obj   = $target{rmd160_obj}
2318 \$rc5_obj      = $target{rc5_obj}
2319 \$wp_obj       = $target{wp_obj}
2320 \$cmll_obj     = $target{cmll_obj}
2321 \$modes_obj    = $target{modes_obj}
2322 \$engines_obj  = $target{engines_obj}
2323 \$chacha_obj   = $target{chacha_obj}
2324 \$poly1305_obj = $target{poly1305_obj}
2325 \$perlasm_scheme = $target{perlasm_scheme}
2326 \$dso_scheme   = $target{dso_scheme}
2327 \$shared_target= $target{shared_target}
2328 \$shared_cflag = $target{shared_cflag}
2329 \$shared_ldflag = $target{shared_ldflag}
2330 \$shared_extension = $target{shared_extension}
2331 \$ranlib       = $target{ranlib}
2332 \$arflags      = $target{arflags}
2333 \$multilib     = $target{multilib}
2334 EOF
2335         } elsif ($type eq "HASH") {
2336             my @sequence = (
2337                 "cc",
2338                 "cflags",
2339                 "debug_cflags",
2340                 "release_cflags",
2341                 "unistd",
2342                 "thread_cflag",
2343                 "sys_id",
2344                 "lflags",
2345                 "debug_lflags",
2346                 "release_lflags",
2347                 "bn_ops",
2348                 "cpuid_obj",
2349                 "bn_obj",
2350                 "ec_obj",
2351                 "des_obj",
2352                 "aes_obj",
2353                 "bf_obj",
2354                 "md5_obj",
2355                 "sha1_obj",
2356                 "cast_obj",
2357                 "rc4_obj",
2358                 "rmd160_obj",
2359                 "rc5_obj",
2360                 "wp_obj",
2361                 "cmll_obj",
2362                 "modes_obj",
2363                 "engines_obj",
2364                 "chacha_obj",
2365                 "poly1305_obj",
2366                 "perlasm_scheme",
2367                 "dso_scheme",
2368                 "shared_target",
2369                 "shared_cflag",
2370                 "shared_ldflag",
2371                 "shared_extension",
2372                 "ranlib",
2373                 "arflags",
2374                 "multilib",
2375                 );
2376             my $largest =
2377                 length((sort { length($a) <=> length($b) } @sequence)[-1]);
2378             print "    '$target' => {\n";
2379             foreach (@sequence) {
2380                 if ($target{$_}) {
2381                     print "      '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
2382                 }
2383             }
2384             print "    },\n";
2385         }
2386         }