b6672a026726f69f415c9403455a995b5e72650e
[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     "dtls",
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                                 my $config_args_found=0;
1036                                 while (<IN>)
1037                                         {
1038                                         chomp;
1039                                         if (/^CONFIGURE_ARGS=(.*)/)
1040                                                 {
1041                                                 $argvstring=$1;
1042                                                 @argvcopy=split(' ',$argvstring);
1043                                                 die "Incorrect data to reconfigure, please do a normal configuration\n"
1044                                                         if (grep(/^reconf/,@argvcopy));
1045                                                 print "Reconfiguring with: $argvstring\n";
1046                                                 $argv_unprocessed=1;
1047                                                 $config_args_found=1;
1048                                                 }
1049                                         elsif (/^CROSS_COMPILE=\s*(.*)/)
1050                                                 {
1051                                                 $ENV{CROSS_COMPILE}=$1;
1052                                                 }
1053                                         elsif (/^CC=\s*(?:\$\(CROSS_COMPILE\))?(.*?)/)
1054                                                 {
1055                                                 $ENV{CC}=$1;
1056                                                 }
1057                                         }
1058                                 close(IN);
1059                                 last PROCESS_ARGS if ($config_args_found);
1060                                 }
1061                         die "Insufficient data to reconfigure, please do a normal configuration\n";
1062                         }
1063                 elsif (/^386$/)
1064                         { $processor=386; }
1065                 elsif (/^fips$/)
1066                         {
1067                         $fips=1;
1068                         }
1069                 elsif (/^rsaref$/)
1070                         {
1071                         # No RSAref support any more since it's not needed.
1072                         # The check for the option is there so scripts aren't
1073                         # broken
1074                         }
1075                 elsif (/^nofipscanistercheck$/)
1076                         {
1077                         $fips = 1;
1078                         $nofipscanistercheck = 1;
1079                         }
1080                 elsif (/^[-+]/)
1081                         {
1082                         if (/^--prefix=(.*)$/)
1083                                 {
1084                                 $prefix=$1;
1085                                 }
1086                         elsif (/^--libdir=(.*)$/)
1087                                 {
1088                                 $libdir=$1;
1089                                 }
1090                         elsif (/^--openssldir=(.*)$/)
1091                                 {
1092                                 $openssldir=$1;
1093                                 }
1094                         elsif (/^--install.prefix=(.*)$/)
1095                                 {
1096                                 $install_prefix=$1;
1097                                 }
1098                         elsif (/^--with-zlib-lib=(.*)$/)
1099                                 {
1100                                 $withargs{"zlib-lib"}=$1;
1101                                 }
1102                         elsif (/^--with-zlib-include=(.*)$/)
1103                                 {
1104                                 $withargs{"zlib-include"}="-I$1";
1105                                 }
1106                         elsif (/^--with-fipslibdir=(.*)$/)
1107                                 {
1108                                 $fipslibdir="$1/";
1109                                 }
1110                         elsif (/^--with-baseaddr=(.*)$/)
1111                                 {
1112                                 $baseaddr="$1";
1113                                 }
1114                         elsif (/^--cross-compile-prefix=(.*)$/)
1115                                 {
1116                                 $cross_compile_prefix=$1;
1117                                 }
1118                         elsif (/^--config=(.*)$/)
1119                                 {
1120                                 read_config $1;
1121                                 }
1122                         elsif (/^-[lL](.*)$/ or /^-Wl,/)
1123                                 {
1124                                 $libs.=$_." ";
1125                                 }
1126                         else    # common if (/^[-+]/), just pass down...
1127                                 {
1128                                 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
1129                                 $flags.=$_." ";
1130                                 }
1131                         }
1132                 elsif ($_ =~ /^([^:]+):(.+)$/)
1133                         {
1134                         eval "\$table{\$1} = \"$2\""; # allow $xxx constructs in the string
1135                         $target=$1;
1136                         }
1137                 else
1138                         {
1139                         die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
1140                         $target=$_;
1141                         }
1142
1143                 unless ($_ eq $target || /^no-/ || /^disable-/)
1144                         {
1145                         # "no-..." follows later after implied disactivations
1146                         # have been derived.  (Don't take this too seroiusly,
1147                         # we really only write OPTIONS to the Makefile out of
1148                         # nostalgia.)
1149
1150                         if ($options eq "")
1151                                 { $options = $_; }
1152                         else
1153                                 { $options .= " ".$_; }
1154                         }
1155                 }
1156
1157         if (keys %unsupported_options)
1158                 {
1159                 die "***** Unsupported options: ",
1160                         join(", ", keys %unsupported_options), "\n";
1161                 }
1162         }
1163         }
1164
1165
1166 if ($processor eq "386")
1167         {
1168         $disabled{"sse2"} = "forced";
1169         }
1170
1171 if (!defined($disabled{"zlib-dynamic"}))
1172         {
1173         # "zlib-dynamic" was specifically enabled, so enable "zlib"
1174         delete $disabled{"zlib"};
1175         }
1176
1177 if (defined($disabled{"rijndael"}))
1178         {
1179         $disabled{"aes"} = "forced";
1180         }
1181 if (defined($disabled{"des"}))
1182         {
1183         $disabled{"mdc2"} = "forced";
1184         }
1185 if (defined($disabled{"ec"}))
1186         {
1187         $disabled{"ecdsa"} = "forced";
1188         $disabled{"ecdh"} = "forced";
1189         }
1190
1191 # SSL 3.0 and TLS requires MD5 and SHA and either RSA or DSA+DH
1192 if (defined($disabled{"md5"}) || defined($disabled{"sha"})
1193     || (defined($disabled{"rsa"})
1194         && (defined($disabled{"dsa"}) || defined($disabled{"dh"}))))
1195         {
1196         $disabled{"ssl3"} = "forced";
1197         $disabled{"tls1"} = "forced";
1198         }
1199
1200
1201 if (defined($disabled{"ec"}) || defined($disabled{"dsa"})
1202     || defined($disabled{"dh"}) || defined($disabled{"stdio"}))
1203         {
1204         $disabled{"gost"} = "forced";
1205         }
1206
1207
1208 if ($target eq "TABLE") {
1209         foreach $target (sort keys %table) {
1210                 print_table_entry($target, "TABLE");
1211         }
1212         exit 0;
1213 }
1214
1215 if ($target eq "LIST") {
1216         foreach (sort keys %table) {
1217                 print;
1218                 print "\n";
1219         }
1220         exit 0;
1221 }
1222
1223 if ($target eq "HASH") {
1224         print "%table = (\n";
1225         foreach (sort keys %table) {
1226                 print_table_entry($_, "HASH");
1227         }
1228         exit 0;
1229 }
1230
1231 if ($target =~ m/^CygWin32(-.*)$/) {
1232         $target = "Cygwin".$1;
1233 }
1234
1235 print "Configuring for $target\n";
1236
1237 # Support for legacy targets having a name starting with 'debug-'
1238 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
1239 if ($d) {
1240     $build_prefix = "debug_";
1241
1242     # If we do not find debug-foo in the table, the target is set to foo,
1243     # but only if the foo target has a noon-empty debug_cflags or debug_lflags
1244     # attribute.
1245     if (!$table{$target} && ($table{$t}->{debug_cflags}
1246                              || $table{$t}->{debug_lflags})) {
1247         $target = $t;
1248     }
1249 }
1250
1251 &usage if (!defined($table{$target})
1252            || $table{$target}->{template}
1253            || ($build_prefix eq "debug_"
1254                && $target !~ /^debug-/
1255                && !($table{$target}->{debug_cflags}
1256                     || $table{$target}->{debug_lflags})));
1257
1258 if ($fips)
1259         {
1260         delete $disabled{"shared"} if ($disabled{"shared"} eq "default");
1261         }
1262
1263 foreach (sort (keys %disabled))
1264         {
1265         $options .= " no-$_";
1266
1267         printf "    no-%-12s %-10s", $_, "[$disabled{$_}]";
1268
1269         if (/^dso$/)
1270                 { $no_dso = 1; }
1271         elsif (/^threads$/)
1272                 { $no_threads = 1; }
1273         elsif (/^shared$/)
1274                 { $no_shared = 1; }
1275         elsif (/^zlib$/)
1276                 { $zlib = 0; }
1277         elsif (/^static-engine$/)
1278                 { }
1279         elsif (/^zlib-dynamic$/)
1280                 { }
1281         elsif (/^sse2$/)
1282                 { $no_sse2 = 1; }
1283         else
1284                 {
1285                 my ($ALGO, $algo);
1286                 ($ALGO = $algo = $_) =~ tr/[\-a-z]/[_A-Z]/;
1287
1288                 if (/^asm$/ || /^err$/ || /^hw$/ || /^hw-/)
1289                         {
1290                         $openssl_other_defines .= "#define OPENSSL_NO_$ALGO\n";
1291                         print " OPENSSL_NO_$ALGO";
1292
1293                         if (/^err$/)    { $flags .= "-DOPENSSL_NO_ERR "; }
1294                         elsif (/^asm$/) { $no_asm = 1; }
1295                         }
1296                 else
1297                         {
1298                         ($ALGO,$algo) = ("RMD160","rmd160") if ($algo eq "ripemd");
1299
1300                         $openssl_algorithm_defines .= "#define OPENSSL_NO_$ALGO\n";
1301                         print " OPENSSL_NO_$ALGO";
1302
1303                         push @skip, $algo;
1304                         # fix-up crypto/directory name(s)
1305                         $skip[$#skip]="whrlpool" if $algo eq "whirlpool";
1306                         $skip[$#skip]="ripemd" if $algo eq "rmd160";
1307
1308                         print " (skip dir)";
1309
1310                         $depflags .= " -DOPENSSL_NO_$ALGO";
1311                         }
1312                 }
1313
1314         print "\n";
1315         }
1316
1317 my $exp_cflags = "";
1318
1319 foreach (sort @experimental)
1320         {
1321         my $ALGO;
1322         ($ALGO = $_) =~ tr/[a-z]/[A-Z]/;
1323
1324         # opensslconf.h will set OPENSSL_NO_... unless OPENSSL_EXPERIMENTAL_... is defined
1325         $openssl_experimental_defines .= "#define OPENSSL_NO_$ALGO\n";
1326         $exp_cflags .= " -DOPENSSL_EXPERIMENTAL_$ALGO";
1327         }
1328
1329 my $IsMK1MF=scalar grep /^$target$/,@MK1MF_Builds;
1330
1331 $exe_ext=".exe" if ($target eq "Cygwin" || $target eq "DJGPP" || $target =~ /^mingw/);
1332 $exe_ext=".nlm" if ($target =~ /netware/);
1333 $exe_ext=".pm"  if ($target =~ /vos/);
1334 $openssldir="/usr/local/ssl" if ($openssldir eq "" and $prefix eq "");
1335 $prefix=$openssldir if $prefix eq "";
1336
1337 $default_ranlib= &which("ranlib") or $default_ranlib="true";
1338 $perl=$ENV{'PERL'} or $perl=&which("perl5") or $perl=&which("perl")
1339   or $perl="perl";
1340 my $make = $ENV{'MAKE'} || "make";
1341
1342 $cross_compile_prefix=$ENV{'CROSS_COMPILE'} if $cross_compile_prefix eq "";
1343
1344 chop $openssldir if $openssldir =~ /\/$/;
1345 chop $prefix if $prefix =~ /.\/$/;
1346
1347 $openssldir=$prefix . "/ssl" if $openssldir eq "";
1348 $openssldir=$prefix . "/" . $openssldir if $openssldir !~ /(^\/|^[a-zA-Z]:[\\\/])/;
1349
1350
1351 print "IsMK1MF=$IsMK1MF\n";
1352
1353 # Allow environment CC to override compiler...
1354 my $cc = $ENV{CC} || $table{$target}->{cc};
1355
1356 # For cflags and lflags, add the debug_ or release_ attributes
1357 # Do it in such a way that no spurious space is appended (hence the grep).
1358 my $cflags = join(" ",
1359                   grep { $_ } ($table{$target}->{cflags},
1360                                $table{$target}->{$build_prefix."cflags"}));
1361 my $lflags = join(" ",
1362                   grep { $_ } ($table{$target}->{lflags},
1363                                $table{$target}->{$build_prefix."lflags"}));
1364
1365 my $unistd = $table{$target}->{unistd};
1366 my $thread_cflag = $table{$target}->{thread_cflag};
1367 my $sys_id = $table{$target}->{sys_id};
1368 my $bn_ops = $table{$target}->{bn_ops};
1369 my $cpuid_obj = $table{$target}->{cpuid_obj};
1370 my $bn_obj = $table{$target}->{bn_obj};
1371 my $ec_obj = $table{$target}->{ec_obj};
1372 my $des_obj = $table{$target}->{des_obj};
1373 my $aes_obj = $table{$target}->{aes_obj};
1374 my $bf_obj = $table{$target}->{bf_obj};
1375 my $md5_obj = $table{$target}->{md5_obj};
1376 my $sha1_obj = $table{$target}->{sha1_obj};
1377 my $cast_obj = $table{$target}->{cast_obj};
1378 my $rc4_obj = $table{$target}->{rc4_obj};
1379 my $rmd160_obj = $table{$target}->{rmd160_obj};
1380 my $rc5_obj = $table{$target}->{rc5_obj};
1381 my $wp_obj = $table{$target}->{wp_obj};
1382 my $cmll_obj = $table{$target}->{cmll_obj};
1383 my $modes_obj = $table{$target}->{modes_obj};
1384 my $engines_obj = $table{$target}->{engines_obj};
1385 my $perlasm_scheme = $table{$target}->{perlasm_scheme};
1386 my $dso_scheme = $table{$target}->{dso_scheme};
1387 my $shared_target = $table{$target}->{shared_target};
1388 my $shared_cflag = $table{$target}->{shared_cflag};
1389 my $shared_ldflag = $table{$target}->{shared_ldflag};
1390 my $shared_extension = $table{$target}->{shared_extension};
1391 my $ranlib = $ENV{'RANLIB'} || $table{$target}->{ranlib};
1392 my $ar = $ENV{'AR'} || "ar";
1393 my $arflags = $table{$target}->{arflags};
1394 my $multilib = $table{$target}->{multilib};
1395
1396 # if $prefix/lib$multilib is not an existing directory, then
1397 # assume that it's not searched by linker automatically, in
1398 # which case adding $multilib suffix causes more grief than
1399 # we're ready to tolerate, so don't...
1400 $multilib="" if !-d "$prefix/lib$multilib";
1401
1402 $libdir="lib$multilib" if $libdir eq "";
1403
1404 $cflags = "$cflags$exp_cflags";
1405
1406 # '%' in $lflags is used to split flags to "pre-" and post-flags
1407 my ($prelflags,$postlflags)=split('%',$lflags);
1408 if (defined($postlflags))       { $lflags=$postlflags;  }
1409 else                            { $lflags=$prelflags; undef $prelflags; }
1410
1411 if ($target =~ /^mingw/ && `$cc --target-help 2>&1` !~ m/\-mno\-cygwin/m)
1412         {
1413         $cflags =~ s/\-mno\-cygwin\s*//;
1414         $shared_ldflag =~ s/\-mno\-cygwin\s*//;
1415         }
1416
1417 if ($target =~ /linux.*\-mips/ && !$no_asm && $flags !~ /\-m(ips|arch=)/) {
1418         # minimally required architecture flags for assembly modules
1419         $cflags="-mips2 $cflags" if ($target =~ /mips32/);
1420         $cflags="-mips3 $cflags" if ($target =~ /mips64/);
1421 }
1422
1423 my $no_shared_warn=0;
1424 my $no_user_cflags=0;
1425
1426 if ($flags ne "")       { $cflags="$flags$cflags"; }
1427 else                    { $no_user_cflags=1;       }
1428
1429 # The DSO code currently always implements all functions so that no
1430 # applications will have to worry about that from a compilation point
1431 # of view. However, the "method"s may return zero unless that platform
1432 # has support compiled in for them. Currently each method is enabled
1433 # by a define "DSO_<name>" ... we translate the "dso_scheme" config
1434 # string entry into using the following logic;
1435 my $dso_cflags;
1436 if (!$no_dso && $dso_scheme ne "")
1437         {
1438         $dso_scheme =~ tr/[a-z]/[A-Z]/;
1439         if ($dso_scheme eq "DLFCN")
1440                 {
1441                 $dso_cflags = "-DDSO_DLFCN -DHAVE_DLFCN_H";
1442                 }
1443         elsif ($dso_scheme eq "DLFCN_NO_H")
1444                 {
1445                 $dso_cflags = "-DDSO_DLFCN";
1446                 }
1447         else
1448                 {
1449                 $dso_cflags = "-DDSO_$dso_scheme";
1450                 }
1451         $cflags = "$dso_cflags $cflags";
1452         }
1453
1454 my $thread_cflags;
1455 my $thread_defines;
1456 if ($thread_cflag ne "(unknown)" && !$no_threads)
1457         {
1458         # If we know how to do it, support threads by default.
1459         $threads = 1;
1460         }
1461 if ($thread_cflag eq "(unknown)" && $threads)
1462         {
1463         # If the user asked for "threads", [s]he is also expected to
1464         # provide any system-dependent compiler options that are
1465         # necessary.
1466         if ($no_user_cflags)
1467                 {
1468                 print "You asked for multi-threading support, but didn't\n";
1469                 print "provide any system-specific compiler options\n";
1470                 exit(1);
1471                 }
1472         $thread_cflags="-DOPENSSL_THREADS $cflags" ;
1473         $thread_defines .= "#define OPENSSL_THREADS\n";
1474         }
1475 else
1476         {
1477         $thread_cflags="-DOPENSSL_THREADS $thread_cflag $cflags";
1478         $thread_defines .= "#define OPENSSL_THREADS\n";
1479 #       my $def;
1480 #       foreach $def (split ' ',$thread_cflag)
1481 #               {
1482 #               if ($def =~ s/^-D// && $def !~ /^_/)
1483 #                       {
1484 #                       $thread_defines .= "#define $def\n";
1485 #                       }
1486 #               }
1487         }
1488
1489 $lflags="$libs$lflags" if ($libs ne "");
1490
1491 if ($no_asm)
1492         {
1493         $cpuid_obj=$bn_obj=$ec_obj=
1494         $des_obj=$aes_obj=$bf_obj=$cast_obj=$rc4_obj=$rc5_obj=$cmll_obj=
1495         $modes_obj=$sha1_obj=$md5_obj=$rmd160_obj=$wp_obj=$engines_obj="";
1496         $cflags=~s/\-D[BL]_ENDIAN//             if ($fips);
1497         $thread_cflags=~s/\-D[BL]_ENDIAN//      if ($fips);
1498         }
1499 elsif (defined($disabled{ec2m}))
1500         {
1501         $bn_obj =~ s/\w+-gf2m.o//;
1502         }
1503
1504 if (!$no_shared)
1505         {
1506         $cast_obj="";   # CAST assembler is not PIC
1507         }
1508
1509 if ($threads)
1510         {
1511         $cflags=$thread_cflags;
1512         $openssl_thread_defines .= $thread_defines;
1513         }
1514
1515 if ($zlib)
1516         {
1517         $cflags = "-DZLIB $cflags";
1518         if (defined($disabled{"zlib-dynamic"}))
1519                 {
1520                 if (defined($withargs{"zlib-lib"}))
1521                         {
1522                         $lflags = "$lflags -L" . $withargs{"zlib-lib"} . " -lz";
1523                         }
1524                 else
1525                         {
1526                         $lflags = "$lflags -lz";
1527                         }
1528                 }
1529         else
1530                 {
1531                 $cflags = "-DZLIB_SHARED $cflags";
1532                 }
1533         }
1534
1535 #Build the library with OPENSSL_USE_DEPRECATED if deprecation is not disabled
1536 if(!defined($disabled{"deprecated"}))
1537         {
1538         $cflags = "-DOPENSSL_USE_DEPRECATED $cflags";
1539         }
1540
1541 # You will find shlib_mark1 and shlib_mark2 explained in Makefile.org
1542 my $shared_mark = "";
1543 if ($shared_target eq "")
1544         {
1545         $no_shared_warn = 1 if !$no_shared && !$fips;
1546         $no_shared = 1;
1547         }
1548 if (!$no_shared)
1549         {
1550         if ($shared_cflag ne "")
1551                 {
1552                 $cflags = "$shared_cflag -DOPENSSL_PIC $cflags";
1553                 }
1554         }
1555
1556 if (!$IsMK1MF)
1557         {
1558         # add {no-}static-engine to options to allow mkdef.pl to work without extra arguments
1559         if ($no_shared)
1560                 {
1561                 $openssl_other_defines.="#define OPENSSL_NO_DYNAMIC_ENGINE\n";
1562                 $options.=" static-engine";
1563                 }
1564         else
1565                 {
1566                 $openssl_other_defines.="#define OPENSSL_NO_STATIC_ENGINE\n";
1567                 $options.=" no-static-engine";
1568                 }
1569         }
1570
1571 $cpuid_obj.=" uplink.o uplink-x86.o" if ($cflags =~ /\-DOPENSSL_USE_APPLINK/);
1572
1573 #
1574 # Platform fix-ups
1575 #
1576 if ($target =~ /\-icc$/)        # Intel C compiler
1577         {
1578         my $iccver=0;
1579         if (open(FD,"$cc -V 2>&1 |"))
1580                 {
1581                 while(<FD>) { $iccver=$1 if (/Version ([0-9]+)\./); }
1582                 close(FD);
1583                 }
1584         if ($iccver>=8)
1585                 {
1586                 $cflags=~s/\-KPIC/-fPIC/;
1587                 # Eliminate unnecessary dependency from libirc.a. This is
1588                 # essential for shared library support, as otherwise
1589                 # apps/openssl can end up in endless loop upon startup...
1590                 $cflags.=" -Dmemcpy=__builtin_memcpy -Dmemset=__builtin_memset";
1591                 }
1592         if ($iccver>=9)
1593                 {
1594                 $lflags.=" -i-static";
1595                 $lflags=~s/\-no_cpprt/-no-cpprt/;
1596                 }
1597         if ($iccver>=10)
1598                 {
1599                 $lflags=~s/\-i\-static/-static-intel/;
1600                 }
1601         if ($iccver>=11)
1602                 {
1603                 $cflags.=" -no-intel-extensions";       # disable Cilk
1604                 $lflags=~s/\-no\-cpprt/-no-cxxlib/;
1605                 }
1606         }
1607
1608 # Unlike other OSes (like Solaris, Linux, Tru64, IRIX) BSD run-time
1609 # linkers (tested OpenBSD, NetBSD and FreeBSD) "demand" RPATH set on
1610 # .so objects. Apparently application RPATH is not global and does
1611 # not apply to .so linked with other .so. Problem manifests itself
1612 # when libssl.so fails to load libcrypto.so. One can argue that we
1613 # should engrave this into Makefile.shared rules or into BSD-* config
1614 # lines above. Meanwhile let's try to be cautious and pass -rpath to
1615 # linker only when --prefix is not /usr.
1616 if ($target =~ /^BSD\-/)
1617         {
1618         $shared_ldflag.=" -Wl,-rpath,\$(LIBRPATH)" if ($prefix !~ m|^/usr[/]*$|);
1619         }
1620
1621 if ($sys_id ne "")
1622         {
1623         #$cflags="-DOPENSSL_SYS_$sys_id $cflags";
1624         $openssl_sys_defines="#define OPENSSL_SYS_$sys_id\n";
1625         }
1626
1627 if ($ranlib eq "")
1628         {
1629         $ranlib = $default_ranlib;
1630         }
1631
1632 #my ($bn1)=split(/\s+/,$bn_obj);
1633 #$bn1 = "" unless defined $bn1;
1634 #$bn1=$bn_asm unless ($bn1 =~ /\.o$/);
1635 #$bn_obj="$bn1";
1636
1637 $cpuid_obj="" if ($processor eq "386");
1638
1639 $bn_obj = $bn_asm unless $bn_obj ne "";
1640 # bn-586 is the only one implementing bn_*_part_words
1641 $cflags.=" -DOPENSSL_BN_ASM_PART_WORDS" if ($bn_obj =~ /bn-586/);
1642 $cflags.=" -DOPENSSL_IA32_SSE2" if (!$no_sse2 && $bn_obj =~ /86/);
1643
1644 $cflags.=" -DOPENSSL_BN_ASM_MONT" if ($bn_obj =~ /-mont/);
1645 $cflags.=" -DOPENSSL_BN_ASM_MONT5" if ($bn_obj =~ /-mont5/);
1646 $cflags.=" -DOPENSSL_BN_ASM_GF2m" if ($bn_obj =~ /-gf2m/);
1647
1648 if ($fips)
1649         {
1650         $openssl_other_defines.="#define OPENSSL_FIPS\n";
1651         }
1652
1653 $cpuid_obj="mem_clr.o"  unless ($cpuid_obj =~ /\.o$/);
1654 $des_obj=$des_enc       unless ($des_obj =~ /\.o$/);
1655 $bf_obj=$bf_enc         unless ($bf_obj =~ /\.o$/);
1656 $cast_obj=$cast_enc     unless ($cast_obj =~ /\.o$/);
1657 $rc4_obj=$rc4_enc       unless ($rc4_obj =~ /\.o$/);
1658 $rc5_obj=$rc5_enc       unless ($rc5_obj =~ /\.o$/);
1659 if ($sha1_obj =~ /\.o$/)
1660         {
1661 #       $sha1_obj=$sha1_enc;
1662         $cflags.=" -DSHA1_ASM"   if ($sha1_obj =~ /sx86/ || $sha1_obj =~ /sha1/);
1663         $cflags.=" -DSHA256_ASM" if ($sha1_obj =~ /sha256/);
1664         $cflags.=" -DSHA512_ASM" if ($sha1_obj =~ /sha512/);
1665         if ($sha1_obj =~ /sse2/)
1666             {   if ($no_sse2)
1667                 {   $sha1_obj =~ s/\S*sse2\S+//;        }
1668                 elsif ($cflags !~ /OPENSSL_IA32_SSE2/)
1669                 {   $cflags.=" -DOPENSSL_IA32_SSE2";    }
1670             }
1671         }
1672 if ($md5_obj =~ /\.o$/)
1673         {
1674 #       $md5_obj=$md5_enc;
1675         $cflags.=" -DMD5_ASM";
1676         }
1677 if ($rmd160_obj =~ /\.o$/)
1678         {
1679 #       $rmd160_obj=$rmd160_enc;
1680         $cflags.=" -DRMD160_ASM";
1681         }
1682 if ($aes_obj =~ /\.o$/)
1683         {
1684         $cflags.=" -DAES_ASM" if ($aes_obj =~ m/\baes\-/);;
1685         # aes-ctr.o is not a real file, only indication that assembler
1686         # module implements AES_ctr32_encrypt...
1687         $cflags.=" -DAES_CTR_ASM" if ($aes_obj =~ s/\s*aes\-ctr\.o//);
1688         # aes-xts.o indicates presence of AES_xts_[en|de]crypt...
1689         $cflags.=" -DAES_XTS_ASM" if ($aes_obj =~ s/\s*aes\-xts\.o//);
1690         $aes_obj =~ s/\s*(vpaes|aesni)\-x86\.o//g if ($no_sse2);
1691         $cflags.=" -DVPAES_ASM" if ($aes_obj =~ m/vpaes/);
1692         $cflags.=" -DBSAES_ASM" if ($aes_obj =~ m/bsaes/);
1693         }
1694 else    {
1695         $aes_obj=$aes_enc;
1696         }
1697 $wp_obj="" if ($wp_obj =~ /mmx/ && $processor eq "386");
1698 if ($wp_obj =~ /\.o$/ && !$disabled{"whirlpool"})
1699         {
1700         $cflags.=" -DWHIRLPOOL_ASM";
1701         }
1702 else    {
1703         $wp_obj="wp_block.o";
1704         }
1705 $cmll_obj=$cmll_enc     unless ($cmll_obj =~ /.o$/);
1706 if ($modes_obj =~ /ghash\-/)
1707         {
1708         $cflags.=" -DGHASH_ASM";
1709         }
1710 if ($ec_obj =~ /ecp_nistz256/)
1711         {
1712         $cflags.=" -DECP_NISTZ256_ASM";
1713         }
1714
1715 # "Stringify" the C flags string.  This permits it to be made part of a string
1716 # and works as well on command lines.
1717 $cflags =~ s/([\\\"])/\\\1/g;
1718
1719 my $version = "unknown";
1720 my $version_num = "unknown";
1721 my $major = "unknown";
1722 my $minor = "unknown";
1723 my $shlib_version_number = "unknown";
1724 my $shlib_version_history = "unknown";
1725 my $shlib_major = "unknown";
1726 my $shlib_minor = "unknown";
1727
1728 open(IN,'<include/openssl/opensslv.h') || die "unable to read opensslv.h:$!\n";
1729 while (<IN>)
1730         {
1731         $version=$1 if /OPENSSL.VERSION.TEXT.*OpenSSL (\S+) /;
1732         $version_num=$1 if /OPENSSL.VERSION.NUMBER.*0x(\S+)/;
1733         $shlib_version_number=$1 if /SHLIB_VERSION_NUMBER *"([^"]+)"/;
1734         $shlib_version_history=$1 if /SHLIB_VERSION_HISTORY *"([^"]*)"/;
1735         }
1736 close(IN);
1737 if ($shlib_version_history ne "") { $shlib_version_history .= ":"; }
1738
1739 if ($version =~ /(^[0-9]*)\.([0-9\.]*)/)
1740         {
1741         $major=$1;
1742         $minor=$2;
1743         }
1744
1745 if ($shlib_version_number =~ /(^[0-9]*)\.([0-9\.]*)/)
1746         {
1747         $shlib_major=$1;
1748         $shlib_minor=$2;
1749         }
1750
1751 my $ecc = $cc;
1752 $ecc = "clang" if `$cc --version 2>&1` =~ /clang/;
1753
1754 if ($strict_warnings)
1755         {
1756         my $wopt;
1757         die "ERROR --strict-warnings requires gcc or clang" unless ($ecc =~ /gcc(-\d(\.\d)*)?$/ or $ecc =~ /clang$/);
1758         foreach $wopt (split /\s+/, $gcc_devteam_warn)
1759                 {
1760                 $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/)
1761                 }
1762         if ($ecc eq "clang")
1763                 {
1764                 foreach $wopt (split /\s+/, $clang_devteam_warn)
1765                         {
1766                         $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/)
1767                         }
1768                 }
1769         if ($target !~ /^mingw/)
1770                 {
1771                 foreach $wopt (split /\s+/, $memleak_devteam_backtrace)
1772                         {
1773                         $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/)
1774                         }
1775                 if ($target =~ /^BSD-/)
1776                         {
1777                         $lflags .= " -lexecinfo";
1778                         }
1779                 }
1780         }
1781
1782 open(IN,"<Makefile.org") || die "unable to read Makefile.org:$!\n";
1783 unlink("$Makefile.new") || die "unable to remove old $Makefile.new:$!\n" if -e "$Makefile.new";
1784 open(OUT,">$Makefile.new") || die "unable to create $Makefile.new:$!\n";
1785 print OUT "### Generated automatically from Makefile.org by Configure.\n\n";
1786 my $sdirs=0;
1787
1788 while (<IN>)
1789         {
1790         chomp;
1791         $sdirs = 1 if /^SDIRS=/;
1792         if ($sdirs) {
1793                 my $dir;
1794                 foreach $dir (@skip) {
1795                         s/(\s)$dir /$1/;
1796                         s/\s$dir$//;
1797                         }
1798                 }
1799         $sdirs = 0 unless /\\$/;
1800         s/fips // if (/^DIRS=/ && !$fips);
1801         s/engines // if (/^DIRS=/ && $disabled{"engine"});
1802         s/ccgost// if (/^ENGDIRS=/ && $disabled{"gost"});
1803         s/^VERSION=.*/VERSION=$version/;
1804         s/^MAJOR=.*/MAJOR=$major/;
1805         s/^MINOR=.*/MINOR=$minor/;
1806         s/^SHLIB_VERSION_NUMBER=.*/SHLIB_VERSION_NUMBER=$shlib_version_number/;
1807         s/^SHLIB_VERSION_HISTORY=.*/SHLIB_VERSION_HISTORY=$shlib_version_history/;
1808         s/^SHLIB_MAJOR=.*/SHLIB_MAJOR=$shlib_major/;
1809         s/^SHLIB_MINOR=.*/SHLIB_MINOR=$shlib_minor/;
1810         s/^SHLIB_EXT=.*/SHLIB_EXT=$shared_extension/;
1811         s/^INSTALLTOP=.*$/INSTALLTOP=$prefix/;
1812         s/^MULTILIB=.*$/MULTILIB=$multilib/;
1813         s/^OPENSSLDIR=.*$/OPENSSLDIR=$openssldir/;
1814         s/^LIBDIR=.*$/LIBDIR=$libdir/;
1815         s/^INSTALL_PREFIX=.*$/INSTALL_PREFIX=$install_prefix/;
1816         s/^PLATFORM=.*$/PLATFORM=$target/;
1817         s/^OPTIONS=.*$/OPTIONS=$options/;
1818         s/^CONFIGURE_ARGS=.*$/CONFIGURE_ARGS=$argvstring/;
1819         if ($cross_compile_prefix)
1820                 {
1821                 s/^CC=.*$/CROSS_COMPILE= $cross_compile_prefix\nCC= \$\(CROSS_COMPILE\)$cc/;
1822                 s/^AR=\s*/AR= \$\(CROSS_COMPILE\)/;
1823                 s/^NM=\s*/NM= \$\(CROSS_COMPILE\)/;
1824                 s/^RANLIB=\s*/RANLIB= \$\(CROSS_COMPILE\)/;
1825                 s/^MAKEDEPPROG=.*$/MAKEDEPPROG= \$\(CROSS_COMPILE\)$cc/ if $cc eq "gcc";
1826                 }
1827         else    {
1828                 s/^CC=.*$/CC= $cc/;
1829                 s/^AR=\s*ar/AR= $ar/;
1830                 s/^RANLIB=.*/RANLIB= $ranlib/;
1831                 s/^MAKEDEPPROG=.*$/MAKEDEPPROG= $cc/ if $ecc eq "gcc" || $ecc eq "clang";
1832                 }
1833         s/^CFLAG=.*$/CFLAG= $cflags/;
1834         s/^DEPFLAG=.*$/DEPFLAG=$depflags/;
1835         s/^PEX_LIBS=.*$/PEX_LIBS= $prelflags/;
1836         s/^EX_LIBS=.*$/EX_LIBS= $lflags/;
1837         s/^EXE_EXT=.*$/EXE_EXT= $exe_ext/;
1838         s/^CPUID_OBJ=.*$/CPUID_OBJ= $cpuid_obj/;
1839         s/^BN_ASM=.*$/BN_ASM= $bn_obj/;
1840         s/^EC_ASM=.*$/EC_ASM= $ec_obj/;
1841         s/^DES_ENC=.*$/DES_ENC= $des_obj/;
1842         s/^AES_ENC=.*$/AES_ENC= $aes_obj/;
1843         s/^BF_ENC=.*$/BF_ENC= $bf_obj/;
1844         s/^CAST_ENC=.*$/CAST_ENC= $cast_obj/;
1845         s/^RC4_ENC=.*$/RC4_ENC= $rc4_obj/;
1846         s/^RC5_ENC=.*$/RC5_ENC= $rc5_obj/;
1847         s/^MD5_ASM_OBJ=.*$/MD5_ASM_OBJ= $md5_obj/;
1848         s/^SHA1_ASM_OBJ=.*$/SHA1_ASM_OBJ= $sha1_obj/;
1849         s/^RMD160_ASM_OBJ=.*$/RMD160_ASM_OBJ= $rmd160_obj/;
1850         s/^WP_ASM_OBJ=.*$/WP_ASM_OBJ= $wp_obj/;
1851         s/^CMLL_ENC=.*$/CMLL_ENC= $cmll_obj/;
1852         s/^MODES_ASM_OBJ.=*$/MODES_ASM_OBJ= $modes_obj/;
1853         s/^ENGINES_ASM_OBJ.=*$/ENGINES_ASM_OBJ= $engines_obj/;
1854         s/^PERLASM_SCHEME=.*$/PERLASM_SCHEME= $perlasm_scheme/;
1855         s/^PROCESSOR=.*/PROCESSOR= $processor/;
1856         s/^ARFLAGS=.*/ARFLAGS= $arflags/;
1857         s/^PERL=.*/PERL= $perl/;
1858         s/^LIBZLIB=.*/LIBZLIB=$withargs{"zlib-lib"}/;
1859         s/^ZLIB_INCLUDE=.*/ZLIB_INCLUDE=$withargs{"zlib-include"}/;
1860         s/^FIPSLIBDIR=.*/FIPSLIBDIR=$fipslibdir/;
1861         s/^FIPSCANLIB=.*/FIPSCANLIB=libcrypto/ if $fips;
1862         s/^SHARED_FIPS=.*/SHARED_FIPS=/;
1863         s/^SHLIBDIRS=.*/SHLIBDIRS= crypto ssl/;
1864         s/^BASEADDR=.*/BASEADDR=$baseaddr/;
1865         s/^SHLIB_TARGET=.*/SHLIB_TARGET=$shared_target/;
1866         s/^SHLIB_MARK=.*/SHLIB_MARK=$shared_mark/;
1867         s/^SHARED_LIBS=.*/SHARED_LIBS=\$(SHARED_CRYPTO) \$(SHARED_SSL)/ if (!$no_shared);
1868         if ($shared_extension ne "" && $shared_extension =~ /^\.s([ol])\.[^\.]*$/)
1869                 {
1870                 my $sotmp = $1;
1871                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.s$sotmp/;
1872                 }
1873         elsif ($shared_extension ne "" && $shared_extension =~ /^\.[^\.]*\.dylib$/)
1874                 {
1875                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.dylib/;
1876                 }
1877         elsif ($shared_extension ne "" && $shared_extension =~ /^\.s([ol])\.[^\.]*\.[^\.]*$/)
1878                 {
1879                 my $sotmp = $1;
1880                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.s$sotmp.\$(SHLIB_MAJOR) .s$sotmp/;
1881                 }
1882         elsif ($shared_extension ne "" && $shared_extension =~ /^\.[^\.]*\.[^\.]*\.dylib$/)
1883                 {
1884                 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.\$(SHLIB_MAJOR).dylib .dylib/;
1885                 }
1886         s/^SHARED_LDFLAGS=.*/SHARED_LDFLAGS=$shared_ldflag/;
1887         print OUT $_."\n";
1888         }
1889 close(IN);
1890 close(OUT);
1891 rename($Makefile,"$Makefile.bak") || die "unable to rename $Makefile\n" if -e $Makefile;
1892 rename("$Makefile.new",$Makefile) || die "unable to rename $Makefile.new\n";
1893
1894 print "CC            =$cc\n";
1895 print "CFLAG         =$cflags\n";
1896 print "EX_LIBS       =$lflags\n";
1897 print "CPUID_OBJ     =$cpuid_obj\n";
1898 print "BN_ASM        =$bn_obj\n";
1899 print "EC_ASM        =$ec_obj\n";
1900 print "DES_ENC       =$des_obj\n";
1901 print "AES_ENC       =$aes_obj\n";
1902 print "BF_ENC        =$bf_obj\n";
1903 print "CAST_ENC      =$cast_obj\n";
1904 print "RC4_ENC       =$rc4_obj\n";
1905 print "RC5_ENC       =$rc5_obj\n";
1906 print "MD5_OBJ_ASM   =$md5_obj\n";
1907 print "SHA1_OBJ_ASM  =$sha1_obj\n";
1908 print "RMD160_OBJ_ASM=$rmd160_obj\n";
1909 print "CMLL_ENC      =$cmll_obj\n";
1910 print "MODES_OBJ     =$modes_obj\n";
1911 print "ENGINES_OBJ   =$engines_obj\n";
1912 print "PROCESSOR     =$processor\n";
1913 print "RANLIB        =$ranlib\n";
1914 print "ARFLAGS       =$arflags\n";
1915 print "PERL          =$perl\n";
1916
1917 my $des_ptr=0;
1918 my $des_risc1=0;
1919 my $des_risc2=0;
1920 my $des_unroll=0;
1921 my $bn_ll=0;
1922 my $def_int=2;
1923 my $rc4_int=$def_int;
1924 my $md2_int=$def_int;
1925 my $idea_int=$def_int;
1926 my $rc2_int=$def_int;
1927 my $rc4_idx=0;
1928 my $rc4_chunk=0;
1929 my $bf_ptr=0;
1930 my @type=("char","short","int","long");
1931 my ($b64l,$b64,$b32,$b16,$b8)=(0,0,1,0,0);
1932 my $export_var_as_fn=0;
1933
1934 my $des_int;
1935
1936 foreach (sort split(/\s+/,$bn_ops))
1937         {
1938         $des_ptr=1 if /DES_PTR/;
1939         $des_risc1=1 if /DES_RISC1/;
1940         $des_risc2=1 if /DES_RISC2/;
1941         $des_unroll=1 if /DES_UNROLL/;
1942         $des_int=1 if /DES_INT/;
1943         $bn_ll=1 if /BN_LLONG/;
1944         $rc4_int=0 if /RC4_CHAR/;
1945         $rc4_int=3 if /RC4_LONG/;
1946         $rc4_idx=1 if /RC4_INDEX/;
1947         $rc4_chunk=1 if /RC4_CHUNK/;
1948         $rc4_chunk=2 if /RC4_CHUNK_LL/;
1949         $md2_int=0 if /MD2_CHAR/;
1950         $md2_int=3 if /MD2_LONG/;
1951         $idea_int=1 if /IDEA_SHORT/;
1952         $idea_int=3 if /IDEA_LONG/;
1953         $rc2_int=1 if /RC2_SHORT/;
1954         $rc2_int=3 if /RC2_LONG/;
1955         $bf_ptr=1 if $_ eq "BF_PTR";
1956         $bf_ptr=2 if $_ eq "BF_PTR2";
1957         ($b64l,$b64,$b32,$b16,$b8)=(0,1,0,0,0) if /SIXTY_FOUR_BIT/;
1958         ($b64l,$b64,$b32,$b16,$b8)=(1,0,0,0,0) if /SIXTY_FOUR_BIT_LONG/;
1959         ($b64l,$b64,$b32,$b16,$b8)=(0,0,1,0,0) if /THIRTY_TWO_BIT/;
1960         ($b64l,$b64,$b32,$b16,$b8)=(0,0,0,1,0) if /SIXTEEN_BIT/;
1961         ($b64l,$b64,$b32,$b16,$b8)=(0,0,0,0,1) if /EIGHT_BIT/;
1962         $export_var_as_fn=1 if /EXPORT_VAR_AS_FN/;
1963         }
1964
1965 open(IN,'<crypto/opensslconf.h.in') || die "unable to read crypto/opensslconf.h.in:$!\n";
1966 unlink("include/openssl/opensslconf.h.new") || die "unable to remove old include/openssl/opensslconf.h.new:$!\n" if -e "include/openssl/opensslconf.h.new";
1967 open(OUT,'>include/openssl/opensslconf.h.new') || die "unable to create include/openssl/opensslconf.h.new:$!\n";
1968 print OUT "/* opensslconf.h */\n";
1969 print OUT "/* WARNING: Generated automatically from opensslconf.h.in by Configure. */\n\n";
1970
1971 print OUT "#ifdef  __cplusplus\n";
1972 print OUT "extern \"C\" {\n";
1973 print OUT "#endif\n";
1974 print OUT "/* OpenSSL was configured with the following options: */\n";
1975 my $openssl_algorithm_defines_trans = $openssl_algorithm_defines;
1976 $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;
1977 $openssl_algorithm_defines_trans =~ s/^\s*#\s*define\s+OPENSSL_(.*)/# if defined(OPENSSL_$1) \&\& !defined($1)\n#  define $1\n# endif/mg;
1978 $openssl_algorithm_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1979 $openssl_algorithm_defines = "   /* no ciphers excluded */\n" if $openssl_algorithm_defines eq "";
1980 $openssl_thread_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1981 $openssl_sys_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1982 $openssl_other_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1983 print OUT $openssl_sys_defines;
1984 print OUT "#ifndef OPENSSL_DOING_MAKEDEPEND\n\n";
1985 print OUT $openssl_experimental_defines;
1986 print OUT "\n";
1987 print OUT $openssl_algorithm_defines;
1988 print OUT "\n#endif /* OPENSSL_DOING_MAKEDEPEND */\n\n";
1989 print OUT $openssl_thread_defines;
1990 print OUT $openssl_other_defines,"\n";
1991
1992 print OUT "/* The OPENSSL_NO_* macros are also defined as NO_* if the application\n";
1993 print OUT "   asks for it.  This is a transient feature that is provided for those\n";
1994 print OUT "   who haven't had the time to do the appropriate changes in their\n";
1995 print OUT "   applications.  */\n";
1996 print OUT "#ifdef OPENSSL_ALGORITHM_DEFINES\n";
1997 print OUT $openssl_algorithm_defines_trans;
1998 print OUT "#endif\n\n";
1999
2000 print OUT "#define OPENSSL_CPUID_OBJ\n\n" if ($cpuid_obj ne "mem_clr.o");
2001
2002 while (<IN>)
2003         {
2004         if      (/^#define\s+OPENSSLDIR/)
2005                 {
2006                 my $foo = $openssldir;
2007                 $foo =~ s/\\/\\\\/g;
2008                 print OUT "#define OPENSSLDIR \"$foo\"\n";
2009                 }
2010         elsif   (/^#define\s+ENGINESDIR/)
2011                 {
2012                 my $foo = "$prefix/$libdir/engines";
2013                 $foo =~ s/\\/\\\\/g;
2014                 print OUT "#define ENGINESDIR \"$foo\"\n";
2015                 }
2016         elsif   (/^#((define)|(undef))\s+OPENSSL_EXPORT_VAR_AS_FUNCTION/)
2017                 { printf OUT "#undef OPENSSL_EXPORT_VAR_AS_FUNCTION\n"
2018                         if $export_var_as_fn;
2019                   printf OUT "#%s OPENSSL_EXPORT_VAR_AS_FUNCTION\n",
2020                         ($export_var_as_fn)?"define":"undef"; }
2021         elsif   (/^#define\s+OPENSSL_UNISTD/)
2022                 {
2023                 $unistd = "<unistd.h>" if $unistd eq "";
2024                 print OUT "#define OPENSSL_UNISTD $unistd\n";
2025                 }
2026         elsif   (/^#((define)|(undef))\s+SIXTY_FOUR_BIT_LONG/)
2027                 { printf OUT "#%s SIXTY_FOUR_BIT_LONG\n",($b64l)?"define":"undef"; }
2028         elsif   (/^#((define)|(undef))\s+SIXTY_FOUR_BIT/)
2029                 { printf OUT "#%s SIXTY_FOUR_BIT\n",($b64)?"define":"undef"; }
2030         elsif   (/^#((define)|(undef))\s+THIRTY_TWO_BIT/)
2031                 { printf OUT "#%s THIRTY_TWO_BIT\n",($b32)?"define":"undef"; }
2032         elsif   (/^#((define)|(undef))\s+SIXTEEN_BIT/)
2033                 { printf OUT "#%s SIXTEEN_BIT\n",($b16)?"define":"undef"; }
2034         elsif   (/^#((define)|(undef))\s+EIGHT_BIT/)
2035                 { printf OUT "#%s EIGHT_BIT\n",($b8)?"define":"undef"; }
2036         elsif   (/^#((define)|(undef))\s+BN_LLONG\s*$/)
2037                 { printf OUT "#%s BN_LLONG\n",($bn_ll)?"define":"undef"; }
2038         elsif   (/^\#define\s+DES_LONG\s+.*/)
2039                 { printf OUT "#define DES_LONG unsigned %s\n",
2040                         ($des_int)?'int':'long'; }
2041         elsif   (/^\#(define|undef)\s+DES_PTR/)
2042                 { printf OUT "#%s DES_PTR\n",($des_ptr)?'define':'undef'; }
2043         elsif   (/^\#(define|undef)\s+DES_RISC1/)
2044                 { printf OUT "#%s DES_RISC1\n",($des_risc1)?'define':'undef'; }
2045         elsif   (/^\#(define|undef)\s+DES_RISC2/)
2046                 { printf OUT "#%s DES_RISC2\n",($des_risc2)?'define':'undef'; }
2047         elsif   (/^\#(define|undef)\s+DES_UNROLL/)
2048                 { printf OUT "#%s DES_UNROLL\n",($des_unroll)?'define':'undef'; }
2049         elsif   (/^#define\s+RC4_INT\s/)
2050                 { printf OUT "#define RC4_INT unsigned %s\n",$type[$rc4_int]; }
2051         elsif   (/^#undef\s+RC4_CHUNK/)
2052                 {
2053                 printf OUT "#undef RC4_CHUNK\n" if $rc4_chunk==0;
2054                 printf OUT "#define RC4_CHUNK unsigned long\n" if $rc4_chunk==1;
2055                 printf OUT "#define RC4_CHUNK unsigned long long\n" if $rc4_chunk==2;
2056                 }
2057         elsif   (/^#((define)|(undef))\s+RC4_INDEX/)
2058                 { printf OUT "#%s RC4_INDEX\n",($rc4_idx)?"define":"undef"; }
2059         elsif (/^#(define|undef)\s+I386_ONLY/)
2060                 { printf OUT "#%s I386_ONLY\n", ($processor eq "386")?
2061                         "define":"undef"; }
2062         elsif   (/^#define\s+MD2_INT\s/)
2063                 { printf OUT "#define MD2_INT unsigned %s\n",$type[$md2_int]; }
2064         elsif   (/^#define\s+IDEA_INT\s/)
2065                 {printf OUT "#define IDEA_INT unsigned %s\n",$type[$idea_int];}
2066         elsif   (/^#define\s+RC2_INT\s/)
2067                 {printf OUT "#define RC2_INT unsigned %s\n",$type[$rc2_int];}
2068         elsif (/^#(define|undef)\s+BF_PTR/)
2069                 {
2070                 printf OUT "#undef BF_PTR\n" if $bf_ptr == 0;
2071                 printf OUT "#define BF_PTR\n" if $bf_ptr == 1;
2072                 printf OUT "#define BF_PTR2\n" if $bf_ptr == 2;
2073                 }
2074         else
2075                 { print OUT $_; }
2076         }
2077 close(IN);
2078 print OUT "#ifdef  __cplusplus\n";
2079 print OUT "}\n";
2080 print OUT "#endif\n";
2081 close(OUT);
2082 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";
2083 rename("include/openssl/opensslconf.h.new","include/openssl/opensslconf.h") || die "unable to rename include/openssl/opensslconf.h.new\n";
2084
2085
2086 # Fix the date
2087
2088 print "SIXTY_FOUR_BIT_LONG mode\n" if $b64l;
2089 print "SIXTY_FOUR_BIT mode\n" if $b64;
2090 print "THIRTY_TWO_BIT mode\n" if $b32;
2091 print "SIXTEEN_BIT mode\n" if $b16;
2092 print "EIGHT_BIT mode\n" if $b8;
2093 print "DES_PTR used\n" if $des_ptr;
2094 print "DES_RISC1 used\n" if $des_risc1;
2095 print "DES_RISC2 used\n" if $des_risc2;
2096 print "DES_UNROLL used\n" if $des_unroll;
2097 print "DES_INT used\n" if $des_int;
2098 print "BN_LLONG mode\n" if $bn_ll;
2099 print "RC4 uses u$type[$rc4_int]\n" if $rc4_int != $def_int;
2100 print "RC4_INDEX mode\n" if $rc4_idx;
2101 print "RC4_CHUNK is undefined\n" if $rc4_chunk==0;
2102 print "RC4_CHUNK is unsigned long\n" if $rc4_chunk==1;
2103 print "RC4_CHUNK is unsigned long long\n" if $rc4_chunk==2;
2104 print "MD2 uses u$type[$md2_int]\n" if $md2_int != $def_int;
2105 print "IDEA uses u$type[$idea_int]\n" if $idea_int != $def_int;
2106 print "RC2 uses u$type[$rc2_int]\n" if $rc2_int != $def_int;
2107 print "BF_PTR used\n" if $bf_ptr == 1;
2108 print "BF_PTR2 used\n" if $bf_ptr == 2;
2109
2110 {
2111     my $perlguess = $perl =~ m@^/@ ? $perl : '/usr/local/bin/perl';
2112
2113     &dofile("tools/c_rehash",$perlguess,
2114             '^#!/'              => '#!%s',
2115             '^my \$dir;$'       => 'my $dir = "' . $openssldir . '";',
2116             '^my \$prefix;$'    => 'my $prefix = "' . $prefix . '";');
2117     &dofile("apps/CA.pl",$perl,
2118             '^#!/'              => '#!%s');
2119 }
2120 if($IsMK1MF) {
2121         open (OUT,">crypto/buildinf.h") || die "Can't open buildinf.h";
2122         printf OUT <<EOF;
2123 #ifndef MK1MF_BUILD
2124   /* auto-generated by Configure for crypto/cversion.c:
2125    * for Unix builds, crypto/Makefile.ssl generates functional definitions;
2126    * Windows builds (and other mk1mf builds) compile cversion.c with
2127    * -DMK1MF_BUILD and use definitions added to this file by util/mk1mf.pl. */
2128   #error "Windows builds (PLATFORM=$target) use mk1mf.pl-created Makefiles"
2129 #endif
2130 EOF
2131         close(OUT);
2132 } else {
2133         my $make_command = "$make PERL=\'$perl\'";
2134         my $make_targets = "";
2135         $make_targets .= " depend" if $depflags ne $default_depflags && $make_depend;
2136         (system $make_command.$make_targets) == 0 or die "make $make_targets failed"
2137                 if $make_targets ne "";
2138         if ($depflags ne $default_depflags && !$make_depend) {
2139                 print <<EOF;
2140
2141 Since you've disabled or enabled at least one algorithm, you need to do
2142 the following before building:
2143
2144         make depend
2145 EOF
2146         }
2147 }
2148
2149 # create the ms/version32.rc file if needed
2150 if ($IsMK1MF && ($target !~ /^netware/)) {
2151         my ($v1, $v2, $v3, $v4);
2152         if ($version_num =~ /(^[0-9a-f]{1})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})/i) {
2153                 $v1=hex $1;
2154                 $v2=hex $2;
2155                 $v3=hex $3;
2156                 $v4=hex $4;
2157         }
2158         open (OUT,">ms/version32.rc") || die "Can't open ms/version32.rc";
2159         print OUT <<EOF;
2160 #include <winver.h>
2161
2162 LANGUAGE 0x09,0x01
2163
2164 1 VERSIONINFO
2165   FILEVERSION $v1,$v2,$v3,$v4
2166   PRODUCTVERSION $v1,$v2,$v3,$v4
2167   FILEFLAGSMASK 0x3fL
2168 #ifdef _DEBUG
2169   FILEFLAGS 0x01L
2170 #else
2171   FILEFLAGS 0x00L
2172 #endif
2173   FILEOS VOS__WINDOWS32
2174   FILETYPE VFT_DLL
2175   FILESUBTYPE 0x0L
2176 BEGIN
2177     BLOCK "StringFileInfo"
2178     BEGIN
2179         BLOCK "040904b0"
2180         BEGIN
2181             // Required:
2182             VALUE "CompanyName", "The OpenSSL Project, http://www.openssl.org/\\0"
2183             VALUE "FileDescription", "OpenSSL Shared Library\\0"
2184             VALUE "FileVersion", "$version\\0"
2185 #if defined(CRYPTO)
2186             VALUE "InternalName", "libeay32\\0"
2187             VALUE "OriginalFilename", "libeay32.dll\\0"
2188 #elif defined(SSL)
2189             VALUE "InternalName", "ssleay32\\0"
2190             VALUE "OriginalFilename", "ssleay32.dll\\0"
2191 #endif
2192             VALUE "ProductName", "The OpenSSL Toolkit\\0"
2193             VALUE "ProductVersion", "$version\\0"
2194             // Optional:
2195             //VALUE "Comments", "\\0"
2196             VALUE "LegalCopyright", "Copyright © 1998-2015 The OpenSSL Project. Copyright © 1995-1998 Eric A. Young, Tim J. Hudson. All rights reserved.\\0"
2197             //VALUE "LegalTrademarks", "\\0"
2198             //VALUE "PrivateBuild", "\\0"
2199             //VALUE "SpecialBuild", "\\0"
2200         END
2201     END
2202     BLOCK "VarFileInfo"
2203     BEGIN
2204         VALUE "Translation", 0x409, 0x4b0
2205     END
2206 END
2207 EOF
2208         close(OUT);
2209   }
2210
2211 print <<EOF;
2212
2213 Configured for $target.
2214 EOF
2215
2216 print <<\EOF if (!$no_threads && !$threads);
2217
2218 The library could not be configured for supporting multi-threaded
2219 applications as the compiler options required on this system are not known.
2220 See file INSTALL for details if you need multi-threading.
2221 EOF
2222
2223 print <<\EOF if ($no_shared_warn);
2224
2225 You gave the option 'shared'.  Normally, that would give you shared libraries.
2226 Unfortunately, the OpenSSL configuration doesn't include shared library support
2227 for this platform yet, so it will pretend you gave the option 'no-shared'.  If
2228 you can inform the developpers (openssl-dev\@openssl.org) how to support shared
2229 libraries on this platform, they will at least look at it and try their best
2230 (but please first make sure you have tried with a current version of OpenSSL).
2231 EOF
2232
2233 exit(0);
2234
2235 sub usage
2236         {
2237         print STDERR $usage;
2238         print STDERR "\npick os/compiler from:\n";
2239         my $j=0;
2240         my $i;
2241         my $k=0;
2242         foreach $i (sort keys %table)
2243                 {
2244                 next if $i =~ /^debug/;
2245                 $k += length($i) + 1;
2246                 if ($k > 78)
2247                         {
2248                         print STDERR "\n";
2249                         $k=length($i);
2250                         }
2251                 print STDERR $i . " ";
2252                 }
2253         foreach $i (sort keys %table)
2254                 {
2255                 next if $i !~ /^debug/;
2256                 $k += length($i) + 1;
2257                 if ($k > 78)
2258                         {
2259                         print STDERR "\n";
2260                         $k=length($i);
2261                         }
2262                 print STDERR $i . " ";
2263                 }
2264         print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
2265         exit(1);
2266         }
2267
2268 sub which
2269         {
2270         my($name)=@_;
2271         my $path;
2272         foreach $path (split /:/, $ENV{PATH})
2273                 {
2274                 if (-f "$path/$name$exe_ext" and -x _)
2275                         {
2276                         return "$path/$name$exe_ext" unless ($name eq "perl" and
2277                          system("$path/$name$exe_ext -e " . '\'exit($]<5.0);\''));
2278                         }
2279                 }
2280         }
2281
2282 sub dofile
2283         {
2284         my $f; my $p; my %m; my @a; my $k; my $ff;
2285         ($f,$p,%m)=@_;
2286
2287         open(IN,"<$f.in") || open(IN,"<$f") || die "unable to open $f:$!\n";
2288         @a=<IN>;
2289         close(IN);
2290         foreach $k (keys %m)
2291                 {
2292                 grep(/$k/ && ($_=sprintf($m{$k}."\n",$p)),@a);
2293                 }
2294         open(OUT,">$f.new") || die "unable to open $f.new:$!\n";
2295         print OUT @a;
2296         close(OUT);
2297         rename($f,"$f.bak") || die "unable to rename $f\n" if -e $f;
2298         rename("$f.new",$f) || die "unable to rename $f.new\n";
2299         }
2300
2301 sub print_table_entry
2302         {
2303         my $target = shift;
2304         my $type = shift;
2305
2306         # Don't print the templates
2307         return if $table{$target}->{template};
2308
2309         if ($type eq "TABLE") {
2310             print <<EOF
2311
2312 *** $target
2313 \$cc           = $table{$target}->{cc}
2314 \$cflags       = $table{$target}->{cflags}
2315 \$debug_cflags   = $table{$target}->{debug_cflags}
2316 \$release_cflags = $table{$target}->{release_cflags}
2317 \$unistd       = $table{$target}->{unistd}
2318 \$thread_cflag = $table{$target}->{thread_cflag}
2319 \$sys_id       = $table{$target}->{sys_id}
2320 \$lflags       = $table{$target}->{lflags}
2321 \$debug_lflags   = $table{$target}->{debug_lflags}
2322 \$release_lflags = $table{$target}->{release_lflags}
2323 \$bn_ops       = $table{$target}->{bn_ops}
2324 \$cpuid_obj    = $table{$target}->{cpuid_obj}
2325 \$bn_obj       = $table{$target}->{bn_obj}
2326 \$ec_obj       = $table{$target}->{ec_obj}
2327 \$des_obj      = $table{$target}->{des_obj}
2328 \$aes_obj      = $table{$target}->{aes_obj}
2329 \$bf_obj       = $table{$target}->{bf_obj}
2330 \$md5_obj      = $table{$target}->{md5_obj}
2331 \$sha1_obj     = $table{$target}->{sha1_obj}
2332 \$cast_obj     = $table{$target}->{cast_obj}
2333 \$rc4_obj      = $table{$target}->{rc4_obj}
2334 \$rmd160_obj   = $table{$target}->{rmd160_obj}
2335 \$rc5_obj      = $table{$target}->{rc5_obj}
2336 \$wp_obj       = $table{$target}->{wp_obj}
2337 \$cmll_obj     = $table{$target}->{cmll_obj}
2338 \$modes_obj    = $table{$target}->{modes_obj}
2339 \$engines_obj  = $table{$target}->{engines_obj}
2340 \$perlasm_scheme = $table{$target}->{perlasm_scheme}
2341 \$dso_scheme   = $table{$target}->{dso_scheme}
2342 \$shared_target= $table{$target}->{shared_target}
2343 \$shared_cflag = $table{$target}->{shared_cflag}
2344 \$shared_ldflag = $table{$target}->{shared_ldflag}
2345 \$shared_extension = $table{$target}->{shared_extension}
2346 \$ranlib       = $table{$target}->{ranlib}
2347 \$arflags      = $table{$target}->{arflags}
2348 \$multilib     = $table{$target}->{multilib}
2349 EOF
2350         } elsif ($type eq "HASH") {
2351             my @sequence = (
2352                 "cc",
2353                 "cflags",
2354                 "debug_cflags",
2355                 "release_cflags",
2356                 "unistd",
2357                 "thread_cflag",
2358                 "sys_id",
2359                 "lflags",
2360                 "debug_lflags",
2361                 "release_lflags",
2362                 "bn_ops",
2363                 "cpuid_obj",
2364                 "bn_obj",
2365                 "ec_obj",
2366                 "des_obj",
2367                 "aes_obj",
2368                 "bf_obj",
2369                 "md5_obj",
2370                 "sha1_obj",
2371                 "cast_obj",
2372                 "rc4_obj",
2373                 "rmd160_obj",
2374                 "rc5_obj",
2375                 "wp_obj",
2376                 "cmll_obj",
2377                 "modes_obj",
2378                 "engines_obj",
2379                 "perlasm_scheme",
2380                 "dso_scheme",
2381                 "shared_target",
2382                 "shared_cflag",
2383                 "shared_ldflag",
2384                 "shared_extension",
2385                 "ranlib",
2386                 "arflags",
2387                 "multilib",
2388                 );
2389             my $largest =
2390                 length((sort { length($a) <=> length($b) } @sequence)[-1]);
2391             print "    '$target' => {\n";
2392             foreach (@sequence) {
2393                 if ($table{$target}->{$_}) {
2394                     print "      '",$_,"'"," " x ($largest - length($_))," => '",$table{$target}->{$_},"',\n";
2395                 }
2396             }
2397             print "    },\n";
2398         }
2399         }
2400
2401 sub test_sanity
2402         {
2403         my $errorcnt = 0;
2404
2405         print STDERR "=" x 70, "\n";
2406         print STDERR "=== SANITY TESTING!\n";
2407         print STDERR "=== No configuration will be done, all other arguments will be ignored!\n";
2408         print STDERR "=" x 70, "\n";
2409
2410         foreach $target (sort keys %table)
2411                 {
2412                 my $pre_dso_scheme = "perlasm_scheme";
2413                 my $dso_scheme = "dso_scheme";
2414                 my $post_dso_scheme = "shared_target";
2415
2416
2417                 if ($table{$target}->{$pre_dso_scheme} =~ /^(beos|dl|dlfcn|win32|vms)$/)
2418                         {
2419                         $errorcnt++;
2420                         print STDERR "SANITY ERROR: '$target' has the dso_scheme values\n";
2421                         print STDERR "              in the previous field\n";
2422                         }
2423                 elsif ($table{$target}->{$post_dso_scheme} =~ /^(beos|dl|dlfcn|win32|vms)$/)
2424                         {
2425                         $errorcnt++;
2426                         print STDERR "SANITY ERROR: '$target' has the dso_scheme values\n";
2427                         print STDERR "              in the following field\n";
2428                         }
2429                 elsif ($table{$target}->{$dso_scheme} !~ /^(beos|dl|dlfcn|win32|vms|)$/)
2430                         {
2431                         $errorcnt++;
2432                         print STDERR "SANITY ERROR: '$target' has the dso_scheme field = ",$table{$target}->{$dso_scheme},"\n";
2433                         print STDERR "              valid values are 'beos', 'dl', 'dlfcn', 'win32' and 'vms'\n";
2434                         }
2435                 }
2436         print STDERR "No sanity errors detected!\n" if $errorcnt == 0;
2437         return $errorcnt;
2438         }