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