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