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