]> git.ipfire.org Git - thirdparty/openssl.git/blob - Configure
projects / thirdparty / openssl.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Improve the definition of STITCHED_CALL in e_rc4_hmac_md5.c
[thirdparty/openssl.git] / Configure
1 #! /usr/bin/env perl
2 # -*- mode: perl; -*-
3 # Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
4 #
5 # Licensed under the OpenSSL license (the "License"). You may not use
6 # this file except in compliance with the License. You can obtain a copy
7 # in the file LICENSE in the source distribution or at
8 # https://www.openssl.org/source/license.html
9
10 ## Configure -- OpenSSL source tree configuration script
11
12 require 5.10.0;
13 use strict;
14 use File::Basename;
15 use File::Spec::Functions qw/:DEFAULT abs2rel rel2abs/;
16 use File::Path qw/mkpath/;
17 use if $^O ne "VMS", 'File::Glob' => qw/glob/;
18
19 # see INSTALL for instructions.
20
21 my $usage="Usage: Configure [no-<cipher> ...] [enable-<cipher> ...] [-Dxxx] [-lxxx] [-Lxxx] [-fxxx] [-Kxxx] [no-hw-xxx|no-hw] [[no-]threads] [[no-]shared] [[no-]zlib|zlib-dynamic] [no-asm] [no-dso] [no-egd] [sctp] [386] [--prefix=DIR] [--openssldir=OPENSSLDIR] [--with-xxx[=vvv]] [--config=FILE] os/compiler[:flags]\n";
22
23 # Options:
24 #
25 # --config add the given configuration file, which will be read after
26 # any "Configurations*" files that are found in the same
27 # directory as this script.
28 # --prefix prefix for the OpenSSL installation, which includes the
29 # directories bin, lib, include, share/man, share/doc/openssl
30 # This becomes the value of INSTALLTOP in Makefile
31 # (Default: /usr/local)
32 # --openssldir OpenSSL data area, such as openssl.cnf, certificates and keys.
33 # If it's a relative directory, it will be added on the directory
34 # given with --prefix.
35 # This becomes the value of OPENSSLDIR in Makefile and in C.
36 # (Default: PREFIX/ssl)
37 #
38 # --cross-compile-prefix Add specified prefix to binutils components.
39 #
40 # --api One of 0.9.8, 1.0.0 or 1.1.0. Do not compile support for
41 # interfaces deprecated as of the specified OpenSSL version.
42 #
43 # no-hw-xxx do not compile support for specific crypto hardware.
44 # Generic OpenSSL-style methods relating to this support
45 # are always compiled but return NULL if the hardware
46 # support isn't compiled.
47 # no-hw do not compile support for any crypto hardware.
48 # [no-]threads [don't] try to create a library that is suitable for
49 # multithreaded applications (default is "threads" if we
50 # know how to do it)
51 # [no-]shared [don't] try to create shared libraries when supported.
52 # [no-]pic [don't] try to build position independent code when supported.
53 # If disabled, it also disables shared and dynamic-engine.
54 # no-asm do not use assembler
55 # no-dso do not compile in any native shared-library methods. This
56 # will ensure that all methods just return NULL.
57 # no-egd do not compile support for the entropy-gathering daemon APIs
58 # [no-]zlib [don't] compile support for zlib compression.
59 # zlib-dynamic Like "zlib", but the zlib library is expected to be a shared
60 # library and will be loaded in run-time by the OpenSSL library.
61 # sctp include SCTP support
62 # 386 generate 80386 code
63 # enable-weak-ssl-ciphers
64 # Enable weak ciphers that are disabled by default. This currently
65 # only includes RC4 based ciphers.
66 # no-sse2 disables IA-32 SSE2 code, above option implies no-sse2
67 # no-<cipher> build without specified algorithm (rsa, idea, rc5, ...)
68 # -<xxx> +<xxx> compiler options are passed through
69 #
70 # DEBUG_SAFESTACK use type-safe stacks to enforce type-safety on stack items
71 # provided to stack calls. Generates unique stack functions for
72 # each possible stack type.
73 # BN_LLONG use the type 'long long' in crypto/bn/bn.h
74 # RC4_CHAR use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
75 # Following are set automatically by this script
76 #
77 # MD5_ASM use some extra md5 assembler,
78 # SHA1_ASM use some extra sha1 assembler, must define L_ENDIAN for x86
79 # RMD160_ASM use some extra ripemd160 assembler,
80 # SHA256_ASM sha256_block is implemented in assembler
81 # SHA512_ASM sha512_block is implemented in assembler
82 # AES_ASM AES_[en|de]crypt is implemented in assembler
83
84 # Minimum warning options... any contributions to OpenSSL should at least get
85 # past these.
86
87 # DEBUG_UNUSED enables __owur (warn unused result) checks.
88 my $gcc_devteam_warn = "-DDEBUG_UNUSED"
89 # -DPEDANTIC complements -pedantic and is meant to mask code that
90 # is not strictly standard-compliant and/or implementation-specific,
91 # e.g. inline assembly, disregards to alignment requirements, such
92 # that -pedantic would complain about. Incidentally -DPEDANTIC has
93 # to be used even in sanitized builds, because sanitizer too is
94 # supposed to and does take notice of non-standard behaviour. Then
95 # -pedantic with pre-C9x compiler would also complain about 'long
96 # long' not being supported. As 64-bit algorithms are common now,
97 # it grew impossible to resolve this without sizeable additional
98 # code, so we just tell compiler to be pedantic about everything
99 # but 'long long' type.
100 . " -DPEDANTIC -pedantic -Wno-long-long"
101 . " -Wall"
102 . " -Wsign-compare"
103 . " -Wmissing-prototypes"
104 . " -Wshadow"
105 . " -Wformat"
106 . " -Wtype-limits"
107 . " -Werror"
108 ;
109
110 # These are used in addition to $gcc_devteam_warn when the compiler is clang.
111 # TODO(openssl-team): fix problems and investigate if (at least) the
112 # following warnings can also be enabled:
113 # -Wswitch-enum
114 # -Wcast-align
115 # -Wunreachable-code
116 # -Wlanguage-extension-token -- no, we use asm()
117 # -Wunused-macros -- no, too tricky for BN and _XOPEN_SOURCE etc
118 # -Wextended-offsetof -- no, needed in CMS ASN1 code
119 my $clang_devteam_warn = ""
120 . " -Qunused-arguments"
121 . " -Wextra"
122 . " -Wno-unused-parameter"
123 . " -Wno-missing-field-initializers"
124 . " -Wno-language-extension-token"
125 . " -Wno-extended-offsetof"
126 . " -Wconditional-uninitialized"
127 . " -Wincompatible-pointer-types-discards-qualifiers"
128 . " -Wmissing-variable-declarations"
129 ;
130
131 # This adds backtrace information to the memory leak info. Is only used
132 # when crypto-mdebug-backtrace is enabled.
133 my $memleak_devteam_backtrace = "-rdynamic";
134
135 my $strict_warnings = 0;
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 our $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
145
146 #
147 # API compatibility name to version number mapping.
148 #
149 my $maxapi = "1.1.0"; # API for "no-deprecated" builds
150 my $apitable = {
151 "1.1.0" => "0x10100000L",
152 "1.0.0" => "0x10000000L",
153 "0.9.8" => "0x00908000L",
154 };
155
156 our %table = ();
157 our %config = ();
158 our %withargs = ();
159
160 # Forward declarations ###############################################
161
162 # read_config(filename)
163 #
164 # Reads a configuration file and populates %table with the contents
165 # (which the configuration file places in %targets).
166 sub read_config;
167
168 # resolve_config(target)
169 #
170 # Resolves all the late evaluations, inheritances and so on for the
171 # chosen target and any target it inherits from.
172 sub resolve_config;
173
174
175 # Information collection #############################################
176
177 # Unified build supports separate build dir
178 my $srcdir = catdir(absolutedir(dirname($0))); # catdir ensures local syntax
179 my $blddir = catdir(absolutedir(".")); # catdir ensures local syntax
180 my $dofile = abs2rel(catfile($srcdir, "util/dofile.pl"));
181
182 my $local_config_envname = 'OPENSSL_LOCAL_CONFIG_DIR';
183
184 $config{sourcedir} = abs2rel($srcdir);
185 $config{builddir} = abs2rel($blddir);
186
187 # Collect version numbers
188 $config{version} = "unknown";
189 $config{version_num} = "unknown";
190 $config{shlib_version_number} = "unknown";
191 $config{shlib_version_history} = "unknown";
192
193 collect_information(
194 collect_from_file(catfile($srcdir,'include/openssl/opensslv.h')),
195 qr/OPENSSL.VERSION.TEXT.*OpenSSL (\S+) / => sub { $config{version} = $1; },
196 qr/OPENSSL.VERSION.NUMBER.*(0x\S+)/ => sub { $config{version_num}=$1 },
197 qr/SHLIB_VERSION_NUMBER *"([^"]+)"/ => sub { $config{shlib_version_number}=$1 },
198 qr/SHLIB_VERSION_HISTORY *"([^"]*)"/ => sub { $config{shlib_version_history}=$1 }
199 );
200 if ($config{shlib_version_history} ne "") { $config{shlib_version_history} .= ":"; }
201
202 ($config{major}, $config{minor})
203 = ($config{version} =~ /^([0-9]+)\.([0-9\.]+)/);
204 ($config{shlib_major}, $config{shlib_minor})
205 = ($config{shlib_version_number} =~ /^([0-9]+)\.([0-9\.]+)/);
206 die "erroneous version information in opensslv.h: ",
207 "$config{major}, $config{minor}, $config{shlib_major}, $config{shlib_minor}\n"
208 if ($config{major} eq "" || $config{minor} eq ""
209 || $config{shlib_major} eq "" || $config{shlib_minor} eq "");
210
211 # Collect target configurations
212
213 my $pattern = catfile(dirname($0), "Configurations", "*.conf");
214 foreach (sort glob($pattern)) {
215 &read_config($_);
216 }
217
218 if (defined $ENV{$local_config_envname}) {
219 if ($^O eq 'VMS') {
220 # VMS environment variables are logical names,
221 # which can be used as is
222 $pattern = $local_config_envname . ':' . '*.conf';
223 } else {
224 $pattern = catfile($ENV{$local_config_envname}, '*.conf');
225 }
226
227 foreach (sort glob($pattern)) {
228 &read_config($_);
229 }
230 }
231
232
233 print "Configuring OpenSSL version $config{version} (0x$config{version_num})\n";
234
235 $config{prefix}="";
236 $config{openssldir}="";
237 $config{processor}="";
238 $config{libdir}="";
239 $config{cross_compile_prefix}="";
240 $config{fipslibdir}="/usr/local/ssl/fips-2.0/lib/";
241 my $nofipscanistercheck=0;
242 $config{baseaddr}="0xFB00000";
243 my $auto_threads=1; # enable threads automatically? true by default
244 my $default_ranlib;
245 $config{fips}=0;
246
247 # Top level directories to build
248 $config{dirs} = [ "crypto", "ssl", "engines", "apps", "test", "tools", "fuzz" ];
249 # crypto/ subdirectories to build
250 $config{sdirs} = [
251 "objects",
252 "md2", "md4", "md5", "sha", "mdc2", "hmac", "ripemd", "whrlpool", "poly1305", "blake2",
253 "des", "aes", "rc2", "rc4", "rc5", "idea", "bf", "cast", "camellia", "seed", "chacha", "modes",
254 "bn", "ec", "rsa", "dsa", "dh", "dso", "engine",
255 "buffer", "bio", "stack", "lhash", "rand", "err",
256 "evp", "asn1", "pem", "x509", "x509v3", "conf", "txt_db", "pkcs7", "pkcs12", "comp", "ocsp", "ui",
257 "cms", "ts", "srp", "cmac", "ct", "async", "kdf"
258 ];
259
260 # Known TLS and DTLS protocols
261 my @tls = qw(ssl3 tls1 tls1_1 tls1_2);
262 my @dtls = qw(dtls1 dtls1_2);
263
264 # Explicitly known options that are possible to disable. They can
265 # be regexps, and will be used like this: /^no-${option}$/
266 # For developers: keep it sorted alphabetically
267
268 my @disablables = (
269 "afalgeng",
270 "asan",
271 "asm",
272 "async",
273 "autoalginit",
274 "autoerrinit",
275 "bf",
276 "blake2",
277 "camellia",
278 "capieng",
279 "cast",
280 "chacha",
281 "cmac",
282 "cms",
283 "comp",
284 "crypto-mdebug",
285 "crypto-mdebug-backtrace",
286 "ct",
287 "deprecated",
288 "des",
289 "dgram",
290 "dh",
291 "dsa",
292 "dso",
293 "dtls",
294 "dynamic-engine",
295 "ec",
296 "ec2m",
297 "ecdh",
298 "ecdsa",
299 "ec_nistp_64_gcc_128",
300 "egd",
301 "engine",
302 "err",
303 "filenames",
304 "fuzz-libfuzzer",
305 "fuzz-afl",
306 "gost",
307 "heartbeats",
308 "hw(-.+)?",
309 "idea",
310 "makedepend",
311 "md2",
312 "md4",
313 "mdc2",
314 "msan",
315 "multiblock",
316 "nextprotoneg",
317 "ocb",
318 "ocsp",
319 "pic",
320 "poly1305",
321 "posix-io",
322 "psk",
323 "rc2",
324 "rc4",
325 "rc5",
326 "rdrand",
327 "rfc3779",
328 "rmd160",
329 "scrypt",
330 "sctp",
331 "seed",
332 "shared",
333 "sock",
334 "srp",
335 "srtp",
336 "sse2",
337 "ssl",
338 "ssl-trace",
339 "static-engine",
340 "stdio",
341 "threads",
342 "tls",
343 "ts",
344 "ubsan",
345 "ui",
346 "unit-test",
347 "whirlpool",
348 "weak-ssl-ciphers",
349 "zlib",
350 "zlib-dynamic",
351 );
352 foreach my $proto ((@tls, @dtls))
353 {
354 push(@disablables, $proto);
355 push(@disablables, "$proto-method");
356 }
357
358 my %deprecated_disablables = (
359 "ssl2" => undef,
360 "buf-freelists" => undef,
361 "ripemd" => "rmd160"
362 );
363
364 # All of the following is disabled by default (RC5 was enabled before 0.9.8):
365
366 our %disabled = ( # "what" => "comment"
367 "asan" => "default",
368 "crypto-mdebug" => "default",
369 "crypto-mdebug-backtrace" => "default",
370 "ec_nistp_64_gcc_128" => "default",
371 "egd" => "default",
372 "fuzz-libfuzzer" => "default",
373 "fuzz-afl" => "default",
374 "heartbeats" => "default",
375 "md2" => "default",
376 "msan" => "default",
377 "rc5" => "default",
378 "sctp" => "default",
379 "ssl-trace" => "default",
380 "ssl3" => "default",
381 "ssl3-method" => "default",
382 "ubsan" => "default",
383 "unit-test" => "default",
384 "weak-ssl-ciphers" => "default",
385 "zlib" => "default",
386 "zlib-dynamic" => "default",
387 );
388
389 # Note: => pair form used for aesthetics, not to truly make a hash table
390 my @disable_cascades = (
391 # "what" => [ "cascade", ... ]
392 sub { $config{processor} eq "386" }
393 => [ "sse2" ],
394 "ssl" => [ "ssl3" ],
395 "ssl3-method" => [ "ssl3" ],
396 "zlib" => [ "zlib-dynamic" ],
397 "des" => [ "mdc2" ],
398 "ec" => [ "ecdsa", "ecdh" ],
399
400 "dgram" => [ "dtls", "sctp" ],
401 "sock" => [ "dgram" ],
402 "dtls" => [ @dtls ],
403
404 # SSL 3.0, (D)TLS 1.0 and TLS 1.1 require MD5 and SHA
405 "md5" => [ "ssl", "tls1", "tls1_1", "dtls1" ],
406 "sha" => [ "ssl", "tls1", "tls1_1", "dtls1" ],
407
408 # Additionally, SSL 3.0 requires either RSA or DSA+DH
409 sub { $disabled{rsa}
410 && ($disabled{dsa} || $disabled{dh}); }
411 => [ "ssl" ],
412
413 # (D)TLS 1.0 and TLS 1.1 also require either RSA or DSA+DH
414 # or ECDSA + ECDH. (D)TLS 1.2 has this requirement as well.
415 # (XXX: We don't support PSK-only builds).
416 sub { $disabled{rsa}
417 && ($disabled{dsa} || $disabled{dh})
418 && ($disabled{ecdsa} || $disabled{ecdh}); }
419 => [ "tls1", "tls1_1", "tls1_2",
420 "dtls1", "dtls1_2" ],
421
422 "tls" => [ @tls ],
423
424 # SRP and HEARTBEATS require TLSEXT
425 "tlsext" => [ "srp", "heartbeats" ],
426
427 "crypto-mdebug" => [ "crypto-mdebug-backtrace" ],
428
429 # Without DSO, we can't load dynamic engines, so don't build them dynamic
430 "dso" => [ "dynamic-engine" ],
431
432 # Without position independent code, there can be no shared libraries or DSOs
433 "pic" => [ "shared" ],
434 "shared" => [ "dynamic-engine" ],
435 "engine" => [ "afalgeng" ],
436
437 # no-autoalginit is only useful when building non-shared
438 "autoalginit" => [ "shared", "apps" ],
439
440 "stdio" => [ "apps", "capieng" ],
441 "apps" => [ "tests" ],
442 "comp" => [ "zlib" ],
443 sub { !$disabled{"unit-test"} } => [ "heartbeats" ],
444
445 sub { !$disabled{"msan"} } => [ "asm" ],
446 );
447
448 # Avoid protocol support holes. Also disable all versions below N, if version
449 # N is disabled while N+1 is enabled.
450 #
451 my @list = (reverse @tls);
452 while ((my $first, my $second) = (shift @list, shift @list)) {
453 last unless @list;
454 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
455 => [ @list ] );
456 unshift @list, $second;
457 }
458 my @list = (reverse @dtls);
459 while ((my $first, my $second) = (shift @list, shift @list)) {
460 last unless @list;
461 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
462 => [ @list ] );
463 unshift @list, $second;
464 }
465
466 # Explicit "no-..." options will be collected in %disabled along with the defaults.
467 # To remove something from %disabled, use "enable-foo".
468 # For symmetry, "disable-foo" is a synonym for "no-foo".
469
470 my $no_sse2=0;
471
472 &usage if ($#ARGV < 0);
473
474 my $user_cflags="";
475 my @user_defines=();
476 $config{openssl_api_defines}=[];
477 $config{openssl_algorithm_defines}=[];
478 $config{openssl_thread_defines}=[];
479 $config{openssl_sys_defines}=[];
480 $config{openssl_other_defines}=[];
481 my $libs="";
482 my $target="";
483 $config{options}="";
484 $config{build_type} = "release";
485
486 my @argvcopy=@ARGV;
487
488 if (grep /^reconf(igure)?$/, @argvcopy) {
489 if (-f "./configdata.pm") {
490 my $file = "./configdata.pm";
491 unless (my $return = do $file) {
492 die "couldn't parse $file: $@" if $@;
493 die "couldn't do $file: $!" unless defined $return;
494 die "couldn't run $file" unless $return;
495 }
496
497 @argvcopy = defined($configdata::config{perlargv}) ?
498 @{$configdata::config{perlargv}} : ();
499 die "Incorrect data to reconfigure, please do a normal configuration\n"
500 if (grep(/^reconf/,@argvcopy));
501 $ENV{CROSS_COMPILE} = $configdata::config{cross_compile_prefix}
502 if defined($configdata::config{cross_compile_prefix});
503 $ENV{CC} = $configdata::config{cc}
504 if defined($configdata::config{cc});
505
506 print "Reconfiguring with: ", join(" ",@argvcopy), "\n";
507 print " CROSS_COMPILE = ",$ENV{CROSS_COMPILE},"\n"
508 if $ENV{CROSS_COMPILE};
509 print " CC = ",$ENV{CC},"\n" if $ENV{CC};
510 } elsif (open IN, "<Makefile") {
511 #
512 # THIS SECTION IS TEMPORARY, it helps transitioning from Makefile
513 # centered information gathering the reading configdata.pm
514 #
515 while (<IN>) {
516 s|\R$||;
517 if (/^CONFIGURE_ARGS=\s*(.*)\s*/) {
518 # Older form, we split the string and hope for the best
519 @argvcopy = split /\s+/, $_;
520 die "Incorrect data to reconfigure, please do a normal configuration\n"
521 if (grep(/^reconf/,@argvcopy));
522 } elsif (/^CROSS_COMPILE=\s*(.*)/) {
523 $ENV{CROSS_COMPILE}=$1;
524 } elsif (/^CC=\s*(?:\$\(CROSS_COMPILE\))?(.*?)$/) {
525 $ENV{CC}=$1;
526 }
527 }
528 #
529 # END OF TEMPORARY SECTION
530 #
531 } else {
532 die "Insufficient data to reconfigure, please do a normal configuration\n";
533 }
534 }
535
536 $config{perlargv} = [ @argvcopy ];
537
538 my %unsupported_options = ();
539 my %deprecated_options = ();
540 foreach (@argvcopy)
541 {
542 # VMS is a case insensitive environment, and depending on settings
543 # out of our control, we may receive options uppercased. Let's
544 # downcase at least the part before any equal sign.
545 if ($^O eq "VMS")
546 {
547 s/^([^=]*)/lc($1)/e;
548 }
549 s /^-no-/no-/; # some people just can't read the instructions
550
551 # rewrite some options in "enable-..." form
552 s /^-?-?shared$/enable-shared/;
553 s /^sctp$/enable-sctp/;
554 s /^threads$/enable-threads/;
555 s /^zlib$/enable-zlib/;
556 s /^zlib-dynamic$/enable-zlib-dynamic/;
557
558 if (/^(no|disable|enable)-(.+)$/)
559 {
560 my $word = $2;
561 if (!exists $deprecated_disablables{$word}
562 && !grep { $word =~ /^${_}$/ } @disablables)
563 {
564 $unsupported_options{$_} = 1;
565 next;
566 }
567 }
568 if (/^no-(.+)$/ || /^disable-(.+)$/)
569 {
570 foreach my $proto ((@tls, @dtls))
571 {
572 if ($1 eq "$proto-method")
573 {
574 $disabled{"$proto"} = "option($proto-method)";
575 last;
576 }
577 }
578 if ($1 eq "dtls")
579 {
580 foreach my $proto (@dtls)
581 {
582 $disabled{$proto} = "option(dtls)";
583 }
584 $disabled{"dtls"} = "option(dtls)";
585 }
586 elsif ($1 eq "ssl")
587 {
588 # Last one of its kind
589 $disabled{"ssl3"} = "option(ssl)";
590 }
591 elsif ($1 eq "tls")
592 {
593 # XXX: Tests will fail if all SSL/TLS
594 # protocols are disabled.
595 foreach my $proto (@tls)
596 {
597 $disabled{$proto} = "option(tls)";
598 }
599 }
600 elsif ($1 eq "static-engine")
601 {
602 delete $disabled{"dynamic-engine"};
603 }
604 elsif ($1 eq "dynamic-engine")
605 {
606 $disabled{"dynamic-engine"} = "option";
607 }
608 elsif (exists $deprecated_disablables{$1})
609 {
610 $deprecated_options{$_} = 1;
611 if (defined $deprecated_disablables{$1})
612 {
613 $disabled{$deprecated_disablables{$1}} = "option";
614 }
615 }
616 else
617 {
618 $disabled{$1} = "option";
619 }
620 # No longer an automatic choice
621 $auto_threads = 0 if ($1 eq "threads");
622 }
623 elsif (/^enable-(.+)$/)
624 {
625 if ($1 eq "static-engine")
626 {
627 $disabled{"dynamic-engine"} = "option";
628 }
629 elsif ($1 eq "dynamic-engine")
630 {
631 delete $disabled{"dynamic-engine"};
632 }
633 elsif ($1 eq "zlib-dynamic")
634 {
635 delete $disabled{"zlib"};
636 }
637 my $algo = $1;
638 delete $disabled{$algo};
639
640 # No longer an automatic choice
641 $auto_threads = 0 if ($1 eq "threads");
642 }
643 elsif (/^--strict-warnings$/)
644 {
645 $strict_warnings = 1;
646 }
647 elsif (/^--debug$/)
648 {
649 $config{build_type} = "debug";
650 }
651 elsif (/^--release$/)
652 {
653 $config{build_type} = "release";
654 }
655 elsif (/^386$/)
656 { $config{processor}=386; }
657 elsif (/^fips$/)
658 {
659 $config{fips}=1;
660 }
661 elsif (/^rsaref$/)
662 {
663 # No RSAref support any more since it's not needed.
664 # The check for the option is there so scripts aren't
665 # broken
666 }
667 elsif (/^nofipscanistercheck$/)
668 {
669 $config{fips} = 1;
670 $nofipscanistercheck = 1;
671 }
672 elsif (/^[-+]/)
673 {
674 if (/^--prefix=(.*)$/)
675 {
676 $config{prefix}=$1;
677 die "Directory given with --prefix MUST be absolute\n"
678 unless file_name_is_absolute($config{prefix});
679 }
680 elsif (/^--api=(.*)$/)
681 {
682 $config{api}=$1;
683 }
684 elsif (/^--libdir=(.*)$/)
685 {
686 $config{libdir}=$1;
687 }
688 elsif (/^--openssldir=(.*)$/)
689 {
690 $config{openssldir}=$1;
691 }
692 elsif (/^--with-zlib-lib=(.*)$/)
693 {
694 $withargs{zlib_lib}=$1;
695 }
696 elsif (/^--with-zlib-include=(.*)$/)
697 {
698 $withargs{zlib_include}=$1;
699 }
700 elsif (/^--with-fuzzer-lib=(.*)$/)
701 {
702 $withargs{fuzzer_lib}=$1;
703 }
704 elsif (/^--with-fuzzer-include=(.*)$/)
705 {
706 $withargs{fuzzer_include}=$1;
707 }
708 elsif (/^--with-fipslibdir=(.*)$/)
709 {
710 $config{fipslibdir}="$1/";
711 }
712 elsif (/^--with-baseaddr=(.*)$/)
713 {
714 $config{baseaddr}="$1";
715 }
716 elsif (/^--cross-compile-prefix=(.*)$/)
717 {
718 $config{cross_compile_prefix}=$1;
719 }
720 elsif (/^--config=(.*)$/)
721 {
722 read_config $1;
723 }
724 elsif (/^-[lL](.*)$/ or /^-Wl,/)
725 {
726 $libs.=$_." ";
727 }
728 elsif (/^-static$/)
729 {
730 $libs.=$_." ";
731 $disabled{"pic"} = "forced";
732 $disabled{"shared"} = "forced";
733 $disabled{"threads"} = "forced";
734 }
735 elsif (/^-D(.*)$/)
736 {
737 push @user_defines, $1;
738 }
739 else # common if (/^[-+]/), just pass down...
740 {
741 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
742 $user_cflags.=" ".$_;
743 }
744 }
745 else
746 {
747 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
748 $target=$_;
749 }
750 unless ($_ eq $target || /^no-/ || /^disable-/)
751 {
752 # "no-..." follows later after implied disactivations
753 # have been derived. (Don't take this too seriously,
754 # we really only write OPTIONS to the Makefile out of
755 # nostalgia.)
756
757 if ($config{options} eq "")
758 { $config{options} = $_; }
759 else
760 { $config{options} .= " ".$_; }
761 }
762
763 if (defined($config{api}) && !exists $apitable->{$config{api}}) {
764 die "***** Unsupported api compatibility level: $config{api}\n",
765 }
766
767 if (keys %deprecated_options)
768 {
769 warn "***** Deprecated options: ",
770 join(", ", keys %deprecated_options), "\n";
771 }
772 if (keys %unsupported_options)
773 {
774 die "***** Unsupported options: ",
775 join(", ", keys %unsupported_options), "\n";
776 }
777 }
778
779 if ($config{fips})
780 {
781 delete $disabled{"shared"} if ($disabled{"shared"} =~ /^default/);
782 }
783 else
784 {
785 @{$config{dirs}} = grep !/^fips$/, @{$config{dirs}};
786 }
787
788 my @tocheckfor = (keys %disabled);
789 while (@tocheckfor) {
790 my %new_tocheckfor = ();
791 my @cascade_copy = (@disable_cascades);
792 while (@cascade_copy) {
793 my ($test, $descendents) = (shift @cascade_copy, shift @cascade_copy);
794 if (ref($test) eq "CODE" ? $test->() : defined($disabled{$test})) {
795 foreach(grep { !defined($disabled{$_}) } @$descendents) {
796 $new_tocheckfor{$_} = 1; $disabled{$_} = "forced";
797 }
798 }
799 }
800 @tocheckfor = (keys %new_tocheckfor);
801 }
802
803 if ($target eq "TABLE") {
804 foreach (sort keys %table) {
805 print_table_entry($_, "TABLE");
806 }
807 exit 0;
808 }
809
810 if ($target eq "LIST") {
811 foreach (sort keys %table) {
812 print $_,"\n" unless $table{$_}->{template};
813 }
814 exit 0;
815 }
816
817 if ($target eq "HASH") {
818 print "%table = (\n";
819 foreach (sort keys %table) {
820 print_table_entry($_, "HASH");
821 }
822 exit 0;
823 }
824
825 # Backward compatibility?
826 if ($target =~ m/^CygWin32(-.*)$/) {
827 $target = "Cygwin".$1;
828 }
829
830 foreach (sort (keys %disabled))
831 {
832 $config{options} .= " no-$_";
833
834 printf " no-%-12s %-10s", $_, "[$disabled{$_}]";
835
836 if (/^dso$/)
837 { }
838 elsif (/^threads$/)
839 { }
840 elsif (/^shared$/)
841 { }
842 elsif (/^pic$/)
843 { }
844 elsif (/^zlib$/)
845 { }
846 elsif (/^dynamic-engine$/)
847 { }
848 elsif (/^makedepend$/)
849 { }
850 elsif (/^zlib-dynamic$/)
851 { }
852 elsif (/^sse2$/)
853 { $no_sse2 = 1; }
854 elsif (/^engine$/)
855 {
856 @{$config{dirs}} = grep !/^engines$/, @{$config{dirs}};
857 @{$config{sdirs}} = grep !/^engine$/, @{$config{sdirs}};
858 push @{$config{openssl_other_defines}}, "OPENSSL_NO_ENGINE";
859 }
860 else
861 {
862 my ($ALGO, $algo);
863 ($ALGO = $algo = $_) =~ tr/[\-a-z]/[_A-Z]/;
864
865 if (/^asm$/ || /^err$/ || /^hw$/ || /^hw-/ || /^async$/
866 || /^autoalginit/ || /^autoerrinit/)
867 {
868 push @{$config{openssl_other_defines}}, "OPENSSL_NO_$ALGO";
869 print " OPENSSL_NO_$ALGO";
870
871 if (/^err$/) { push @user_defines, "OPENSSL_NO_ERR"; }
872 }
873 else
874 {
875 ($ALGO,$algo) = ("RMD160","rmd160") if ($algo eq "ripemd");
876
877 push @{$config{openssl_algorithm_defines}}, "OPENSSL_NO_$ALGO";
878 print " OPENSSL_NO_$ALGO";
879
880 # fix-up crypto/directory name(s)
881 $algo="whrlpool" if $algo eq "whirlpool";
882 $algo="ripemd" if $algo eq "rmd160";
883 @{$config{sdirs}} = grep { $_ ne $algo} @{$config{sdirs}};
884
885 print " (skip dir)";
886 }
887 }
888
889 print "\n";
890 }
891
892 print "Configuring for $target\n";
893
894 # Support for legacy targets having a name starting with 'debug-'
895 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
896 if ($d) {
897 $config{build_type} = "debug";
898
899 # If we do not find debug-foo in the table, the target is set to foo.
900 if (!$table{$target}) {
901 $target = $t;
902 }
903 }
904 $config{target} = $target;
905 my %target = resolve_config($target);
906
907 &usage if (!%target || $target{template});
908
909 %target = ( %{$table{DEFAULTS}}, %target );
910
911 $target{exe_extension}="";
912 $target{exe_extension}=".exe" if ($config{target} eq "DJGPP"
913 || $config{target} =~ /^(?:Cygwin|mingw)/);
914 $target{exe_extension}=".pm" if ($config{target} =~ /vos/);
915
916 ($target{shared_extension_simple}=$target{shared_extension})
917 =~ s|\.\$\(SHLIB_MAJOR\)\.\$\(SHLIB_MINOR\)||;
918 $target{dso_extension}=$target{shared_extension_simple};
919 ($target{shared_import_extension}=$target{shared_extension_simple}.".a")
920 if ($config{target} =~ /^(?:Cygwin|mingw)/);
921
922
923 $config{cross_compile_prefix} = $ENV{'CROSS_COMPILE'}
924 if $config{cross_compile_prefix} eq "";
925
926 # Allow overriding the names of some tools. USE WITH CARE
927 # Note: only Unix cares about HASHBANGPERL... that explains
928 # the default string.
929 $config{perl} = $ENV{'PERL'} || ($^O ne "VMS" ? $^X : "perl");
930 $config{hashbangperl} =
931 $ENV{'HASHBANGPERL'} || $ENV{'PERL'} || "/usr/bin/env perl";
932 $target{cc} = $ENV{'CC'} || $target{cc} || "cc";
933 $target{ranlib} = $ENV{'RANLIB'} || $target{ranlib} ||
934 (which("$config{cross_compile_prefix}ranlib") ?
935 "\$(CROSS_COMPILE)ranlib" : "true");
936 $target{ar} = $ENV{'AR'} || $target{ar} || "ar";
937 $target{nm} = $ENV{'NM'} || $target{nm} || "nm";
938 $target{rc} =
939 $ENV{'RC'} || $ENV{'WINDRES'} || $target{rc} || "windres";
940
941 # Cache the C compiler command for reconfiguration
942 $config{cc} = $target{cc};
943
944 # For cflags, lflags, plib_lflags, ex_libs and defines, add the debug_
945 # or release_ attributes.
946 # Do it in such a way that no spurious space is appended (hence the grep).
947 $config{defines} = [];
948 $config{cflags} = "";
949 $config{ex_libs} = "";
950 $config{shared_ldflag} = "";
951
952 # Make sure build_scheme is consistent.
953 $target{build_scheme} = [ $target{build_scheme} ]
954 if ref($target{build_scheme}) ne "ARRAY";
955
956 my ($builder, $builder_platform, @builder_opts) =
957 @{$target{build_scheme}};
958
959 push @{$config{defines}}, "NDEBUG" if $config{build_type} eq "release";
960
961 if ($target =~ /^mingw/ && `$target{cc} --target-help 2>&1` =~ m/-mno-cygwin/m)
962 {
963 $config{cflags} .= " -mno-cygwin";
964 $config{shared_ldflag} .= " -mno-cygwin";
965 }
966
967 if ($target =~ /linux.*-mips/ && !$disabled{asm} && $user_cflags !~ /-m(ips|arch=)/) {
968 # minimally required architecture flags for assembly modules
969 $config{cflags}="-mips2 $config{cflags}" if ($target =~ /mips32/);
970 $config{cflags}="-mips3 $config{cflags}" if ($target =~ /mips64/);
971 }
972
973 my $no_shared_warn=0;
974 my $no_user_cflags=0;
975 my $no_user_defines=0;
976
977 # The DSO code currently always implements all functions so that no
978 # applications will have to worry about that from a compilation point
979 # of view. However, the "method"s may return zero unless that platform
980 # has support compiled in for them. Currently each method is enabled
981 # by a define "DSO_<name>" ... we translate the "dso_scheme" config
982 # string entry into using the following logic;
983 if (!$disabled{dso} && $target{dso_scheme} ne "")
984 {
985 $target{dso_scheme} =~ tr/[a-z]/[A-Z]/;
986 if ($target{dso_scheme} eq "DLFCN")
987 {
988 unshift @{$config{defines}}, "DSO_DLFCN", "HAVE_DLFCN_H";
989 }
990 elsif ($target{dso_scheme} eq "DLFCN_NO_H")
991 {
992 unshift @{$config{defines}}, "DSO_DLFCN";
993 }
994 else
995 {
996 unshift @{$config{defines}}, "DSO_$target{dso_scheme}";
997 }
998 }
999
1000 $config{ex_libs}="$libs$config{ex_libs}" if ($libs ne "");
1001
1002 if ($disabled{asm})
1003 {
1004 if ($config{fips})
1005 {
1006 @{$config{defines}} = grep !/^[BL]_ENDIAN$/, @{$config{defines}};
1007 @{$target{defines}} = grep !/^[BL]_ENDIAN$/, @{$target{defines}};
1008 }
1009 }
1010
1011 # If threads aren't disabled, check how possible they are
1012 unless ($disabled{threads}) {
1013 if ($auto_threads) {
1014 # Enabled by default, disable it forcibly if unavailable
1015 if ($target{thread_scheme} eq "(unknown)") {
1016 $disabled{threads} = "unavailable";
1017 }
1018 } else {
1019 # The user chose to enable threads explicitly, let's see
1020 # if there's a chance that's possible
1021 if ($target{thread_scheme} eq "(unknown)") {
1022 # If the user asked for "threads" and we don't have internal
1023 # knowledge how to do it, [s]he is expected to provide any
1024 # system-dependent compiler options that are necessary. We
1025 # can't truly check that the given options are correct, but
1026 # we expect the user to know what [s]He is doing.
1027 if ($no_user_cflags && $no_user_defines) {
1028 die "You asked for multi-threading support, but didn't\n"
1029 ,"provide any system-specific compiler options\n";
1030 }
1031 }
1032 }
1033 }
1034
1035 # If threads still aren't disabled, add a C macro to ensure the source
1036 # code knows about it. Any other flag is taken care of by the configs.
1037 unless($disabled{threads}) {
1038 foreach (("defines", "openssl_thread_defines")) {
1039 push @{$config{$_}}, "OPENSSL_THREADS";
1040 }
1041 }
1042
1043 # With "deprecated" disable all deprecated features.
1044 if (defined($disabled{"deprecated"})) {
1045 $config{api} = $maxapi;
1046 }
1047
1048 if ($target{shared_target} eq "")
1049 {
1050 $no_shared_warn = 1
1051 if ((!$disabled{shared} || !$disabled{"dynamic-engine"})
1052 && !$config{fips});
1053 $disabled{shared} = "no-shared-target";
1054 $disabled{pic} = $disabled{shared} = $disabled{"dynamic-engine"} =
1055 "no-shared-target";
1056 }
1057
1058 if ($disabled{"dynamic-engine"}) {
1059 push @{$config{defines}}, "OPENSSL_NO_DYNAMIC_ENGINE";
1060 $config{dynamic_engines} = 0;
1061 } else {
1062 push @{$config{defines}}, "OPENSSL_NO_STATIC_ENGINE";
1063 $config{dynamic_engines} = 1;
1064 }
1065
1066 unless ($disabled{"fuzz-libfuzzer"}) {
1067 $config{cflags} .= "-fsanitize-coverage=edge,indirect-calls ";
1068 }
1069
1070 unless ($disabled{asan}) {
1071 $config{cflags} .= "-fsanitize=address ";
1072 }
1073
1074 unless ($disabled{ubsan}) {
1075 # -DPEDANTIC or -fnosanitize=alignment may also be required on some
1076 # platforms.
1077 $config{cflags} .= "-fsanitize=undefined -fno-sanitize-recover=all ";
1078 }
1079
1080 unless ($disabled{msan}) {
1081 $config{cflags} .= "-fsanitize=memory ";
1082 }
1083
1084 unless ($disabled{"fuzz-libfuzzer"} && $disabled{"fuzz-afl"}
1085 && $disabled{asan} && $disabled{ubsan} && $disabled{msan}) {
1086 $config{cflags} .= "-fno-omit-frame-pointer -g ";
1087 }
1088 #
1089 # Platform fix-ups
1090 #
1091
1092 # This saves the build files from having to check
1093 if ($disabled{pic})
1094 {
1095 $target{shared_cflag} = $target{shared_ldflag} =
1096 $target{shared_rcflag} = "";
1097 }
1098 else
1099 {
1100 push @{$config{defines}}, "OPENSSL_PIC";
1101 }
1102
1103 if ($target{sys_id} ne "")
1104 {
1105 push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
1106 }
1107
1108 unless ($disabled{asm}) {
1109 $target{cpuid_asm_src}=$table{DEFAULTS}->{cpuid_asm_src} if ($config{processor} eq "386");
1110 $target{bn_asm_src} =~ s/\w+-gf2m.c// if (defined($disabled{ec2m}));
1111
1112 # bn-586 is the only one implementing bn_*_part_words
1113 push @{$config{defines}}, "OPENSSL_BN_ASM_PART_WORDS" if ($target{bn_asm_src} =~ /bn-586/);
1114 push @{$config{defines}}, "OPENSSL_IA32_SSE2" if (!$no_sse2 && $target{bn_asm_src} =~ /86/);
1115
1116 push @{$config{defines}}, "OPENSSL_BN_ASM_MONT" if ($target{bn_asm_src} =~ /-mont/);
1117 push @{$config{defines}}, "OPENSSL_BN_ASM_MONT5" if ($target{bn_asm_src} =~ /-mont5/);
1118 push @{$config{defines}}, "OPENSSL_BN_ASM_GF2m" if ($target{bn_asm_src} =~ /-gf2m/);
1119
1120 if ($config{fips}) {
1121 push @{$config{openssl_other_defines}}, "OPENSSL_FIPS";
1122 }
1123
1124 if ($target{sha1_asm_src}) {
1125 push @{$config{defines}}, "SHA1_ASM" if ($target{sha1_asm_src} =~ /sx86/ || $target{sha1_asm_src} =~ /sha1/);
1126 push @{$config{defines}}, "SHA256_ASM" if ($target{sha1_asm_src} =~ /sha256/);
1127 push @{$config{defines}}, "SHA512_ASM" if ($target{sha1_asm_src} =~ /sha512/);
1128 }
1129 if ($target{rc4_asm_src} ne $table{DEFAULTS}->{rc4_asm_src}) {
1130 push @{$config{defines}}, "RC4_ASM";
1131 }
1132 if ($target{md5_asm_src}) {
1133 push @{$config{defines}}, "MD5_ASM";
1134 }
1135 $target{cast_asm_src}=$table{DEFAULTS}->{cast_asm_src} unless $disabled{pic}; # CAST assembler is not PIC
1136 if ($target{rmd160_asm_src}) {
1137 push @{$config{defines}}, "RMD160_ASM";
1138 }
1139 if ($target{aes_asm_src}) {
1140 push @{$config{defines}}, "AES_ASM" if ($target{aes_asm_src} =~ m/\baes-/);;
1141 # aes-ctr.fake is not a real file, only indication that assembler
1142 # module implements AES_ctr32_encrypt...
1143 push @{$config{defines}}, "AES_CTR_ASM" if ($target{aes_asm_src} =~ s/\s*aes-ctr\.fake//);
1144 # aes-xts.fake indicates presence of AES_xts_[en|de]crypt...
1145 push @{$config{defines}}, "AES_XTS_ASM" if ($target{aes_asm_src} =~ s/\s*aes-xts\.fake//);
1146 $target{aes_asm_src} =~ s/\s*(vpaes|aesni)-x86\.s//g if ($no_sse2);
1147 push @{$config{defines}}, "VPAES_ASM" if ($target{aes_asm_src} =~ m/vpaes/);
1148 push @{$config{defines}}, "BSAES_ASM" if ($target{aes_asm_src} =~ m/bsaes/);
1149 }
1150 if ($target{wp_asm_src} =~ /mmx/) {
1151 if ($config{processor} eq "386") {
1152 $target{wp_asm_src}=$table{DEFAULTS}->{wp_asm_src};
1153 } elsif (!$disabled{"whirlpool"}) {
1154 push @{$config{defines}}, "WHIRLPOOL_ASM";
1155 }
1156 }
1157 if ($target{modes_asm_src} =~ /ghash-/) {
1158 push @{$config{defines}}, "GHASH_ASM";
1159 }
1160 if ($target{ec_asm_src} =~ /ecp_nistz256/) {
1161 push @{$config{defines}}, "ECP_NISTZ256_ASM";
1162 }
1163 if ($target{poly1305_asm_src} ne "") {
1164 push @{$config{defines}}, "POLY1305_ASM";
1165 }
1166 }
1167
1168 my $ecc = $target{cc};
1169 if ($^O ne "VMS" && !$disabled{makedepend}) {
1170 # Is the compiler gcc or clang? $ecc is used below to see if
1171 # error-checking can be turned on.
1172 my $ccpcc = "$config{cross_compile_prefix}$target{cc}";
1173 open(PIPE, "$ccpcc --version 2>&1 |");
1174 my $lines = 2;
1175 while ( <PIPE> ) {
1176 # Find the version number and save the major.
1177 m|(?:.*)\b(\d+)\.\d+\.\d+\b(?:.*)|;
1178 my $compiler_major = $1;
1179 # We know that GNU C version 3 and up as well as all clang
1180 # versions support dependency generation
1181 $config{makedepprog} = $ccpcc
1182 if (/clang/ || (/gcc/ && $compiler_major > 3));
1183 $ecc = "clang" if /clang/;
1184 $ecc = "gcc" if /gcc/;
1185 last if ($config{makedepprog} || !$lines--);
1186 }
1187 close(PIPE);
1188
1189 $config{makedepprog} = which('makedepend') unless $config{makedepprog};
1190 $disabled{makedepend} = "unavailable" unless $config{makedepprog};
1191 }
1192
1193
1194
1195 # Deal with bn_ops ###################################################
1196
1197 $config{bn_ll} =0;
1198 $config{export_var_as_fn} =0;
1199 my $def_int="unsigned int";
1200 $config{rc4_int} =$def_int;
1201 ($config{b64l},$config{b64},$config{b32})=(0,0,1);
1202
1203 my $count = 0;
1204 foreach (sort split(/\s+/,$target{bn_ops})) {
1205 $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1206 $config{export_var_as_fn}=1 if $_ eq 'EXPORT_VAR_AS_FN';
1207 $config{bn_ll}=1 if $_ eq 'BN_LLONG';
1208 $config{rc4_int}="unsigned char" if $_ eq 'RC4_CHAR';
1209 ($config{b64l},$config{b64},$config{b32})
1210 =(0,1,0) if $_ eq 'SIXTY_FOUR_BIT';
1211 ($config{b64l},$config{b64},$config{b32})
1212 =(1,0,0) if $_ eq 'SIXTY_FOUR_BIT_LONG';
1213 ($config{b64l},$config{b64},$config{b32})
1214 =(0,0,1) if $_ eq 'THIRTY_TWO_BIT';
1215 }
1216 die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1217 if $count > 1;
1218
1219
1220 # Hack cflags for better warnings (dev option) #######################
1221
1222 # "Stringify" the C flags string. This permits it to be made part of a string
1223 # and works as well on command lines.
1224 $config{cflags} =~ s/([\\\"])/\\$1/g;
1225
1226 if (defined($config{api})) {
1227 $config{openssl_api_defines} = [ "OPENSSL_MIN_API=".$apitable->{$config{api}} ];
1228 my $apiflag = sprintf("OPENSSL_API_COMPAT=%s", $apitable->{$config{api}});
1229 push @{$config{defines}}, $apiflag;
1230 }
1231
1232 if ($strict_warnings)
1233 {
1234 my $wopt;
1235 die "ERROR --strict-warnings requires gcc or clang"
1236 unless $ecc eq 'gcc' || $ecc eq 'clang';
1237 foreach $wopt (split /\s+/, $gcc_devteam_warn)
1238 {
1239 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1240 }
1241 if ($ecc eq "clang")
1242 {
1243 foreach $wopt (split /\s+/, $clang_devteam_warn)
1244 {
1245 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1246 }
1247 }
1248 }
1249
1250 unless ($disabled{"crypto-mdebug-backtrace"})
1251 {
1252 foreach my $wopt (split /\s+/, $memleak_devteam_backtrace)
1253 {
1254 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1255 }
1256 if ($target =~ /^BSD-/)
1257 {
1258 $config{ex_libs} .= " -lexecinfo";
1259 }
1260 }
1261
1262 if ($user_cflags ne "") { $config{cflags}="$config{cflags}$user_cflags"; }
1263 else { $no_user_cflags=1; }
1264 if (@user_defines) { $config{defines}=[ @{$config{defines}}, @user_defines ]; }
1265 else { $no_user_defines=1; }
1266
1267 # ALL MODIFICATIONS TO %config and %target MUST BE DONE FROM HERE ON
1268
1269 unless ($disabled{afalgeng}) {
1270 $config{afalgeng}="";
1271 if ($target =~ m/^linux/) {
1272 my $minver = 4*10000 + 1*100 + 0;
1273 if ($config{cross_compile_prefix} eq "") {
1274 my $verstr = `uname -r`;
1275 my ($ma, $mi1, $mi2) = split("\\.", $verstr);
1276 ($mi2) = $mi2 =~ /(\d+)/;
1277 my $ver = $ma*10000 + $mi1*100 + $mi2;
1278 if ($ver < $minver) {
1279 $disabled{afalgeng} = "too-old-kernel";
1280 } else {
1281 push @{$config{engdirs}}, "afalg";
1282 }
1283 } else {
1284 $disabled{afalgeng} = "cross-compiling";
1285 }
1286 } else {
1287 $disabled{afalgeng} = "not-linux";
1288 }
1289 }
1290
1291 push @{$config{openssl_other_defines}}, "OPENSSL_NO_AFALGENG" if ($disabled{afalgeng});
1292
1293 # If we use the unified build, collect information from build.info files
1294 my %unified_info = ();
1295
1296 my $buildinfo_debug = defined($ENV{CONFIGURE_DEBUG_BUILDINFO});
1297 if ($builder eq "unified") {
1298 # Store the name of the template file we will build the build file from
1299 # in %config. This may be useful for the build file itself.
1300 my $build_file_template;
1301
1302 for my $filename (( $builder_platform."-".$target{build_file}.".tmpl",
1303 $target{build_file}.".tmpl" )) {
1304 if (defined $ENV{$local_config_envname}) {
1305 if ($^O eq 'VMS') {
1306 # VMS environment variables are logical names,
1307 # which can be used as is
1308 $build_file_template = $local_config_envname . ':' . $filename;
1309 } else {
1310 $build_file_template = catfile($ENV{$local_config_envname},
1311 $filename);
1312 }
1313 }
1314
1315 last if -f $build_file_template;
1316
1317 $build_file_template = catfile($srcdir, "Configurations", $filename);
1318
1319 last if -f $build_file_template;
1320 }
1321 $config{build_file_template} = $build_file_template;
1322
1323 use lib catdir(dirname(__FILE__),"util");
1324 use with_fallback qw(Text::Template);
1325
1326 sub cleandir {
1327 my $base = shift;
1328 my $dir = shift;
1329 my $relativeto = shift || ".";
1330
1331 $dir = catdir($base,$dir) unless isabsolute($dir);
1332
1333 # Make sure the directories we're building in exists
1334 mkpath($dir);
1335
1336 my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
1337 #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1338 return $res;
1339 }
1340
1341 sub cleanfile {
1342 my $base = shift;
1343 my $file = shift;
1344 my $relativeto = shift || ".";
1345
1346 $file = catfile($base,$file) unless isabsolute($file);
1347
1348 my $d = dirname($file);
1349 my $f = basename($file);
1350
1351 # Make sure the directories we're building in exists
1352 mkpath($d);
1353
1354 my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
1355 #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1356 return $res;
1357 }
1358
1359 my @build_infos = ( [ ".", "build.info" ] );
1360 foreach (@{$config{dirs}}) {
1361 push @build_infos, [ $_, "build.info" ]
1362 if (-f catfile($srcdir, $_, "build.info"));
1363 }
1364 foreach (@{$config{sdirs}}) {
1365 push @build_infos, [ catdir("crypto", $_), "build.info" ]
1366 if (-f catfile($srcdir, "crypto", $_, "build.info"));
1367 }
1368 foreach (@{$config{engdirs}}) {
1369 push @build_infos, [ catdir("engines", $_), "build.info" ]
1370 if (-f catfile($srcdir, "engines", $_, "build.info"));
1371 }
1372
1373 $config{build_infos} = [ ];
1374
1375 foreach (@build_infos) {
1376 my $sourced = catdir($srcdir, $_->[0]);
1377 my $buildd = catdir($blddir, $_->[0]);
1378
1379 mkpath($buildd);
1380
1381 my $f = $_->[1];
1382 # The basic things we're trying to build
1383 my @programs = ();
1384 my @programs_install = ();
1385 my @libraries = ();
1386 my @libraries_install = ();
1387 my @engines = ();
1388 my @engines_install = ();
1389 my @scripts = ();
1390 my @scripts_install = ();
1391 my @extra = ();
1392 my @overrides = ();
1393 my @intermediates = ();
1394 my @rawlines = ();
1395
1396 my %ordinals = ();
1397 my %sources = ();
1398 my %shared_sources = ();
1399 my %includes = ();
1400 my %depends = ();
1401 my %renames = ();
1402 my %sharednames = ();
1403 my %generate = ();
1404
1405 push @{$config{build_infos}}, catfile(abs2rel($sourced, $blddir), $f);
1406 my $template = Text::Template->new(TYPE => 'FILE',
1407 SOURCE => catfile($sourced, $f));
1408 die "Something went wrong with $sourced/$f: $!\n" unless $template;
1409 my @text =
1410 split /^/m,
1411 $template->fill_in(HASH => { config => \%config,
1412 target => \%target,
1413 disabled => \%disabled,
1414 withargs => \%withargs,
1415 builddir => abs2rel($buildd, $blddir),
1416 sourcedir => abs2rel($sourced, $blddir),
1417 buildtop => abs2rel($blddir, $blddir),
1418 sourcetop => abs2rel($srcdir, $blddir) },
1419 DELIMITERS => [ "{-", "-}" ]);
1420
1421 # The top item of this stack has the following values
1422 # -2 positive already run and we found ELSE (following ELSIF should fail)
1423 # -1 positive already run (skip until ENDIF)
1424 # 0 negatives so far (if we're at a condition, check it)
1425 # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
1426 # 2 positive ELSE (following ELSIF should fail)
1427 my @skip = ();
1428 collect_information(
1429 collect_from_array([ @text ],
1430 qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
1431 $l1 =~ s/\\$//; $l1.$l2 }),
1432 # Info we're looking for
1433 qr/^\s*IF\[((?:\\.|[^\\\]])*)\]\s*$/
1434 => sub {
1435 if (! @skip || $skip[$#skip] > 0) {
1436 push @skip, !! $1;
1437 } else {
1438 push @skip, -1;
1439 }
1440 },
1441 qr/^\s*ELSIF\[((?:\\.|[^\\\]])*)\]\s*$/
1442 => sub { die "ELSIF out of scope" if ! @skip;
1443 die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
1444 $skip[$#skip] = -1 if $skip[$#skip] != 0;
1445 $skip[$#skip] = !! $1
1446 if $skip[$#skip] == 0; },
1447 qr/^\s*ELSE\s*$/
1448 => sub { die "ELSE out of scope" if ! @skip;
1449 $skip[$#skip] = -2 if $skip[$#skip] != 0;
1450 $skip[$#skip] = 2 if $skip[$#skip] == 0; },
1451 qr/^\s*ENDIF\s*$/
1452 => sub { die "ENDIF out of scope" if ! @skip;
1453 pop @skip; },
1454 qr/^\s*PROGRAMS(_NO_INST)?\s*=\s*(.*)\s*$/
1455 => sub {
1456 if (!@skip || $skip[$#skip] > 0) {
1457 my $install = $1;
1458 my @x = tokenize($2);
1459 push @programs, @x;
1460 push @programs_install, @x unless $install;
1461 }
1462 },
1463 qr/^\s*LIBS(_NO_INST)?\s*=\s*(.*)\s*$/
1464 => sub {
1465 if (!@skip || $skip[$#skip] > 0) {
1466 my $install = $1;
1467 my @x = tokenize($2);
1468 push @libraries, @x;
1469 push @libraries_install, @x unless $install;
1470 }
1471 },
1472 qr/^\s*ENGINES(_NO_INST)?\s*=\s*(.*)\s*$/
1473 => sub {
1474 if (!@skip || $skip[$#skip] > 0) {
1475 my $install = $1;
1476 my @x = tokenize($2);
1477 push @engines, @x;
1478 push @engines_install, @x unless $install;
1479 }
1480 },
1481 qr/^\s*SCRIPTS(_NO_INST)?\s*=\s*(.*)\s*$/
1482 => sub {
1483 if (!@skip || $skip[$#skip] > 0) {
1484 my $install = $1;
1485 my @x = tokenize($2);
1486 push @scripts, @x;
1487 push @scripts_install, @x unless $install;
1488 }
1489 },
1490 qr/^\s*EXTRA\s*=\s*(.*)\s*$/
1491 => sub { push @extra, tokenize($1)
1492 if !@skip || $skip[$#skip] > 0 },
1493 qr/^\s*OVERRIDES\s*=\s*(.*)\s*$/
1494 => sub { push @overrides, tokenize($1)
1495 if !@skip || $skip[$#skip] > 0 },
1496
1497 qr/^\s*ORDINALS\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/,
1498 => sub { push @{$ordinals{$1}}, tokenize($2)
1499 if !@skip || $skip[$#skip] > 0 },
1500 qr/^\s*SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1501 => sub { push @{$sources{$1}}, tokenize($2)
1502 if !@skip || $skip[$#skip] > 0 },
1503 qr/^\s*SHARED_SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1504 => sub { push @{$shared_sources{$1}}, tokenize($2)
1505 if !@skip || $skip[$#skip] > 0 },
1506 qr/^\s*INCLUDE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1507 => sub { push @{$includes{$1}}, tokenize($2)
1508 if !@skip || $skip[$#skip] > 0 },
1509 qr/^\s*DEPEND\[((?:\\.|[^\\\]])*)\]\s*=\s*(.*)\s*$/
1510 => sub { push @{$depends{$1}}, tokenize($2)
1511 if !@skip || $skip[$#skip] > 0 },
1512 qr/^\s*GENERATE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1513 => sub { push @{$generate{$1}}, $2
1514 if !@skip || $skip[$#skip] > 0 },
1515 qr/^\s*RENAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1516 => sub { push @{$renames{$1}}, tokenize($2)
1517 if !@skip || $skip[$#skip] > 0 },
1518 qr/^\s*SHARED_NAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1519 => sub { push @{$sharednames{$1}}, tokenize($2)
1520 if !@skip || $skip[$#skip] > 0 },
1521 qr/^\s*BEGINRAW\[((?:\\.|[^\\\]])+)\]\s*$/
1522 => sub {
1523 my $lineiterator = shift;
1524 my $target_kind = $1;
1525 while (defined $lineiterator->()) {
1526 s|\R$||;
1527 if (/^\s*ENDRAW\[((?:\\.|[^\\\]])+)\]\s*$/) {
1528 die "ENDRAW doesn't match BEGINRAW"
1529 if $1 ne $target_kind;
1530 last;
1531 }
1532 next if @skip && $skip[$#skip] <= 0;
1533 push @rawlines, $_
1534 if ($target_kind eq $target{build_file}
1535 || $target_kind eq $target{build_file}."(".$builder_platform.")");
1536 }
1537 },
1538 qr/^(?:#.*|\s*)$/ => sub { },
1539 "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" },
1540 "BEFORE" => sub {
1541 if ($buildinfo_debug) {
1542 print STDERR "DEBUG: Parsing ",join(" ", @_),"\n";
1543 print STDERR "DEBUG: ... before parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1544 }
1545 },
1546 "AFTER" => sub {
1547 if ($buildinfo_debug) {
1548 print STDERR "DEBUG: .... after parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1549 }
1550 },
1551 );
1552 die "runaway IF?" if (@skip);
1553
1554 foreach (keys %renames) {
1555 die "$_ renamed to more than one thing: "
1556 ,join(" ", @{$renames{$_}}),"\n"
1557 if scalar @{$renames{$_}} > 1;
1558 my $dest = cleanfile($buildd, $_, $blddir);
1559 my $to = cleanfile($buildd, $renames{$_}->[0], $blddir);
1560 die "$dest renamed to more than one thing: "
1561 ,$unified_info{rename}->{$dest}, $to
1562 unless !defined($unified_info{rename}->{$dest})
1563 or $unified_info{rename}->{$dest} eq $to;
1564 $unified_info{rename}->{$dest} = $to;
1565 }
1566
1567 foreach (@programs) {
1568 my $program = cleanfile($buildd, $_, $blddir);
1569 if ($unified_info{rename}->{$program}) {
1570 $program = $unified_info{rename}->{$program};
1571 }
1572 $unified_info{programs}->{$program} = 1;
1573 }
1574
1575 foreach (@programs_install) {
1576 my $program = cleanfile($buildd, $_, $blddir);
1577 if ($unified_info{rename}->{$program}) {
1578 $program = $unified_info{rename}->{$program};
1579 }
1580 $unified_info{install}->{programs}->{$program} = 1;
1581 }
1582
1583 foreach (@libraries) {
1584 my $library = cleanfile($buildd, $_, $blddir);
1585 if ($unified_info{rename}->{$library}) {
1586 $library = $unified_info{rename}->{$library};
1587 }
1588 $unified_info{libraries}->{$library} = 1;
1589 }
1590
1591 foreach (@libraries_install) {
1592 my $library = cleanfile($buildd, $_, $blddir);
1593 if ($unified_info{rename}->{$library}) {
1594 $library = $unified_info{rename}->{$library};
1595 }
1596 $unified_info{install}->{libraries}->{$library} = 1;
1597 }
1598
1599 die <<"EOF" if scalar @engines and !$config{dynamic_engines};
1600 ENGINES can only be used if configured with 'dynamic-engine'.
1601 This is usually a fault in a build.info file.
1602 EOF
1603 foreach (@engines) {
1604 my $library = cleanfile($buildd, $_, $blddir);
1605 if ($unified_info{rename}->{$library}) {
1606 $library = $unified_info{rename}->{$library};
1607 }
1608 $unified_info{engines}->{$library} = 1;
1609 }
1610
1611 foreach (@engines_install) {
1612 my $library = cleanfile($buildd, $_, $blddir);
1613 if ($unified_info{rename}->{$library}) {
1614 $library = $unified_info{rename}->{$library};
1615 }
1616 $unified_info{install}->{engines}->{$library} = 1;
1617 }
1618
1619 foreach (@scripts) {
1620 my $script = cleanfile($buildd, $_, $blddir);
1621 if ($unified_info{rename}->{$script}) {
1622 $script = $unified_info{rename}->{$script};
1623 }
1624 $unified_info{scripts}->{$script} = 1;
1625 }
1626
1627 foreach (@scripts_install) {
1628 my $script = cleanfile($buildd, $_, $blddir);
1629 if ($unified_info{rename}->{$script}) {
1630 $script = $unified_info{rename}->{$script};
1631 }
1632 $unified_info{install}->{scripts}->{$script} = 1;
1633 }
1634
1635 foreach (@extra) {
1636 my $extra = cleanfile($buildd, $_, $blddir);
1637 $unified_info{extra}->{$extra} = 1;
1638 }
1639
1640 foreach (@overrides) {
1641 my $override = cleanfile($buildd, $_, $blddir);
1642 $unified_info{overrides}->{$override} = 1;
1643 }
1644
1645 push @{$unified_info{rawlines}}, @rawlines;
1646
1647 unless ($disabled{shared}) {
1648 # Check sharednames.
1649 foreach (keys %sharednames) {
1650 my $dest = cleanfile($buildd, $_, $blddir);
1651 if ($unified_info{rename}->{$dest}) {
1652 $dest = $unified_info{rename}->{$dest};
1653 }
1654 die "shared_name for $dest with multiple values: "
1655 ,join(" ", @{$sharednames{$_}}),"\n"
1656 if scalar @{$sharednames{$_}} > 1;
1657 my $to = cleanfile($buildd, $sharednames{$_}->[0], $blddir);
1658 die "shared_name found for a library $dest that isn't defined\n"
1659 unless $unified_info{libraries}->{$dest};
1660 die "shared_name for $dest with multiple values: "
1661 ,$unified_info{sharednames}->{$dest}, ", ", $to
1662 unless !defined($unified_info{sharednames}->{$dest})
1663 or $unified_info{sharednames}->{$dest} eq $to;
1664 $unified_info{sharednames}->{$dest} = $to;
1665 }
1666
1667 # Additionally, we set up sharednames for libraries that don't
1668 # have any, as themselves.
1669 foreach (keys %{$unified_info{libraries}}) {
1670 if (!defined $unified_info{sharednames}->{$_}) {
1671 $unified_info{sharednames}->{$_} = $_
1672 }
1673 }
1674 }
1675
1676 foreach (keys %ordinals) {
1677 my $dest = $_;
1678 my $ddest = cleanfile($buildd, $_, $blddir);
1679 if ($unified_info{rename}->{$ddest}) {
1680 $ddest = $unified_info{rename}->{$ddest};
1681 }
1682 foreach (@{$ordinals{$dest}}) {
1683 my %known_ordinals =
1684 (
1685 crypto =>
1686 cleanfile($sourced, catfile("util", "libcrypto.num"), $blddir),
1687 ssl =>
1688 cleanfile($sourced, catfile("util", "libssl.num"), $blddir)
1689 );
1690 my $o = $known_ordinals{$_};
1691 die "Ordinals for $ddest defined more than once\n"
1692 if $unified_info{ordinals}->{$ddest};
1693 $unified_info{ordinals}->{$ddest} = [ $_, $o ];
1694 }
1695 }
1696
1697 foreach (keys %sources) {
1698 my $dest = $_;
1699 my $ddest = cleanfile($buildd, $_, $blddir);
1700 if ($unified_info{rename}->{$ddest}) {
1701 $ddest = $unified_info{rename}->{$ddest};
1702 }
1703 foreach (@{$sources{$dest}}) {
1704 my $s = cleanfile($sourced, $_, $blddir);
1705
1706 # If it isn't in the source tree, we assume it's generated
1707 # in the build tree
1708 if (! -f $s) {
1709 $s = cleanfile($buildd, $_, $blddir);
1710 }
1711 # We recognise C and asm files
1712 if ($s =~ /\.[csS]\b$/) {
1713 (my $o = $_) =~ s/\.[csS]\b$/.o/;
1714 $o = cleanfile($buildd, $o, $blddir);
1715 $unified_info{sources}->{$ddest}->{$o} = 1;
1716 $unified_info{sources}->{$o}->{$s} = 1;
1717 } else {
1718 $unified_info{sources}->{$ddest}->{$s} = 1;
1719 }
1720 }
1721 }
1722
1723 foreach (keys %shared_sources) {
1724 my $dest = $_;
1725 my $ddest = cleanfile($buildd, $_, $blddir);
1726 if ($unified_info{rename}->{$ddest}) {
1727 $ddest = $unified_info{rename}->{$ddest};
1728 }
1729 foreach (@{$shared_sources{$dest}}) {
1730 my $s = cleanfile($sourced, $_, $blddir);
1731
1732 # If it isn't in the source tree, we assume it's generated
1733 # in the build tree
1734 if (! -f $s) {
1735 $s = cleanfile($buildd, $_, $blddir);
1736 }
1737 # We recognise C and asm files
1738 if ($s =~ /\.[csS]\b$/) {
1739 (my $o = $_) =~ s/\.[csS]\b$/.o/;
1740 $o = cleanfile($buildd, $o, $blddir);
1741 $unified_info{shared_sources}->{$ddest}->{$o} = 1;
1742 $unified_info{sources}->{$o}->{$s} = 1;
1743 } else {
1744 die "unrecognised source file type for shared library: $s\n";
1745 }
1746 }
1747 }
1748
1749 foreach (keys %generate) {
1750 my $dest = $_;
1751 my $ddest = cleanfile($buildd, $_, $blddir);
1752 if ($unified_info{rename}->{$ddest}) {
1753 $ddest = $unified_info{rename}->{$ddest};
1754 }
1755 die "more than one generator for $dest: "
1756 ,join(" ", @{$generate{$_}}),"\n"
1757 if scalar @{$generate{$_}} > 1;
1758 my @generator = split /\s+/, $generate{$dest}->[0];
1759 $generator[0] = cleanfile($sourced, $generator[0], $blddir),
1760 $unified_info{generate}->{$ddest} = [ @generator ];
1761 }
1762
1763 foreach (keys %depends) {
1764 my $dest = $_;
1765 my $ddest = $dest eq "" ? "" : cleanfile($sourced, $_, $blddir);
1766
1767 # If the destination doesn't exist in source, it can only be
1768 # a generated file in the build tree.
1769 if ($ddest ne "" && ! -f $ddest) {
1770 $ddest = cleanfile($buildd, $_, $blddir);
1771 if ($unified_info{rename}->{$ddest}) {
1772 $ddest = $unified_info{rename}->{$ddest};
1773 }
1774 }
1775 foreach (@{$depends{$dest}}) {
1776 my $d = cleanfile($sourced, $_, $blddir);
1777
1778 # If we know it's generated, or assume it is because we can't
1779 # find it in the source tree, we set file we depend on to be
1780 # in the build tree rather than the source tree, and assume
1781 # and that there are lines to build it in a BEGINRAW..ENDRAW
1782 # section or in the Makefile template.
1783 if (! -f $d
1784 || (grep { $d eq $_ }
1785 map { cleanfile($srcdir, $_, $blddir) }
1786 grep { /\.h$/ } keys %{$unified_info{generate}})) {
1787 $d = cleanfile($buildd, $_, $blddir);
1788 }
1789 # Take note if the file to depend on is being renamed
1790 if ($unified_info{rename}->{$d}) {
1791 $d = $unified_info{rename}->{$d};
1792 }
1793 $unified_info{depends}->{$ddest}->{$d} = 1;
1794 # If we depend on a header file or a perl module, let's make
1795 # sure it can get included
1796 if ($dest ne "" && $d =~ /\.(h|pm)$/) {
1797 my $i = dirname($d);
1798 push @{$unified_info{includes}->{$ddest}->{source}}, $i
1799 unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}->{source}};
1800 }
1801 }
1802 }
1803
1804 foreach (keys %includes) {
1805 my $dest = $_;
1806 my $ddest = cleanfile($sourced, $_, $blddir);
1807
1808 # If the destination doesn't exist in source, it can only be
1809 # a generated file in the build tree.
1810 if (! -f $ddest) {
1811 $ddest = cleanfile($buildd, $_, $blddir);
1812 if ($unified_info{rename}->{$ddest}) {
1813 $ddest = $unified_info{rename}->{$ddest};
1814 }
1815 }
1816 foreach (@{$includes{$dest}}) {
1817 my $is = cleandir($sourced, $_, $blddir);
1818 my $ib = cleandir($buildd, $_, $blddir);
1819 push @{$unified_info{includes}->{$ddest}->{source}}, $is
1820 unless grep { $_ eq $is } @{$unified_info{includes}->{$ddest}->{source}};
1821 push @{$unified_info{includes}->{$ddest}->{build}}, $ib
1822 unless grep { $_ eq $ib } @{$unified_info{includes}->{$ddest}->{build}};
1823 }
1824 }
1825 }
1826
1827 ### Make unified_info a bit more efficient
1828 # One level structures
1829 foreach (("programs", "libraries", "engines", "scripts", "extra", "overrides")) {
1830 $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
1831 }
1832 # Two level structures
1833 foreach my $l1 (("install", "sources", "shared_sources", "ldadd", "depends")) {
1834 foreach my $l2 (sort keys %{$unified_info{$l1}}) {
1835 $unified_info{$l1}->{$l2} =
1836 [ sort keys %{$unified_info{$l1}->{$l2}} ];
1837 }
1838 }
1839 # Includes
1840 foreach my $dest (sort keys %{$unified_info{includes}}) {
1841 if (defined($unified_info{includes}->{$dest}->{build})) {
1842 my @source_includes =
1843 ( @{$unified_info{includes}->{$dest}->{source}} );
1844 $unified_info{includes}->{$dest} =
1845 [ @{$unified_info{includes}->{$dest}->{build}} ];
1846 foreach my $inc (@source_includes) {
1847 push @{$unified_info{includes}->{$dest}}, $inc
1848 unless grep { $_ eq $inc } @{$unified_info{includes}->{$dest}};
1849 }
1850 } else {
1851 $unified_info{includes}->{$dest} =
1852 [ @{$unified_info{includes}->{$dest}->{source}} ];
1853 }
1854 }
1855 }
1856
1857 # For the schemes that need it, we provide the old *_obj configs
1858 # from the *_asm_obj ones
1859 foreach (grep /_(asm|aux)_src$/, keys %target) {
1860 my $src = $_;
1861 (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
1862 ($target{$obj} = $target{$src}) =~ s/\.[csS]\b/.o/g;
1863 }
1864
1865 # Write down our configuration where it fits #########################
1866
1867 open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
1868 print OUT <<"EOF";
1869 package configdata;
1870
1871 use strict;
1872 use warnings;
1873
1874 use Exporter;
1875 #use vars qw(\@ISA \@EXPORT);
1876 our \@ISA = qw(Exporter);
1877 our \@EXPORT = qw(\%config \%target \%disabled \%withargs \%unified_info \@disablables);
1878
1879 EOF
1880 print OUT "our %config = (\n";
1881 foreach (sort keys %config) {
1882 if (ref($config{$_}) eq "ARRAY") {
1883 print OUT " ", $_, " => [ ", join(", ",
1884 map { quotify("perl", $_) }
1885 @{$config{$_}}), " ],\n";
1886 } else {
1887 print OUT " ", $_, " => ", quotify("perl", $config{$_}), ",\n"
1888 }
1889 }
1890 print OUT <<"EOF";
1891 );
1892
1893 EOF
1894 print OUT "our %target = (\n";
1895 foreach (sort keys %target) {
1896 if (ref($target{$_}) eq "ARRAY") {
1897 print OUT " ", $_, " => [ ", join(", ",
1898 map { quotify("perl", $_) }
1899 @{$target{$_}}), " ],\n";
1900 } else {
1901 print OUT " ", $_, " => ", quotify("perl", $target{$_}), ",\n"
1902 }
1903 }
1904 print OUT <<"EOF";
1905 );
1906
1907 EOF
1908 print OUT "our \%available_protocols = (\n";
1909 print OUT " tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n";
1910 print OUT " dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n";
1911 print OUT <<"EOF";
1912 );
1913
1914 EOF
1915 print OUT "our \@disablables = (\n";
1916 foreach (@disablables) {
1917 print OUT " ", quotify("perl", $_), ",\n";
1918 }
1919 print OUT <<"EOF";
1920 );
1921
1922 EOF
1923 print OUT "our \%disabled = (\n";
1924 foreach (sort keys %disabled) {
1925 print OUT " ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n";
1926 }
1927 print OUT <<"EOF";
1928 );
1929
1930 EOF
1931 print OUT "our %withargs = (\n";
1932 foreach (sort keys %withargs) {
1933 if (ref($withargs{$_}) eq "ARRAY") {
1934 print OUT " ", $_, " => [ ", join(", ",
1935 map { quotify("perl", $_) }
1936 @{$withargs{$_}}), " ],\n";
1937 } else {
1938 print OUT " ", $_, " => ", quotify("perl", $withargs{$_}), ",\n"
1939 }
1940 }
1941 print OUT <<"EOF";
1942 );
1943
1944 EOF
1945 if ($builder eq "unified") {
1946 my $recurse;
1947 $recurse = sub {
1948 my $indent = shift;
1949 foreach (@_) {
1950 if (ref $_ eq "ARRAY") {
1951 print OUT " "x$indent, "[\n";
1952 foreach (@$_) {
1953 $recurse->($indent + 4, $_);
1954 }
1955 print OUT " "x$indent, "],\n";
1956 } elsif (ref $_ eq "HASH") {
1957 my %h = %$_;
1958 print OUT " "x$indent, "{\n";
1959 foreach (sort keys %h) {
1960 if (ref $h{$_} eq "") {
1961 print OUT " "x($indent + 4), quotify("perl", $_), " => ", quotify("perl", $h{$_}), ",\n";
1962 } else {
1963 print OUT " "x($indent + 4), quotify("perl", $_), " =>\n";
1964 $recurse->($indent + 8, $h{$_});
1965 }
1966 }
1967 print OUT " "x$indent, "},\n";
1968 } else {
1969 print OUT " "x$indent, quotify("perl", $_), ",\n";
1970 }
1971 }
1972 };
1973 print OUT "our %unified_info = (\n";
1974 foreach (sort keys %unified_info) {
1975 if (ref $unified_info{$_} eq "") {
1976 print OUT " "x4, quotify("perl", $_), " => ", quotify("perl", $unified_info{$_}), ",\n";
1977 } else {
1978 print OUT " "x4, quotify("perl", $_), " =>\n";
1979 $recurse->(8, $unified_info{$_});
1980 }
1981 }
1982 print OUT <<"EOF";
1983 );
1984
1985 EOF
1986 }
1987 print OUT "1;\n";
1988 close(OUT);
1989
1990
1991 print "CC =$config{cross_compile_prefix}$target{cc}\n";
1992 print "CFLAG =$target{cflags} $config{cflags}\n";
1993 print "SHARED_CFLAG =$target{shared_cflag}\n";
1994 print "DEFINES =",join(" ", @{$target{defines}}, @{$config{defines}}),"\n";
1995 print "LFLAG =$target{lflags}\n";
1996 print "PLIB_LFLAG =$target{plib_lflags}\n";
1997 print "EX_LIBS =$target{ex_libs} $config{ex_libs}\n";
1998 print "APPS_OBJ =$target{apps_obj}\n";
1999 print "CPUID_OBJ =$target{cpuid_obj}\n";
2000 print "UPLINK_OBJ =$target{uplink_obj}\n";
2001 print "BN_ASM =$target{bn_obj}\n";
2002 print "EC_ASM =$target{ec_obj}\n";
2003 print "DES_ENC =$target{des_obj}\n";
2004 print "AES_ENC =$target{aes_obj}\n";
2005 print "BF_ENC =$target{bf_obj}\n";
2006 print "CAST_ENC =$target{cast_obj}\n";
2007 print "RC4_ENC =$target{rc4_obj}\n";
2008 print "RC5_ENC =$target{rc5_obj}\n";
2009 print "MD5_OBJ_ASM =$target{md5_obj}\n";
2010 print "SHA1_OBJ_ASM =$target{sha1_obj}\n";
2011 print "RMD160_OBJ_ASM=$target{rmd160_obj}\n";
2012 print "CMLL_ENC =$target{cmll_obj}\n";
2013 print "MODES_OBJ =$target{modes_obj}\n";
2014 print "PADLOCK_OBJ =$target{padlock_obj}\n";
2015 print "CHACHA_ENC =$target{chacha_obj}\n";
2016 print "POLY1305_OBJ =$target{poly1305_obj}\n";
2017 print "BLAKE2_OBJ =$target{blake2_obj}\n";
2018 print "PROCESSOR =$config{processor}\n";
2019 print "RANLIB =", $target{ranlib} eq '$(CROSS_COMPILE)ranlib' ?
2020 "$config{cross_compile_prefix}ranlib" :
2021 "$target{ranlib}", "\n";
2022 print "ARFLAGS =$target{arflags}\n";
2023 print "PERL =$config{perl}\n";
2024 print "\n";
2025 print "SIXTY_FOUR_BIT_LONG mode\n" if $config{b64l};
2026 print "SIXTY_FOUR_BIT mode\n" if $config{b64};
2027 print "THIRTY_TWO_BIT mode\n" if $config{b32};
2028 print "BN_LLONG mode\n" if $config{bn_ll};
2029 print "RC4 uses $config{rc4_int}\n" if $config{rc4_int} ne $def_int;
2030
2031 my %builders = (
2032 unified => sub {
2033 run_dofile(catfile($blddir, $target{build_file}),
2034 $config{build_file_template},
2035 catfile($srcdir, "Configurations", "common.tmpl"));
2036 },
2037 );
2038
2039 $builders{$builder}->($builder_platform, @builder_opts);
2040
2041 print <<"EOF";
2042
2043 Configured for $target.
2044 EOF
2045
2046 print <<"EOF" if ($disabled{threads} eq "unavailable");
2047
2048 The library could not be configured for supporting multi-threaded
2049 applications as the compiler options required on this system are not known.
2050 See file INSTALL for details if you need multi-threading.
2051 EOF
2052
2053 print <<"EOF" if ($no_shared_warn);
2054
2055 The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
2056 platform, so we will pretend you gave the option 'no-pic', which also disables
2057 'shared' and 'dynamic-engine'. If you know how to implement shared libraries
2058 or position independent code, please let us know (but please first make sure
2059 you have tried with a current version of OpenSSL).
2060 EOF
2061
2062 print <<"EOF" if (-f catfile($srcdir, "configdata.pm") && $srcdir ne $blddir);
2063
2064 WARNING: there are indications that another build was made in the source
2065 directory. This build may have picked up artifacts from that build, the
2066 safest course of action is to clean the source directory and redo this
2067 configuration.
2068 EOF
2069
2070 exit(0);
2071
2072 ######################################################################
2073 #
2074 # Helpers and utility functions
2075 #
2076
2077 # Configuration file reading #########################################
2078
2079 # Note: All of the helper functions are for lazy evaluation. They all
2080 # return a CODE ref, which will return the intended value when evaluated.
2081 # Thus, whenever there's mention of a returned value, it's about that
2082 # intended value.
2083
2084 # Helper function to implement conditional inheritance depending on the
2085 # value of $disabled{asm}. Used in inherit_from values as follows:
2086 #
2087 # inherit_from => [ "template", asm("asm_tmpl") ]
2088 #
2089 sub asm {
2090 my @x = @_;
2091 sub {
2092 $disabled{asm} ? () : @x;
2093 }
2094 }
2095
2096 # Helper function to implement conditional value variants, with a default
2097 # plus additional values based on the value of $config{build_type}.
2098 # Arguments are given in hash table form:
2099 #
2100 # picker(default => "Basic string: ",
2101 # debug => "debug",
2102 # release => "release")
2103 #
2104 # When configuring with --debug, the resulting string will be
2105 # "Basic string: debug", and when not, it will be "Basic string: release"
2106 #
2107 # This can be used to create variants of sets of flags according to the
2108 # build type:
2109 #
2110 # cflags => picker(default => "-Wall",
2111 # debug => "-g -O0",
2112 # release => "-O3")
2113 #
2114 sub picker {
2115 my %opts = @_;
2116 return sub { add($opts{default} || (),
2117 $opts{$config{build_type}} || ())->(); }
2118 }
2119
2120 # Helper function to combine several values of different types into one.
2121 # This is useful if you want to combine a string with the result of a
2122 # lazy function, such as:
2123 #
2124 # cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
2125 #
2126 sub combine {
2127 my @stuff = @_;
2128 return sub { add(@stuff)->(); }
2129 }
2130
2131 # Helper function to implement conditional values depending on the value
2132 # of $disabled{threads}. Can be used as follows:
2133 #
2134 # cflags => combine("-Wall", threads("-pthread"))
2135 #
2136 sub threads {
2137 my @flags = @_;
2138 return sub { add($disabled{threads} ? () : @flags)->(); }
2139 }
2140
2141
2142
2143 our $add_called = 0;
2144 # Helper function to implement adding values to already existing configuration
2145 # values. It handles elements that are ARRAYs, CODEs and scalars
2146 sub _add {
2147 my $separator = shift;
2148
2149 # If there's any ARRAY in the collection of values OR the separator
2150 # is undef, we will return an ARRAY of combined values, otherwise a
2151 # string of joined values with $separator as the separator.
2152 my $found_array = !defined($separator);
2153
2154 my @values =
2155 map {
2156 my $res = $_;
2157 while (ref($res) eq "CODE") {
2158 $res = $res->();
2159 }
2160 if (defined($res)) {
2161 if (ref($res) eq "ARRAY") {
2162 $found_array = 1;
2163 @$res;
2164 } else {
2165 $res;
2166 }
2167 } else {
2168 ();
2169 }
2170 } (@_);
2171
2172 $add_called = 1;
2173
2174 if ($found_array) {
2175 [ @values ];
2176 } else {
2177 join($separator, grep { defined($_) && $_ ne "" } @values);
2178 }
2179 }
2180 sub add_before {
2181 my $separator = " ";
2182 if (ref($_[$#_]) eq "HASH") {
2183 my $opts = pop;
2184 $separator = $opts->{separator};
2185 }
2186 my @x = @_;
2187 sub { _add($separator, @x, @_) };
2188 }
2189 sub add {
2190 my $separator = " ";
2191 if (ref($_[$#_]) eq "HASH") {
2192 my $opts = pop;
2193 $separator = $opts->{separator};
2194 }
2195 my @x = @_;
2196 sub { _add($separator, @_, @x) };
2197 }
2198
2199 # configuration reader, evaluates the input file as a perl script and expects
2200 # it to fill %targets with target configurations. Those are then added to
2201 # %table.
2202 sub read_config {
2203 my $fname = shift;
2204 open(CONFFILE, "< $fname")
2205 or die "Can't open configuration file '$fname'!\n";
2206 my $x = $/;
2207 undef $/;
2208 my $content = <CONFFILE>;
2209 $/ = $x;
2210 close(CONFFILE);
2211 my %targets = ();
2212 {
2213 local %table = %::table; # Protect %table from tampering
2214
2215 eval $content;
2216 warn $@ if $@;
2217 }
2218
2219 # For each target, check that it's configured with a hash table.
2220 foreach (keys %targets) {
2221 if (ref($targets{$_}) ne "HASH") {
2222 if (ref($targets{$_}) eq "") {
2223 warn "Deprecated target configuration for $_, ignoring...\n";
2224 } else {
2225 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
2226 }
2227 delete $targets{$_};
2228 }
2229 }
2230
2231 %table = (%table, %targets);
2232
2233 }
2234
2235 # configuration resolver. Will only resolve all the lazy evaluation
2236 # codeblocks for the chosen target and all those it inherits from,
2237 # recursively
2238 sub resolve_config {
2239 my $target = shift;
2240 my @breadcrumbs = @_;
2241
2242 # my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
2243
2244 if (grep { $_ eq $target } @breadcrumbs) {
2245 die "inherit_from loop! target backtrace:\n "
2246 ,$target,"\n ",join("\n ", @breadcrumbs),"\n";
2247 }
2248
2249 if (!defined($table{$target})) {
2250 warn "Warning! target $target doesn't exist!\n";
2251 return ();
2252 }
2253 # Recurse through all inheritances. They will be resolved on the
2254 # fly, so when this operation is done, they will all just be a
2255 # bunch of attributes with string values.
2256 # What we get here, though, are keys with references to lists of
2257 # the combined values of them all. We will deal with lists after
2258 # this stage is done.
2259 my %combined_inheritance = ();
2260 if ($table{$target}->{inherit_from}) {
2261 my @inherit_from =
2262 map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
2263 foreach (@inherit_from) {
2264 my %inherited_config = resolve_config($_, $target, @breadcrumbs);
2265
2266 # 'template' is a marker that's considered private to
2267 # the config that had it.
2268 delete $inherited_config{template};
2269
2270 foreach (keys %inherited_config) {
2271 if (!$combined_inheritance{$_}) {
2272 $combined_inheritance{$_} = [];
2273 }
2274 push @{$combined_inheritance{$_}}, $inherited_config{$_};
2275 }
2276 }
2277 }
2278
2279 # We won't need inherit_from in this target any more, since we've
2280 # resolved all the inheritances that lead to this
2281 delete $table{$target}->{inherit_from};
2282
2283 # Now is the time to deal with those lists. Here's the place to
2284 # decide what shall be done with those lists, all based on the
2285 # values of the target we're currently dealing with.
2286 # - If a value is a coderef, it will be executed with the list of
2287 # inherited values as arguments.
2288 # - If the corresponding key doesn't have a value at all or is the
2289 # empty string, the inherited value list will be run through the
2290 # default combiner (below), and the result becomes this target's
2291 # value.
2292 # - Otherwise, this target's value is assumed to be a string that
2293 # will simply override the inherited list of values.
2294 my $default_combiner = add();
2295
2296 my %all_keys =
2297 map { $_ => 1 } (keys %combined_inheritance,
2298 keys %{$table{$target}});
2299
2300 sub process_values {
2301 my $object = shift;
2302 my $inherited = shift; # Always a [ list ]
2303 my $target = shift;
2304 my $entry = shift;
2305
2306 $add_called = 0;
2307
2308 while(ref($object) eq "CODE") {
2309 $object = $object->(@$inherited);
2310 }
2311 if (!defined($object)) {
2312 return ();
2313 }
2314 elsif (ref($object) eq "ARRAY") {
2315 local $add_called; # To make sure recursive calls don't affect it
2316 return [ map { process_values($_, $inherited, $target, $entry) }
2317 @$object ];
2318 } elsif (ref($object) eq "") {
2319 return $object;
2320 } else {
2321 die "cannot handle reference type ",ref($object)
2322 ," found in target ",$target," -> ",$entry,"\n";
2323 }
2324 }
2325
2326 foreach (sort keys %all_keys) {
2327 my $previous = $combined_inheritance{$_};
2328
2329 # Current target doesn't have a value for the current key?
2330 # Assign it the default combiner, the rest of this loop body
2331 # will handle it just like any other coderef.
2332 if (!exists $table{$target}->{$_}) {
2333 $table{$target}->{$_} = $default_combiner;
2334 }
2335
2336 $table{$target}->{$_} = process_values($table{$target}->{$_},
2337 $combined_inheritance{$_},
2338 $target, $_);
2339 unless(defined($table{$target}->{$_})) {
2340 delete $table{$target}->{$_};
2341 }
2342 # if ($extra_checks &&
2343 # $previous && !($add_called || $previous ~~ $table{$target}->{$_})) {
2344 # warn "$_ got replaced in $target\n";
2345 # }
2346 }
2347
2348 # Finally done, return the result.
2349 return %{$table{$target}};
2350 }
2351
2352 sub usage
2353 {
2354 print STDERR $usage;
2355 print STDERR "\npick os/compiler from:\n";
2356 my $j=0;
2357 my $i;
2358 my $k=0;
2359 foreach $i (sort keys %table)
2360 {
2361 next if $table{$i}->{template};
2362 next if $i =~ /^debug/;
2363 $k += length($i) + 1;
2364 if ($k > 78)
2365 {
2366 print STDERR "\n";
2367 $k=length($i);
2368 }
2369 print STDERR $i . " ";
2370 }
2371 foreach $i (sort keys %table)
2372 {
2373 next if $table{$i}->{template};
2374 next if $i !~ /^debug/;
2375 $k += length($i) + 1;
2376 if ($k > 78)
2377 {
2378 print STDERR "\n";
2379 $k=length($i);
2380 }
2381 print STDERR $i . " ";
2382 }
2383 print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
2384 exit(1);
2385 }
2386
2387 sub run_dofile
2388 {
2389 my $out = shift;
2390 my @templates = @_;
2391
2392 unlink $out || warn "Can't remove $out, $!"
2393 if -f $out;
2394 foreach (@templates) {
2395 die "Can't open $_, $!" unless -f $_;
2396 }
2397 my $cmd = "$config{perl} \"-I.\" \"-Mconfigdata\" \"$dofile\" -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\"";
2398 #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
2399 system($cmd);
2400 exit 1 if $? != 0;
2401 rename("$out.new", $out) || die "Can't rename $out.new, $!";
2402 }
2403
2404 sub which
2405 {
2406 my ($name)=@_;
2407
2408 if (eval { require IPC::Cmd; 1; }) {
2409 IPC::Cmd->import();
2410 return scalar IPC::Cmd::can_run($name);
2411 } else {
2412 # if there is $directories component in splitpath,
2413 # then it's not something to test with $PATH...
2414 return $name if (File::Spec->splitpath($name))[1];
2415
2416 foreach (File::Spec->path()) {
2417 my $fullpath = catfile($_, "$name$target{exe_extension}");
2418 if (-f $fullpath and -x $fullpath) {
2419 return $fullpath;
2420 }
2421 }
2422 }
2423 }
2424
2425 # Configuration printer ##############################################
2426
2427 sub print_table_entry
2428 {
2429 my $target = shift;
2430 my %target = resolve_config($target);
2431 my $type = shift;
2432
2433 # Don't print the templates
2434 return if $target{template};
2435
2436 my @sequence = (
2437 "sys_id",
2438 "cc",
2439 "cflags",
2440 "defines",
2441 "unistd",
2442 "ld",
2443 "lflags",
2444 "plib_lflags",
2445 "ex_libs",
2446 "bn_ops",
2447 "cpuid_obj",
2448 "bn_obj",
2449 "ec_obj",
2450 "des_obj",
2451 "aes_obj",
2452 "bf_obj",
2453 "md5_obj",
2454 "sha1_obj",
2455 "cast_obj",
2456 "rc4_obj",
2457 "rmd160_obj",
2458 "rc5_obj",
2459 "wp_obj",
2460 "cmll_obj",
2461 "modes_obj",
2462 "padlock_obj",
2463 "thread_scheme",
2464 "perlasm_scheme",
2465 "dso_scheme",
2466 "shared_target",
2467 "shared_cflag",
2468 "shared_ldflag",
2469 "shared_rcflag",
2470 "shared_extension",
2471 "shared_extension_simple",
2472 "shared_import_extension",
2473 "dso_extension",
2474 "obj_extension",
2475 "exe_extension",
2476 "ranlib",
2477 "ar",
2478 "arflags",
2479 "multilib",
2480 "build_scheme",
2481 );
2482
2483 if ($type eq "TABLE") {
2484 print "\n";
2485 print "*** $target\n";
2486 foreach (@sequence) {
2487 if (ref($target{$_}) eq "ARRAY") {
2488 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
2489 } else {
2490 printf "\$%-12s = %s\n", $_, $target{$_};
2491 }
2492 }
2493 } elsif ($type eq "HASH") {
2494 my $largest =
2495 length((sort { length($a) <=> length($b) } @sequence)[-1]);
2496 print " '$target' => {\n";
2497 foreach (@sequence) {
2498 if ($target{$_}) {
2499 if (ref($target{$_}) eq "ARRAY") {
2500 print " '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
2501 } else {
2502 print " '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
2503 }
2504 }
2505 }
2506 print " },\n";
2507 }
2508 }
2509
2510 # Utility routines ###################################################
2511
2512 # On VMS, if the given file is a logical name, File::Spec::Functions
2513 # will consider it an absolute path. There are cases when we want a
2514 # purely syntactic check without checking the environment.
2515 sub isabsolute {
2516 my $file = shift;
2517
2518 # On non-platforms, we just use file_name_is_absolute().
2519 return file_name_is_absolute($file) unless $^O eq "VMS";
2520
2521 # If the file spec includes a device or a directpry spec,
2522 # file_name_is_absolute() is perfectly safe.
2523 return file_name_is_absolute($file) if $file =~ m|[:\[]|;
2524
2525 # Here, we know the given file spec isn't absolute
2526 return 0;
2527 }
2528
2529 # Makes a directory absolute and cleans out /../ in paths like foo/../bar
2530 # On some platforms, this uses rel2abs(), while on others, realpath() is used.
2531 # realpath() requires that at least all path components except the last is an
2532 # existing directory. On VMS, the last component of the directory spec must
2533 # exist.
2534 sub absolutedir {
2535 my $dir = shift;
2536
2537 # realpath() is quite buggy on VMS. It uses LIB$FID_TO_NAME, which
2538 # will return the volume name for the device, no matter what. Also,
2539 # it will return an incorrect directory spec if the argument is a
2540 # directory that doesn't exist.
2541 if ($^O eq "VMS") {
2542 return rel2abs($dir);
2543 }
2544
2545 # We use realpath() on Unix, since no other will properly clean out
2546 # a directory spec.
2547 use Cwd qw/realpath/;
2548
2549 return realpath($dir);
2550 }
2551
2552 sub quotify {
2553 my %processors = (
2554 perl => sub { my $x = shift;
2555 $x =~ s/([\\\$\@"])/\\$1/g;
2556 return '"'.$x.'"'; },
2557 );
2558 my $for = shift;
2559 my $processor =
2560 defined($processors{$for}) ? $processors{$for} : sub { shift; };
2561
2562 return map { $processor->($_); } @_;
2563 }
2564
2565 # collect_from_file($filename, $line_concat_cond_re, $line_concat)
2566 # $filename is a file name to read from
2567 # $line_concat_cond_re is a regexp detecting a line continuation ending
2568 # $line_concat is a CODEref that takes care of concatenating two lines
2569 sub collect_from_file {
2570 my $filename = shift;
2571 my $line_concat_cond_re = shift;
2572 my $line_concat = shift;
2573
2574 open my $fh, $filename || die "unable to read $filename: $!\n";
2575 return sub {
2576 my $saved_line = "";
2577 $_ = "";
2578 while (<$fh>) {
2579 s|\R$||;
2580 if (defined $line_concat) {
2581 $_ = $line_concat->($saved_line, $_);
2582 $saved_line = "";
2583 }
2584 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2585 $saved_line = $_;
2586 next;
2587 }
2588 return $_;
2589 }
2590 die "$filename ending with continuation line\n" if $_;
2591 close $fh;
2592 return undef;
2593 }
2594 }
2595
2596 # collect_from_array($array, $line_concat_cond_re, $line_concat)
2597 # $array is an ARRAYref of lines
2598 # $line_concat_cond_re is a regexp detecting a line continuation ending
2599 # $line_concat is a CODEref that takes care of concatenating two lines
2600 sub collect_from_array {
2601 my $array = shift;
2602 my $line_concat_cond_re = shift;
2603 my $line_concat = shift;
2604 my @array = (@$array);
2605
2606 return sub {
2607 my $saved_line = "";
2608 $_ = "";
2609 while (defined($_ = shift @array)) {
2610 s|\R$||;
2611 if (defined $line_concat) {
2612 $_ = $line_concat->($saved_line, $_);
2613 $saved_line = "";
2614 }
2615 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2616 $saved_line = $_;
2617 next;
2618 }
2619 return $_;
2620 }
2621 die "input text ending with continuation line\n" if $_;
2622 return undef;
2623 }
2624 }
2625
2626 # collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
2627 # $lineiterator is a CODEref that delivers one line at a time.
2628 # All following arguments are regex/CODEref pairs, where the regexp detects a
2629 # line and the CODEref does something with the result of the regexp.
2630 sub collect_information {
2631 my $lineiterator = shift;
2632 my %collectors = @_;
2633
2634 while(defined($_ = $lineiterator->())) {
2635 s|\R$||;
2636 my $found = 0;
2637 if ($collectors{"BEFORE"}) {
2638 $collectors{"BEFORE"}->($_);
2639 }
2640 foreach my $re (keys %collectors) {
2641 if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
2642 $collectors{$re}->($lineiterator);
2643 $found = 1;
2644 };
2645 }
2646 if ($collectors{"OTHERWISE"}) {
2647 $collectors{"OTHERWISE"}->($lineiterator, $_)
2648 unless $found || !defined $collectors{"OTHERWISE"};
2649 }
2650 if ($collectors{"AFTER"}) {
2651 $collectors{"AFTER"}->($_);
2652 }
2653 }
2654 }
2655
2656 # tokenize($line)
2657 # $line is a line of text to split up into tokens
2658 # returns a list of tokens
2659 #
2660 # Tokens are divided by spaces. If the tokens include spaces, they
2661 # have to be quoted with single or double quotes. Double quotes
2662 # inside a double quoted token must be escaped. Escaping is done
2663 # with backslash.
2664 # Basically, the same quoting rules apply for " and ' as in any
2665 # Unix shell.
2666 sub tokenize {
2667 my $line = my $debug_line = shift;
2668 my @result = ();
2669
2670 while ($line =~ s|^\s+||, $line ne "") {
2671 my $token = "";
2672 while ($line ne "" && $line !~ m|^\s|) {
2673 if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
2674 $token .= $1;
2675 $line = $';
2676 } elsif ($line =~ m/^'([^']*)'/) {
2677 $token .= $1;
2678 $line = $';
2679 } elsif ($line =~ m/^(\S+)/) {
2680 $token .= $1;
2681 $line = $';
2682 }
2683 }
2684 push @result, $token;
2685 }
2686
2687 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
2688 print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
2689 print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";
2690 }
2691 return @result;
2692 }
A mirror of the official openssl repository