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