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