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