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