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