5 ## Configure -- OpenSSL source tree configuration script
6 ## If editing this file, run this command before committing
7 ## make -f Makefile.in TABLE
13 use File::Spec::Functions;
15 # see INSTALL for instructions.
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-egd] [sctp] [386] [--prefix=DIR] [--openssldir=OPENSSLDIR] [--with-xxx[=vvv]] [--config=FILE] os/compiler[:flags]\n";
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 # --prefix prefix for the OpenSSL installation, which includes the
25 # directories bin, lib, include, share/man, share/doc/openssl
26 # This becomes the value of INSTALLTOP in Makefile
27 # (Default: /usr/local)
28 # --openssldir OpenSSL data area, such as openssl.cnf, certificates and keys.
29 # If it's a relative directory, it will be added on the directory
30 # given with --prefix.
31 # This becomes the value of OPENSSLDIR in Makefile and in C.
32 # (Default: PREFIX/ssl)
34 # --install_prefix Additional prefix for package builders (empty by
35 # default). This needn't be set in advance, you can
36 # just as well use "make INSTALL_PREFIX=/whatever install".
38 # --cross-compile-prefix Add specified prefix to binutils components.
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.
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
51 # [no-]shared [don't] try to create shared libraries when supported.
52 # no-asm do not use assembler
53 # no-dso do not compile in any native shared-library methods. This
54 # will ensure that all methods just return NULL.
55 # no-egd do not compile support for the entropy-gathering daemon APIs
56 # [no-]zlib [don't] compile support for zlib compression.
57 # zlib-dynamic Like "zlib", but the zlib library is expected to be a shared
58 # library and will be loaded in run-time by the OpenSSL library.
59 # sctp include SCTP support
60 # 386 generate 80386 code
61 # no-sse2 disables IA-32 SSE2 code, above option implies no-sse2
62 # no-<cipher> build without specified algorithm (rsa, idea, rc5, ...)
63 # -<xxx> +<xxx> compiler options are passed through
65 # DEBUG_SAFESTACK use type-safe stacks to enforce type-safety on stack items
66 # provided to stack calls. Generates unique stack functions for
67 # each possible stack type.
68 # DES_PTR use pointer lookup vs arrays in the DES in crypto/des/des_locl.h
69 # DES_RISC1 use different DES_ENCRYPT macro that helps reduce register
70 # dependancies but needs to more registers, good for RISC CPU's
71 # DES_RISC2 A different RISC variant.
72 # DES_UNROLL unroll the inner DES loop, sometimes helps, somtimes hinders.
73 # DES_INT use 'int' instead of 'long' for DES_LONG in crypto/des/des.h
74 # This is used on the DEC Alpha where long is 8 bytes
76 # BN_LLONG use the type 'long long' in crypto/bn/bn.h
77 # MD2_CHAR use 'char' instead of 'int' for MD2_INT in crypto/md2/md2.h
78 # MD2_LONG use 'long' instead of 'int' for MD2_INT in crypto/md2/md2.h
79 # IDEA_SHORT use 'short' instead of 'int' for IDEA_INT in crypto/idea/idea.h
80 # IDEA_LONG use 'long' instead of 'int' for IDEA_INT in crypto/idea/idea.h
81 # RC2_SHORT use 'short' instead of 'int' for RC2_INT in crypto/rc2/rc2.h
82 # RC2_LONG use 'long' instead of 'int' for RC2_INT in crypto/rc2/rc2.h
83 # RC4_CHAR use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
84 # RC4_LONG use 'long' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
85 # RC4_INDEX define RC4_INDEX in crypto/rc4/rc4_locl.h. This turns on
86 # array lookups instead of pointer use.
87 # RC4_CHUNK enables code that handles data aligned at long (natural CPU
89 # RC4_CHUNK_LL enables code that handles data aligned at long long boundary
90 # (intended for 64-bit CPUs running 32-bit OS).
91 # BF_PTR use 'pointer arithmatic' for Blowfish (unsafe on Alpha).
92 # BF_PTR2 intel specific version (generic version is more efficient).
94 # Following are set automatically by this script
96 # MD5_ASM use some extra md5 assember,
97 # SHA1_ASM use some extra sha1 assember, must define L_ENDIAN for x86
98 # RMD160_ASM use some extra ripemd160 assember,
99 # SHA256_ASM sha256_block is implemented in assembler
100 # SHA512_ASM sha512_block is implemented in assembler
101 # AES_ASM ASE_[en|de]crypt is implemented in assembler
103 # Minimum warning options... any contributions to OpenSSL should at least get
106 my $gcc_devteam_warn = "-Wall -pedantic -DPEDANTIC -Wno-long-long -Wsign-compare -Wmissing-prototypes -Wshadow -Wformat -Wtype-limits -Werror -DREF_CHECK -DDEBUG_UNUSED";
108 # These are used in addition to $gcc_devteam_warn when the compiler is clang.
109 # TODO(openssl-team): fix problems and investigate if (at least) the
110 # following warnings can also be enabled:
111 # -Wswitch-enum, -Wunused-macros, -Wmissing-field-initializers,
113 # -Wunreachable-code -Wunused-parameter -Wlanguage-extension-token
114 # -Wextended-offsetof
115 my $clang_devteam_warn = "-Wno-unused-parameter -Wno-missing-field-initializers -Wno-language-extension-token -Wno-extended-offsetof -Wconditional-uninitialized -Qunused-arguments -Wincompatible-pointer-types-discards-qualifiers -Wmissing-variable-declarations";
117 # Warn that "make depend" should be run?
118 my $warn_make_depend = 0;
120 # These are used in addition to $gcc_devteam_warn unless this is a mingw build.
121 # This adds backtrace information to the memory leak info.
122 my $memleak_devteam_backtrace = "-rdynamic -DCRYPTO_MDEBUG_BACKTRACE";
125 my $strict_warnings = 0;
127 my $x86_gcc_des="DES_PTR DES_RISC1 DES_UNROLL";
129 # MD2_CHAR slags pentium pros
130 my $x86_gcc_opts="RC4_INDEX MD2_INT";
132 # As for $BSDthreads. Idea is to maintain "collective" set of flags,
133 # which would cover all BSD flavors. -pthread applies to them all,
134 # but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
135 # -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
136 # which has to be accompanied by explicit -D_THREAD_SAFE and
137 # sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
138 # seems to be sufficient?
139 my $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
142 # API compability name to version number mapping.
144 my $maxapi = "1.1.0"; # API for "no-deprecated" builds
146 "1.1.0" => "0x10100000L",
147 "1.0.0" => "0x10000000L",
148 "0.9.8" => "0x00908000L",
151 my $base_target = "BASE"; # The template that all other inherit from
154 # Forward declarations ###############################################
156 # read_config(filename)
158 # Reads a configuration file and populates %table with the contents
159 # (which the configuration file places in %targets).
162 # resolve_config(target)
164 # Resolves all the late evalutations, inheritances and so on for the
165 # chosen target and any target it inherits from.
169 my ($vol, $dir, $dummy) = File::Spec->splitpath($0);
170 my $pattern = File::Spec->catpath($vol, $dir, "Configurations/*.conf");
171 foreach (sort glob($pattern) ) {
179 my $install_prefix= "$ENV{'INSTALL_PREFIX'}";
180 my $cross_compile_prefix="";
181 my $fipslibdir="/usr/local/ssl/fips-2.0/lib/";
182 my $nofipscanistercheck=0;
183 my $baseaddr="0xFB00000";
186 my $no_shared=0; # but "no-shared" is default
187 my $zlib=1; # but "no-zlib" is default
192 my $Makefile="Makefile";
198 # Known TLS and DTLS protocols
199 my @tls = qw(ssl3 tls1 tls1_1 tls1_2);
200 my @dtls = qw(dtls1 dtls1_2);
202 # Explicitelly known options that are possible to disable. They can
203 # be regexps, and will be used like this: /^no-${option}$/
204 # For developers: keep it sorted alphabetically
231 "ec_nistp_64_gcc_128",
240 "locking", # Really???
257 "rijndael", # Old AES name
282 foreach my $proto ((@tls, @dtls))
284 push(@disablables, $proto);
285 push(@disablables, "$proto-method");
288 # All of the following is disabled by default (RC5 was enabled before 0.9.8):
290 my %disabled = ( # "what" => "comment" [or special keyword "experimental"]
291 "ec_nistp_64_gcc_128" => "default",
293 "jpake" => "experimental",
297 "shared" => "default",
298 "ssl-trace" => "default",
299 "store" => "experimental",
300 "unit-test" => "default",
302 "zlib-dynamic" => "default",
303 "crypto-mdebug" => "default",
305 my @experimental = ();
307 # Note: => pair form used for aesthetics, not to truly make a hash table
308 my @disable_cascades = (
309 # "what" => [ "cascade", ... ]
310 sub { $processor eq "386" }
313 "ssl3-method" => [ "ssl3" ],
314 "zlib" => [ "zlib-dynamic" ],
315 "rijndael" => [ "aes" ],
317 "ec" => [ "ecdsa", "ecdh", "gost" ],
321 "dgram" => [ "dtls" ],
324 # SSL 3.0, (D)TLS 1.0 and TLS 1.1 require MD5 and SHA
325 "md5" => [ "ssl", "tls1", "tls1_1", "dtls1" ],
326 "sha" => [ "ssl", "tls1", "tls1_1", "dtls1" ],
328 # Additionally, SSL 3.0 requires either RSA or DSA+DH
330 && ($disabled{dsa} || $disabled{dh}); }
333 # (D)TLS 1.0 and TLS 1.1 also require either RSA or DSA+DH
334 # or ECDSA + ECDH. (D)TLS 1.2 has this requirement as well.
335 # (XXX: We don't support PSK-only builds).
337 && ($disabled{dsa} || $disabled{dh})
338 && ($disabled{ecdsa} || $disabled{ecdh}); }
339 => [ "tls1", "tls1_1", "tls1_2",
340 "dtls1", "dtls1_2" ],
344 # SRP and HEARTBEATS require TLSEXT
345 "tlsext" => [ "srp", "heartbeats" ],
348 # Avoid protocol support holes. Also disable all versions below N, if version
349 # N is disabled while N+1 is enabled.
351 my @list = (reverse @tls);
352 while ((my $first, my $second) = (shift @list, shift @list)) {
354 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
356 unshift @list, $second;
358 my @list = (reverse @dtls);
359 while ((my $first, my $second) = (shift @list, shift @list)) {
361 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
363 unshift @list, $second;
366 # Construct the string of what $depflags should look like with the defaults
367 # from %disabled above. (we need this to see if we should advise the user
368 # to run "make depend"):
369 my $default_depflags = " ".join(" ",
370 map { my $x = $_; $x =~ tr{[a-z]-}{[A-Z]_}; "-DOPENSSL_NO_$x"; }
371 grep { $disabled{$_} !~ /\(no-depflags\)$/ }
372 sort keys %disabled);
374 # Explicit "no-..." options will be collected in %disabled along with the defaults.
375 # To remove something from %disabled, use "enable-foo" (unless it's experimental).
376 # For symmetry, "disable-foo" is a synonym for "no-foo".
378 # For features called "experimental" here, a more explicit "experimental-foo" is needed to enable.
379 # We will collect such requests in @experimental.
380 # To avoid accidental use of experimental features, applications will have to use -DOPENSSL_EXPERIMENTAL_FOO.
385 &usage if ($#ARGV < 0);
389 my $openssl_experimental_defines="";
390 my $openssl_algorithm_defines="";
391 my $openssl_thread_defines="";
392 my $openssl_sys_defines="";
393 my $openssl_other_defines="";
400 my $build_prefix = "release_";
404 if (grep /^reconf(igure)?$/, @argvcopy) {
405 if (open IN, "<$Makefile") {
408 if (/^CONFIGURE_ARGS=\s*(.*)\s*/) {
410 if ($line =~ /^\s*\(/) {
411 # New form perl expression saved in Makefile, eval it
412 @argvcopy = eval $line;
414 # Older form, we split the string and hope for the best
415 @argvcopy = split /\s+/, $line;
417 die "Incorrect data to reconfigure, please do a normal configuration\n"
418 if (grep(/^reconf/,@argvcopy));
419 } elsif (/^CROSS_COMPILE=\s*(.*)/) {
420 $ENV{CROSS_COMPILE}=$1;
421 } elsif (/^CC=\s*(?:\$\(CROSS_COMPILE\))?(.*?)$/) {
425 print "Reconfiguring with: ", join(" ",@argvcopy), "\n";
426 print " CROSS_COMPILE = ",$ENV{CROSS_COMPILE},"\n"
427 if $ENV{CROSS_COMPILE};
428 print " CC = ",$ENV{CC},"\n" if $ENV{CC};
431 die "Insufficient data to reconfigure, please do a normal configuration\n";
436 my %unsupported_options = ();
439 s /^-no-/no-/; # some people just can't read the instructions
441 # rewrite some options in "enable-..." form
442 s /^-?-?shared$/enable-shared/;
443 s /^sctp$/enable-sctp/;
444 s /^threads$/enable-threads/;
445 s /^zlib$/enable-zlib/;
446 s /^zlib-dynamic$/enable-zlib-dynamic/;
448 if (/^(no|disable|enable|experimental)-(.+)$/)
451 if (!grep { $word =~ /^${_}$/ } @disablables)
453 $unsupported_options{$_} = 1;
457 if (/^no-(.+)$/ || /^disable-(.+)$/)
459 if (!($disabled{$1} eq "experimental"))
461 foreach my $proto ((@tls, @dtls))
463 if ($1 eq "$proto-method")
465 $disabled{"$proto"} = "option($proto-method)";
471 foreach my $proto (@dtls)
473 $disabled{$proto} = "option(dtls)";
478 # Last one of its kind
479 $disabled{"ssl3"} = "option(ssl)";
483 # XXX: Tests will fail if all SSL/TLS
484 # protocols are disabled.
485 foreach my $proto (@tls)
487 $disabled{$proto} = "option(tls)";
492 $disabled{$1} = "option";
496 elsif (/^enable-(.+)$/ || /^experimental-(.+)$/)
499 if ($disabled{$algo} eq "experimental")
501 die "You are requesting an experimental feature; please say 'experimental-$algo' if you are sure\n"
502 unless (/^experimental-/);
503 push @experimental, $algo;
505 delete $disabled{$algo};
507 $threads = 1 if ($algo eq "threads");
509 elsif (/^--strict-warnings$/)
511 $strict_warnings = 1;
515 $build_prefix = "debug_";
517 elsif (/^--release$/)
519 $build_prefix = "release_";
529 # No RSAref support any more since it's not needed.
530 # The check for the option is there so scripts aren't
533 elsif (/^nofipscanistercheck$/)
536 $nofipscanistercheck = 1;
540 if (/^--prefix=(.*)$/)
544 elsif (/^--api=(.*)$/)
548 elsif (/^--libdir=(.*)$/)
552 elsif (/^--openssldir=(.*)$/)
556 elsif (/^--install.prefix=(.*)$/)
560 elsif (/^--with-zlib-lib=(.*)$/)
562 $withargs{"zlib-lib"}=$1;
564 elsif (/^--with-zlib-include=(.*)$/)
566 $withargs{"zlib-include"}="-I$1";
568 elsif (/^--with-fipslibdir=(.*)$/)
572 elsif (/^--with-baseaddr=(.*)$/)
576 elsif (/^--cross-compile-prefix=(.*)$/)
578 $cross_compile_prefix=$1;
580 elsif (/^--config=(.*)$/)
584 elsif (/^-[lL](.*)$/ or /^-Wl,/)
588 else # common if (/^[-+]/), just pass down...
590 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
594 elsif ($_ =~ /^([^:]+):(.+)$/)
596 eval "\$table{\$1} = \"$2\""; # allow $xxx constructs in the string
601 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
604 unless ($_ eq $target || /^no-/ || /^disable-/)
606 # "no-..." follows later after implied disactivations
607 # have been derived. (Don't take this too seroiusly,
608 # we really only write OPTIONS to the Makefile out of
614 { $options .= " ".$_; }
617 if (defined($api) && !exists $apitable->{$api}) {
618 die "***** Unsupported api compatibility level: $api\n",
621 if (keys %unsupported_options)
623 die "***** Unsupported options: ",
624 join(", ", keys %unsupported_options), "\n";
630 delete $disabled{"shared"} if ($disabled{"shared"} =~ /^default/);
633 my @tocheckfor = (keys %disabled);
634 while (@tocheckfor) {
635 my %new_tocheckfor = ();
636 my @cascade_copy = (@disable_cascades);
637 while (@cascade_copy) {
638 my ($test, $descendents) = (shift @cascade_copy, shift @cascade_copy);
639 if (ref($test) eq "CODE" ? $test->() : defined($disabled{$test})) {
641 $new_tocheckfor{$_} => 1; $disabled{$_} = "forced";
642 } grep { !defined($disabled{$_}) } @$descendents;
645 @tocheckfor = (keys %new_tocheckfor);
648 if ($target eq "TABLE") {
649 foreach $target (sort keys %table) {
650 print_table_entry($target, "TABLE");
655 if ($target eq "LIST") {
656 foreach (sort keys %table) {
663 if ($target eq "HASH") {
664 print "%table = (\n";
665 foreach (sort keys %table) {
666 print_table_entry($_, "HASH");
671 if ($target =~ m/^CygWin32(-.*)$/) {
672 $target = "Cygwin".$1;
675 foreach (sort (keys %disabled))
677 $options .= " no-$_";
679 printf " no-%-12s %-10s", $_, "[$disabled{$_}]";
689 elsif (/^static-engine$/)
691 elsif (/^zlib-dynamic$/)
698 ($ALGO = $algo = $_) =~ tr/[\-a-z]/[_A-Z]/;
700 if (/^asm$/ || /^err$/ || /^hw$/ || /^hw-/)
702 $openssl_other_defines .= "#define OPENSSL_NO_$ALGO\n";
703 print " OPENSSL_NO_$ALGO";
705 if (/^err$/) { $flags .= "-DOPENSSL_NO_ERR "; }
706 elsif (/^asm$/) { $no_asm = 1; }
710 ($ALGO,$algo) = ("RMD160","rmd160") if ($algo eq "ripemd");
712 $openssl_algorithm_defines .= "#define OPENSSL_NO_$ALGO\n";
713 print " OPENSSL_NO_$ALGO";
716 # fix-up crypto/directory name(s)
717 $skip[$#skip]="whrlpool" if $algo eq "whirlpool";
718 $skip[$#skip]="ripemd" if $algo eq "rmd160";
722 $depflags .= " -DOPENSSL_NO_$ALGO";
731 foreach (sort @experimental)
734 ($ALGO = $_) =~ tr/[a-z]/[A-Z]/;
736 # opensslconf.h will set OPENSSL_NO_... unless OPENSSL_EXPERIMENTAL_... is defined
737 $openssl_experimental_defines .= "#define OPENSSL_NO_$ALGO\n";
738 $exp_cflags .= " -DOPENSSL_EXPERIMENTAL_$ALGO";
741 print "Configuring for $target\n";
743 # Support for legacy targets having a name starting with 'debug-'
744 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
746 $build_prefix = "debug_";
748 # If we do not find debug-foo in the table, the target is set to foo.
749 if (!$table{$target}) {
754 delete $table{$base_target}->{template}; # or the next test will fail.
755 my %target = ( %{$table{$base_target}}, resolve_config($target) );
757 &usage if (!%target || $target{template});
759 $exe_ext=".exe" if ($target eq "Cygwin" || $target eq "DJGPP" || $target =~ /^mingw/);
760 $exe_ext=".nlm" if ($target =~ /netware/);
761 $exe_ext=".pm" if ($target =~ /vos/);
763 $default_ranlib= &which("ranlib") or $default_ranlib="true";
764 $perl=$ENV{'PERL'} or $perl=&which("perl5") or $perl=&which("perl")
766 my $make = $ENV{'MAKE'} || "make";
768 $cross_compile_prefix=$ENV{'CROSS_COMPILE'} if $cross_compile_prefix eq "";
770 $prefix = "/usr/local" if !$prefix;
771 $openssldir = "ssl" if !$openssldir;
772 $openssldir = catdir($prefix, $openssldir)
773 unless file_name_is_absolute($openssldir);
776 # Allow environment CC to override compiler...
777 my $cc = $ENV{CC} || $target{cc};
779 # For cflags and lflags, add the debug_ or release_ attributes
780 # Do it in such a way that no spurious space is appended (hence the grep).
781 my $cflags = join(" ",
782 grep { $_ } ($target{cflags},
783 $target{$build_prefix."cflags"}));
784 my $lflags = join(" ",
785 grep { $_ } ($target{lflags},
786 $target{$build_prefix."lflags"}));
788 my $unistd = $target{unistd};
789 my $thread_cflag = $target{thread_cflag};
790 my $sys_id = $target{sys_id};
791 my $bn_ops = $target{bn_ops};
792 my $cpuid_obj = $target{cpuid_obj};
793 my $bn_obj = $target{bn_obj};
794 my $ec_obj = $target{ec_obj};
795 my $des_obj = $target{des_obj};
796 my $aes_obj = $target{aes_obj};
797 my $bf_obj = $target{bf_obj};
798 my $md5_obj = $target{md5_obj};
799 my $sha1_obj = $target{sha1_obj};
800 my $cast_obj = $target{cast_obj};
801 my $rc4_obj = $target{rc4_obj};
802 my $rmd160_obj = $target{rmd160_obj};
803 my $rc5_obj = $target{rc5_obj};
804 my $wp_obj = $target{wp_obj};
805 my $cmll_obj = $target{cmll_obj};
806 my $modes_obj = $target{modes_obj};
807 my $engines_obj = $target{engines_obj};
808 my $chacha_obj = $target{chacha_obj};
809 my $poly1305_obj = $target{poly1305_obj};
810 my $perlasm_scheme = $target{perlasm_scheme};
811 my $dso_scheme = $target{dso_scheme};
812 my $shared_target = $target{shared_target};
813 my $shared_cflag = $target{shared_cflag};
814 my $shared_ldflag = $target{shared_ldflag};
815 my $shared_extension = $target{shared_extension};
816 my $ranlib = $ENV{'RANLIB'} || $target{ranlib};
817 my $ar = $ENV{'AR'} || "ar";
818 my $arflags = $target{arflags};
819 my $multilib = $target{multilib};
821 ref($target{build_scheme}) eq "ARRAY"
822 ? @{$target{build_scheme}} : ( $target{build_scheme} );
824 # if $prefix/lib$multilib is not an existing directory, then
825 # assume that it's not searched by linker automatically, in
826 # which case adding $multilib suffix causes more grief than
827 # we're ready to tolerate, so don't...
828 $multilib="" if !-d "$prefix/lib$multilib";
830 $libdir="lib$multilib" if $libdir eq "";
832 $cflags = "$cflags$exp_cflags";
834 # '%' in $lflags is used to split flags to "pre-" and post-flags
835 my ($prelflags,$postlflags)=split('%',$lflags);
836 if (defined($postlflags)) { $lflags=$postlflags; }
837 else { $lflags=$prelflags; undef $prelflags; }
839 if ($target =~ /^mingw/ && `$cc --target-help 2>&1` !~ m/\-mno\-cygwin/m)
841 $cflags =~ s/\-mno\-cygwin\s*//;
842 $shared_ldflag =~ s/\-mno\-cygwin\s*//;
845 if ($target =~ /linux.*\-mips/ && !$no_asm && $flags !~ /\-m(ips|arch=)/) {
846 # minimally required architecture flags for assembly modules
847 $cflags="-mips2 $cflags" if ($target =~ /mips32/);
848 $cflags="-mips3 $cflags" if ($target =~ /mips64/);
851 my $no_shared_warn=0;
852 my $no_user_cflags=0;
854 if ($flags ne "") { $cflags="$flags$cflags"; }
855 else { $no_user_cflags=1; }
857 # The DSO code currently always implements all functions so that no
858 # applications will have to worry about that from a compilation point
859 # of view. However, the "method"s may return zero unless that platform
860 # has support compiled in for them. Currently each method is enabled
861 # by a define "DSO_<name>" ... we translate the "dso_scheme" config
862 # string entry into using the following logic;
864 if (!$no_dso && $dso_scheme ne "")
866 $dso_scheme =~ tr/[a-z]/[A-Z]/;
867 if ($dso_scheme eq "DLFCN")
869 $dso_cflags = "-DDSO_DLFCN -DHAVE_DLFCN_H";
871 elsif ($dso_scheme eq "DLFCN_NO_H")
873 $dso_cflags = "-DDSO_DLFCN";
877 $dso_cflags = "-DDSO_$dso_scheme";
879 $cflags = "$dso_cflags $cflags";
884 if ($thread_cflag ne "(unknown)" && !$no_threads)
886 # If we know how to do it, support threads by default.
889 if ($thread_cflag eq "(unknown)" && $threads)
891 # If the user asked for "threads", [s]he is also expected to
892 # provide any system-dependent compiler options that are
896 print "You asked for multi-threading support, but didn't\n";
897 print "provide any system-specific compiler options\n";
900 $thread_cflags="-DOPENSSL_THREADS $cflags" ;
901 $thread_defines .= "#define OPENSSL_THREADS\n";
905 $thread_cflags="-DOPENSSL_THREADS $thread_cflag $cflags";
906 $thread_defines .= "#define OPENSSL_THREADS\n";
908 # foreach $def (split ' ',$thread_cflag)
910 # if ($def =~ s/^-D// && $def !~ /^_/)
912 # $thread_defines .= "#define $def\n";
917 $lflags="$libs$lflags" if ($libs ne "");
921 $cflags=~s/\-D[BL]_ENDIAN// if ($fips);
922 $thread_cflags=~s/\-D[BL]_ENDIAN// if ($fips);
927 $cflags=$thread_cflags;
928 $openssl_thread_defines .= $thread_defines;
933 $cflags = "-DZLIB $cflags";
934 if (defined($disabled{"zlib-dynamic"}))
936 if (defined($withargs{"zlib-lib"}))
938 $lflags = "$lflags -L" . $withargs{"zlib-lib"} . " -lz";
942 $lflags = "$lflags -lz";
947 $cflags = "-DZLIB_SHARED $cflags";
951 # With "deprecated" disable all deprecated features.
952 if (defined($disabled{"deprecated"})) {
956 # You will find shlib_mark1 and shlib_mark2 explained in Makefile.in
957 my $shared_mark = "";
958 if ($shared_target eq "")
960 $no_shared_warn = 1 if !$no_shared && !$fips;
965 if ($shared_cflag ne "")
967 $cflags = "$shared_cflag -DOPENSSL_PIC $cflags";
971 if ($build_scheme[0] ne "mk1mf")
973 # add {no-}static-engine to options to allow mkdef.pl to work without extra arguments
976 $openssl_other_defines.="#define OPENSSL_NO_DYNAMIC_ENGINE\n";
977 $options.=" static-engine";
981 $openssl_other_defines.="#define OPENSSL_NO_STATIC_ENGINE\n";
982 $options.=" no-static-engine";
989 if ($target =~ /\-icc$/) # Intel C compiler
992 if (open(FD,"$cc -V 2>&1 |"))
994 while(<FD>) { $iccver=$1 if (/Version ([0-9]+)\./); }
999 $cflags=~s/\-KPIC/-fPIC/;
1000 # Eliminate unnecessary dependency from libirc.a. This is
1001 # essential for shared library support, as otherwise
1002 # apps/openssl can end up in endless loop upon startup...
1003 $cflags.=" -Dmemcpy=__builtin_memcpy -Dmemset=__builtin_memset";
1007 $lflags.=" -i-static";
1008 $lflags=~s/\-no_cpprt/-no-cpprt/;
1012 $lflags=~s/\-i\-static/-static-intel/;
1016 $cflags.=" -no-intel-extensions"; # disable Cilk
1017 $lflags=~s/\-no\-cpprt/-no-cxxlib/;
1021 # Unlike other OSes (like Solaris, Linux, Tru64, IRIX) BSD run-time
1022 # linkers (tested OpenBSD, NetBSD and FreeBSD) "demand" RPATH set on
1023 # .so objects. Apparently application RPATH is not global and does
1024 # not apply to .so linked with other .so. Problem manifests itself
1025 # when libssl.so fails to load libcrypto.so. One can argue that we
1026 # should engrave this into Makefile.shared rules or into BSD-* config
1027 # lines above. Meanwhile let's try to be cautious and pass -rpath to
1028 # linker only when --prefix is not /usr.
1029 if ($target =~ /^BSD\-/)
1031 $shared_ldflag.=" -Wl,-rpath,\$\$(LIBRPATH)" if ($prefix !~ m|^/usr[/]*$|);
1036 #$cflags="-DOPENSSL_SYS_$sys_id $cflags";
1037 $openssl_sys_defines="#define OPENSSL_SYS_$sys_id\n";
1042 $ranlib = $default_ranlib;
1046 $cpuid_obj=$table{BASE}->{cpuid_obj} if ($processor eq "386");
1047 $cpuid_obj.=" uplink.o uplink-x86.o" if ($cflags =~ /\-DOPENSSL_USE_APPLINK/);
1049 $bn_obj =~ s/\w+-gf2m.o// if (defined($disabled{ec2m}));
1051 # bn-586 is the only one implementing bn_*_part_words
1052 $cflags.=" -DOPENSSL_BN_ASM_PART_WORDS" if ($bn_obj =~ /bn-586/);
1053 $cflags.=" -DOPENSSL_IA32_SSE2" if (!$no_sse2 && $bn_obj =~ /86/);
1055 $cflags.=" -DOPENSSL_BN_ASM_MONT" if ($bn_obj =~ /-mont/);
1056 $cflags.=" -DOPENSSL_BN_ASM_MONT5" if ($bn_obj =~ /-mont5/);
1057 $cflags.=" -DOPENSSL_BN_ASM_GF2m" if ($bn_obj =~ /-gf2m/);
1060 $openssl_other_defines.="#define OPENSSL_FIPS\n";
1063 if ($sha1_obj =~ /\.o$/) {
1064 $cflags.=" -DSHA1_ASM" if ($sha1_obj =~ /sx86/ || $sha1_obj =~ /sha1/);
1065 $cflags.=" -DSHA256_ASM" if ($sha1_obj =~ /sha256/);
1066 $cflags.=" -DSHA512_ASM" if ($sha1_obj =~ /sha512/);
1067 if ($sha1_obj =~ /sse2/) {
1069 $sha1_obj =~ s/\S*sse2\S+//;
1070 } elsif ($cflags !~ /OPENSSL_IA32_SSE2/) {
1071 $cflags.=" -DOPENSSL_IA32_SSE2";
1075 if ($md5_obj =~ /\.o$/) {
1076 $cflags.=" -DMD5_ASM";
1078 $cast_obj=$table{BASE}->{cast_obj} if (!$no_shared); # CAST assembler is not PIC
1079 if ($rmd160_obj =~ /\.o$/) {
1080 $cflags.=" -DRMD160_ASM";
1082 if ($aes_obj =~ /\.o$/) {
1083 $cflags.=" -DAES_ASM" if ($aes_obj =~ m/\baes\-/);;
1084 # aes-ctr.o is not a real file, only indication that assembler
1085 # module implements AES_ctr32_encrypt...
1086 $cflags.=" -DAES_CTR_ASM" if ($aes_obj =~ s/\s*aes\-ctr\.o//);
1087 # aes-xts.o indicates presence of AES_xts_[en|de]crypt...
1088 $cflags.=" -DAES_XTS_ASM" if ($aes_obj =~ s/\s*aes\-xts\.o//);
1089 $aes_obj =~ s/\s*(vpaes|aesni)\-x86\.o//g if ($no_sse2);
1090 $cflags.=" -DVPAES_ASM" if ($aes_obj =~ m/vpaes/);
1091 $cflags.=" -DBSAES_ASM" if ($aes_obj =~ m/bsaes/);
1093 if ($wp_obj =~ /mmx/ && $processor eq "386") {
1094 $wp_obj=$table{BASE}->{wp_obj};
1095 } elsif (!$disabled{"whirlpool"}) {
1096 $cflags.=" -DWHIRLPOOL_ASM";
1098 if ($modes_obj =~ /ghash\-/) {
1099 $cflags.=" -DGHASH_ASM";
1101 if ($ec_obj =~ /ecp_nistz256/) {
1102 $cflags.=" -DECP_NISTZ256_ASM";
1104 if ($poly1305_obj =~ /\.o$/) {
1105 $cflags.=" -DPOLY1305_ASM";
1109 # "Stringify" the C flags string. This permits it to be made part of a string
1110 # and works as well on command lines.
1111 $cflags =~ s/([\\\"])/\\\1/g;
1113 my $version = "unknown";
1114 my $version_num = "unknown";
1115 my $major = "unknown";
1116 my $minor = "unknown";
1117 my $shlib_version_number = "unknown";
1118 my $shlib_version_history = "unknown";
1119 my $shlib_major = "unknown";
1120 my $shlib_minor = "unknown";
1122 open(IN,'<include/openssl/opensslv.h') || die "unable to read opensslv.h:$!\n";
1125 $version=$1 if /OPENSSL.VERSION.TEXT.*OpenSSL (\S+) /;
1126 $version_num=$1 if /OPENSSL.VERSION.NUMBER.*(0x\S+)/;
1127 $shlib_version_number=$1 if /SHLIB_VERSION_NUMBER *"([^"]+)"/;
1128 $shlib_version_history=$1 if /SHLIB_VERSION_HISTORY *"([^"]*)"/;
1131 if ($shlib_version_history ne "") { $shlib_version_history .= ":"; }
1133 if ($version =~ /(^[0-9]*)\.([0-9\.]*)/)
1139 if ($shlib_version_number =~ /(^[0-9]*)\.([0-9\.]*)/)
1145 if (defined($api)) {
1146 my $apiflag = sprintf("-DOPENSSL_API_COMPAT=%s", $apitable->{$api});
1147 $default_depflags .= " $apiflag";
1148 $cflags .= " $apiflag";
1152 $ecc = "clang" if `$cc --version 2>&1` =~ /clang/;
1154 if ($strict_warnings)
1157 die "ERROR --strict-warnings requires gcc or clang" unless ($ecc =~ /gcc(-\d(\.\d)*)?$/ or $ecc =~ /clang$/);
1158 foreach $wopt (split /\s+/, $gcc_devteam_warn)
1160 $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/)
1162 if ($ecc eq "clang")
1164 foreach $wopt (split /\s+/, $clang_devteam_warn)
1166 $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/)
1169 if ($target !~ /^mingw/)
1171 foreach $wopt (split /\s+/, $memleak_devteam_backtrace)
1173 $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/)
1175 if ($target =~ /^BSD-/)
1177 $lflags .= " -lexecinfo";
1182 open(IN,"<Makefile.in") || die "unable to read Makefile.in$!\n";
1183 unlink("$Makefile.new") || die "unable to remove old $Makefile.new:$!\n" if -e "$Makefile.new";
1184 open(OUT,">$Makefile.new") || die "unable to create $Makefile.new:$!\n";
1185 print OUT "### Generated automatically from Makefile.in by Configure.\n\n";
1191 $sdirs = 1 if /^SDIRS=/;
1194 foreach $dir (@skip) {
1199 $sdirs = 0 unless /\\$/;
1200 s/fips // if (/^DIRS=/ && !$fips);
1201 s/engines // if (/^DIRS=/ && $disabled{"engine"});
1202 s/^VERSION=.*/VERSION=$version/;
1203 s/^MAJOR=.*/MAJOR=$major/;
1204 s/^MINOR=.*/MINOR=$minor/;
1205 s/^SHLIB_VERSION_NUMBER=.*/SHLIB_VERSION_NUMBER=$shlib_version_number/;
1206 s/^SHLIB_VERSION_HISTORY=.*/SHLIB_VERSION_HISTORY=$shlib_version_history/;
1207 s/^SHLIB_MAJOR=.*/SHLIB_MAJOR=$shlib_major/;
1208 s/^SHLIB_MINOR=.*/SHLIB_MINOR=$shlib_minor/;
1209 s/^SHLIB_EXT=.*/SHLIB_EXT=$shared_extension/;
1210 s/^INSTALLTOP=.*$/INSTALLTOP=$prefix/;
1211 s/^MULTILIB=.*$/MULTILIB=$multilib/;
1212 s/^OPENSSLDIR=.*$/OPENSSLDIR=$openssldir/;
1213 s/^LIBDIR=.*$/LIBDIR=$libdir/;
1214 s/^INSTALL_PREFIX=.*$/INSTALL_PREFIX=$install_prefix/;
1215 s/^PLATFORM=.*$/PLATFORM=$target/;
1216 s/^OPTIONS=.*$/OPTIONS=$options/;
1217 my $argvstring = "(".join(", ", map { quotify("perl", $_) } @argvcopy).")";
1218 s/^CONFIGURE_ARGS=.*$/CONFIGURE_ARGS=$argvstring/;
1219 if ($cross_compile_prefix)
1221 s/^CC=.*$/CROSS_COMPILE= $cross_compile_prefix\nCC= \$\(CROSS_COMPILE\)$cc/;
1222 s/^AR=\s*/AR= \$\(CROSS_COMPILE\)/;
1223 s/^NM=\s*/NM= \$\(CROSS_COMPILE\)/;
1224 s/^RANLIB=\s*/RANLIB= \$\(CROSS_COMPILE\)/;
1225 s/^MAKEDEPPROG=.*$/MAKEDEPPROG= \$\(CROSS_COMPILE\)$cc/ if $cc eq "gcc";
1229 s/^AR=\s*ar/AR= $ar/;
1230 s/^RANLIB=.*/RANLIB= $ranlib/;
1231 s/^MAKEDEPPROG=.*$/MAKEDEPPROG= $cc/ if $ecc eq "gcc" || $ecc eq "clang";
1233 s/^CFLAG=.*$/CFLAG= $cflags/;
1234 s/^DEPFLAG=.*$/DEPFLAG=$depflags/;
1235 s/^PEX_LIBS=.*$/PEX_LIBS= $prelflags/;
1236 s/^EX_LIBS=.*$/EX_LIBS= $lflags/;
1237 s/^EXE_EXT=.*$/EXE_EXT= $exe_ext/;
1238 s/^CPUID_OBJ=.*$/CPUID_OBJ= $cpuid_obj/;
1239 s/^BN_ASM=.*$/BN_ASM= $bn_obj/;
1240 s/^EC_ASM=.*$/EC_ASM= $ec_obj/;
1241 s/^DES_ENC=.*$/DES_ENC= $des_obj/;
1242 s/^AES_ENC=.*$/AES_ENC= $aes_obj/;
1243 s/^BF_ENC=.*$/BF_ENC= $bf_obj/;
1244 s/^CAST_ENC=.*$/CAST_ENC= $cast_obj/;
1245 s/^RC4_ENC=.*$/RC4_ENC= $rc4_obj/;
1246 s/^RC5_ENC=.*$/RC5_ENC= $rc5_obj/;
1247 s/^MD5_ASM_OBJ=.*$/MD5_ASM_OBJ= $md5_obj/;
1248 s/^SHA1_ASM_OBJ=.*$/SHA1_ASM_OBJ= $sha1_obj/;
1249 s/^RMD160_ASM_OBJ=.*$/RMD160_ASM_OBJ= $rmd160_obj/;
1250 s/^WP_ASM_OBJ=.*$/WP_ASM_OBJ= $wp_obj/;
1251 s/^CMLL_ENC=.*$/CMLL_ENC= $cmll_obj/;
1252 s/^MODES_ASM_OBJ.=*$/MODES_ASM_OBJ= $modes_obj/;
1253 s/^CHACHA_ENC=.*$/CHACHA_ENC= $chacha_obj/;
1254 s/^POLY1305_ASM_OBJ=.*$/POLY1305_ASM_OBJ= $poly1305_obj/;
1255 s/^ENGINES_ASM_OBJ.=*$/ENGINES_ASM_OBJ= $engines_obj/;
1256 s/^PERLASM_SCHEME=.*$/PERLASM_SCHEME= $perlasm_scheme/;
1257 s/^PROCESSOR=.*/PROCESSOR= $processor/;
1258 s/^ARFLAGS=.*/ARFLAGS= $arflags/;
1259 s/^PERL=.*/PERL= $perl/;
1260 s/^LIBZLIB=.*/LIBZLIB=$withargs{"zlib-lib"}/;
1261 s/^ZLIB_INCLUDE=.*/ZLIB_INCLUDE=$withargs{"zlib-include"}/;
1262 s/^FIPSLIBDIR=.*/FIPSLIBDIR=$fipslibdir/;
1263 s/^FIPSCANLIB=.*/FIPSCANLIB=libcrypto/ if $fips;
1264 s/^SHARED_FIPS=.*/SHARED_FIPS=/;
1265 s/^SHLIBDIRS=.*/SHLIBDIRS= crypto ssl/;
1266 s/^BASEADDR=.*/BASEADDR=$baseaddr/;
1267 s/^SHLIB_TARGET=.*/SHLIB_TARGET=$shared_target/;
1268 s/^SHLIB_MARK=.*/SHLIB_MARK=$shared_mark/;
1269 s/^SHARED_LIBS=.*/SHARED_LIBS=\$(SHARED_CRYPTO) \$(SHARED_SSL)/ if (!$no_shared);
1270 if ($shared_extension ne "" && $shared_extension =~ /^\.s([ol])\.[^\.]*$/)
1273 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.s$sotmp/;
1275 elsif ($shared_extension ne "" && $shared_extension =~ /^\.[^\.]*\.dylib$/)
1277 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.dylib/;
1279 elsif ($shared_extension ne "" && $shared_extension =~ /^\.s([ol])\.[^\.]*\.[^\.]*$/)
1282 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.s$sotmp.\$(SHLIB_MAJOR) .s$sotmp/;
1284 elsif ($shared_extension ne "" && $shared_extension =~ /^\.[^\.]*\.[^\.]*\.dylib$/)
1286 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.\$(SHLIB_MAJOR).dylib .dylib/;
1288 s/^SHARED_LDFLAGS=.*/SHARED_LDFLAGS=$shared_ldflag/;
1293 rename($Makefile,"$Makefile.orig") || die "unable to rename $Makefile\n" if -e $Makefile;
1294 rename("$Makefile.new",$Makefile) || die "unable to rename $Makefile.new\n";
1296 print "IsMK1MF =", ($build_scheme[0] eq "mk1mf" ? "yes" : "no"), "\n";
1298 print "CFLAG =$cflags\n";
1299 print "EX_LIBS =$lflags\n";
1300 print "CPUID_OBJ =$cpuid_obj\n";
1301 print "BN_ASM =$bn_obj\n";
1302 print "EC_ASM =$ec_obj\n";
1303 print "DES_ENC =$des_obj\n";
1304 print "AES_ENC =$aes_obj\n";
1305 print "BF_ENC =$bf_obj\n";
1306 print "CAST_ENC =$cast_obj\n";
1307 print "RC4_ENC =$rc4_obj\n";
1308 print "RC5_ENC =$rc5_obj\n";
1309 print "MD5_OBJ_ASM =$md5_obj\n";
1310 print "SHA1_OBJ_ASM =$sha1_obj\n";
1311 print "RMD160_OBJ_ASM=$rmd160_obj\n";
1312 print "CMLL_ENC =$cmll_obj\n";
1313 print "MODES_OBJ =$modes_obj\n";
1314 print "ENGINES_OBJ =$engines_obj\n";
1315 print "CHACHA_ENC =$chacha_obj\n";
1316 print "POLY1305_OBJ =$poly1305_obj\n";
1317 print "PROCESSOR =$processor\n";
1318 print "RANLIB =$ranlib\n";
1319 print "ARFLAGS =$arflags\n";
1320 print "PERL =$perl\n";
1328 my $rc4_int=$def_int;
1329 my $md2_int=$def_int;
1330 my $idea_int=$def_int;
1331 my $rc2_int=$def_int;
1335 my @type=("char","short","int","long");
1336 my ($b64l,$b64,$b32,$b16,$b8)=(0,0,1,0,0);
1337 my $export_var_as_fn=0;
1341 foreach (sort split(/\s+/,$bn_ops))
1343 $des_ptr=1 if /DES_PTR/;
1344 $des_risc1=1 if /DES_RISC1/;
1345 $des_risc2=1 if /DES_RISC2/;
1346 $des_unroll=1 if /DES_UNROLL/;
1347 $des_int=1 if /DES_INT/;
1348 $bn_ll=1 if /BN_LLONG/;
1349 $rc4_int=0 if /RC4_CHAR/;
1350 $rc4_int=3 if /RC4_LONG/;
1351 $rc4_idx=1 if /RC4_INDEX/;
1352 $rc4_chunk=1 if /RC4_CHUNK/;
1353 $rc4_chunk=2 if /RC4_CHUNK_LL/;
1354 $md2_int=0 if /MD2_CHAR/;
1355 $md2_int=3 if /MD2_LONG/;
1356 $idea_int=1 if /IDEA_SHORT/;
1357 $idea_int=3 if /IDEA_LONG/;
1358 $rc2_int=1 if /RC2_SHORT/;
1359 $rc2_int=3 if /RC2_LONG/;
1360 $bf_ptr=1 if $_ eq "BF_PTR";
1361 $bf_ptr=2 if $_ eq "BF_PTR2";
1362 ($b64l,$b64,$b32,$b16,$b8)=(0,1,0,0,0) if /SIXTY_FOUR_BIT/;
1363 ($b64l,$b64,$b32,$b16,$b8)=(1,0,0,0,0) if /SIXTY_FOUR_BIT_LONG/;
1364 ($b64l,$b64,$b32,$b16,$b8)=(0,0,1,0,0) if /THIRTY_TWO_BIT/;
1365 ($b64l,$b64,$b32,$b16,$b8)=(0,0,0,1,0) if /SIXTEEN_BIT/;
1366 ($b64l,$b64,$b32,$b16,$b8)=(0,0,0,0,1) if /EIGHT_BIT/;
1367 $export_var_as_fn=1 if /EXPORT_VAR_AS_FN/;
1370 open(IN,'<crypto/opensslconf.h.in') || die "unable to read crypto/opensslconf.h.in:$!\n";
1371 unlink("include/openssl/opensslconf.h.new") || die "unable to remove old include/openssl/opensslconf.h.new:$!\n" if -e "include/openssl/opensslconf.h.new";
1372 open(OUT,'>include/openssl/opensslconf.h.new') || die "unable to create include/openssl/opensslconf.h.new:$!\n";
1373 print OUT "/* opensslconf.h */\n";
1374 print OUT "/* WARNING: Generated automatically from opensslconf.h.in by Configure. */\n\n";
1376 print OUT "#ifdef __cplusplus\n";
1377 print OUT "extern \"C\" {\n";
1378 print OUT "#endif\n";
1379 print OUT "/* OpenSSL was configured with the following options: */\n";
1381 my $openssl_api_defines = "";
1382 if (defined($api)) {
1383 $openssl_api_defines = sprintf "#define OPENSSL_MIN_API %s\n", $apitable->{$api};
1385 my $openssl_algorithm_defines_trans = $openssl_algorithm_defines;
1386 $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;
1387 $openssl_algorithm_defines_trans =~ s/^\s*#\s*define\s+OPENSSL_(.*)/# if defined(OPENSSL_$1) \&\& !defined($1)\n# define $1\n# endif/mg;
1388 $openssl_algorithm_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1389 $openssl_algorithm_defines = " /* no ciphers excluded */\n" if $openssl_algorithm_defines eq "";
1390 $openssl_thread_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1391 $openssl_sys_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1392 $openssl_other_defines =~ s/^\s*#\s*define\s+(.*)/#ifndef $1\n# define $1\n#endif/mg;
1394 print OUT $openssl_sys_defines;
1395 print OUT "#ifndef OPENSSL_DOING_MAKEDEPEND\n\n";
1396 print OUT $openssl_experimental_defines;
1397 print OUT $openssl_api_defines;
1399 print OUT $openssl_algorithm_defines;
1400 print OUT "\n#endif /* OPENSSL_DOING_MAKEDEPEND */\n\n";
1401 print OUT $openssl_thread_defines;
1402 print OUT $openssl_other_defines,"\n";
1404 print OUT "/* The OPENSSL_NO_* macros are also defined as NO_* if the application\n";
1405 print OUT " asks for it. This is a transient feature that is provided for those\n";
1406 print OUT " who haven't had the time to do the appropriate changes in their\n";
1407 print OUT " applications. */\n";
1408 print OUT "#ifdef OPENSSL_ALGORITHM_DEFINES\n";
1409 print OUT $openssl_algorithm_defines_trans;
1410 print OUT "#endif\n\n";
1412 print OUT "#define OPENSSL_CPUID_OBJ\n\n" if ($cpuid_obj ne "mem_clr.o");
1416 if (/^#define\s+OPENSSLDIR/)
1418 my $foo = $openssldir;
1419 $foo =~ s/\\/\\\\/g;
1420 print OUT "#define OPENSSLDIR \"$foo\"\n";
1422 elsif (/^#define\s+ENGINESDIR/)
1424 my $foo = "$prefix/$libdir/engines";
1425 $foo =~ s/\\/\\\\/g;
1426 print OUT "#define ENGINESDIR \"$foo\"\n";
1428 elsif (/^#((define)|(undef))\s+OPENSSL_EXPORT_VAR_AS_FUNCTION/)
1429 { printf OUT "#undef OPENSSL_EXPORT_VAR_AS_FUNCTION\n"
1430 if $export_var_as_fn;
1431 printf OUT "#%s OPENSSL_EXPORT_VAR_AS_FUNCTION\n",
1432 ($export_var_as_fn)?"define":"undef"; }
1433 elsif (/^#define\s+OPENSSL_UNISTD/)
1435 print OUT "#define OPENSSL_UNISTD $unistd\n";
1437 elsif (/^#((define)|(undef))\s+SIXTY_FOUR_BIT_LONG/)
1438 { printf OUT "#%s SIXTY_FOUR_BIT_LONG\n",($b64l)?"define":"undef"; }
1439 elsif (/^#((define)|(undef))\s+SIXTY_FOUR_BIT/)
1440 { printf OUT "#%s SIXTY_FOUR_BIT\n",($b64)?"define":"undef"; }
1441 elsif (/^#((define)|(undef))\s+THIRTY_TWO_BIT/)
1442 { printf OUT "#%s THIRTY_TWO_BIT\n",($b32)?"define":"undef"; }
1443 elsif (/^#((define)|(undef))\s+SIXTEEN_BIT/)
1444 { printf OUT "#%s SIXTEEN_BIT\n",($b16)?"define":"undef"; }
1445 elsif (/^#((define)|(undef))\s+EIGHT_BIT/)
1446 { printf OUT "#%s EIGHT_BIT\n",($b8)?"define":"undef"; }
1447 elsif (/^#((define)|(undef))\s+BN_LLONG\s*$/)
1448 { printf OUT "#%s BN_LLONG\n",($bn_ll)?"define":"undef"; }
1449 elsif (/^\#define\s+OSSL_DES_LONG\s+.*/)
1450 { printf OUT "#define OSSL_DES_LONG unsigned %s\n",
1451 ($des_int)?'int':'long'; }
1452 elsif (/^\#(define|undef)\s+DES_PTR/)
1453 { printf OUT "#%s DES_PTR\n",($des_ptr)?'define':'undef'; }
1454 elsif (/^\#(define|undef)\s+DES_RISC1/)
1455 { printf OUT "#%s DES_RISC1\n",($des_risc1)?'define':'undef'; }
1456 elsif (/^\#(define|undef)\s+DES_RISC2/)
1457 { printf OUT "#%s DES_RISC2\n",($des_risc2)?'define':'undef'; }
1458 elsif (/^\#(define|undef)\s+DES_UNROLL/)
1459 { printf OUT "#%s DES_UNROLL\n",($des_unroll)?'define':'undef'; }
1460 elsif (/^#define\s+RC4_INT\s/)
1461 { printf OUT "#define RC4_INT unsigned %s\n",$type[$rc4_int]; }
1462 elsif (/^#undef\s+RC4_CHUNK/)
1464 printf OUT "#undef RC4_CHUNK\n" if $rc4_chunk==0;
1465 printf OUT "#define RC4_CHUNK unsigned long\n" if $rc4_chunk==1;
1466 printf OUT "#define RC4_CHUNK unsigned long long\n" if $rc4_chunk==2;
1468 elsif (/^#((define)|(undef))\s+RC4_INDEX/)
1469 { printf OUT "#%s RC4_INDEX\n",($rc4_idx)?"define":"undef"; }
1470 elsif (/^#(define|undef)\s+I386_ONLY/)
1471 { printf OUT "#%s I386_ONLY\n", ($processor eq "386")?
1473 elsif (/^#define\s+MD2_INT\s/)
1474 { printf OUT "#define MD2_INT unsigned %s\n",$type[$md2_int]; }
1475 elsif (/^#define\s+IDEA_INT\s/)
1476 {printf OUT "#define IDEA_INT unsigned %s\n",$type[$idea_int];}
1477 elsif (/^#define\s+RC2_INT\s/)
1478 {printf OUT "#define RC2_INT unsigned %s\n",$type[$rc2_int];}
1479 elsif (/^#(define|undef)\s+BF_PTR/)
1481 printf OUT "#undef BF_PTR\n" if $bf_ptr == 0;
1482 printf OUT "#define BF_PTR\n" if $bf_ptr == 1;
1483 printf OUT "#define BF_PTR2\n" if $bf_ptr == 2;
1489 print OUT "#ifdef __cplusplus\n";
1491 print OUT "#endif\n";
1493 rename("include/openssl/opensslconf.h","include/openssl/opensslconf.h.bak") || die "unable to rename include/openssl/opensslconf.h\n" if -e "include/openssl/opensslconf.h";
1494 rename("include/openssl/opensslconf.h.new","include/openssl/opensslconf.h") || die "unable to rename include/openssl/opensslconf.h.new\n";
1499 print "SIXTY_FOUR_BIT_LONG mode\n" if $b64l;
1500 print "SIXTY_FOUR_BIT mode\n" if $b64;
1501 print "THIRTY_TWO_BIT mode\n" if $b32;
1502 print "SIXTEEN_BIT mode\n" if $b16;
1503 print "EIGHT_BIT mode\n" if $b8;
1504 print "DES_PTR used\n" if $des_ptr;
1505 print "DES_RISC1 used\n" if $des_risc1;
1506 print "DES_RISC2 used\n" if $des_risc2;
1507 print "DES_UNROLL used\n" if $des_unroll;
1508 print "DES_INT used\n" if $des_int;
1509 print "BN_LLONG mode\n" if $bn_ll;
1510 print "RC4 uses u$type[$rc4_int]\n" if $rc4_int != $def_int;
1511 print "RC4_INDEX mode\n" if $rc4_idx;
1512 print "RC4_CHUNK is undefined\n" if $rc4_chunk==0;
1513 print "RC4_CHUNK is unsigned long\n" if $rc4_chunk==1;
1514 print "RC4_CHUNK is unsigned long long\n" if $rc4_chunk==2;
1515 print "MD2 uses u$type[$md2_int]\n" if $md2_int != $def_int;
1516 print "IDEA uses u$type[$idea_int]\n" if $idea_int != $def_int;
1517 print "RC2 uses u$type[$rc2_int]\n" if $rc2_int != $def_int;
1518 print "BF_PTR used\n" if $bf_ptr == 1;
1519 print "BF_PTR2 used\n" if $bf_ptr == 2;
1521 # Copy all Makefile.in to Makefile (except top-level)
1525 return if ($_ ne "Makefile.in" || $File::Find::dir eq ".");
1526 my $in = IO::File->new($_, "r") or
1527 die sprintf "Error reading Makefile.in in %s: !$\n",
1529 my $out = IO::File->new("Makefile", "w") or
1530 die sprintf "Error writing Makefile in %s: !$\n",
1532 print $out "# Generated from $_, do not edit\n";
1533 while (my $line = <$in>) { print $out $line }
1535 die sprintf "Error reading Makefile.in in %s: !$\n",
1538 die sprintf "Error writing Makefile in %s: !$\n",
1544 my $perlguess = $perl =~ m@^/@ ? $perl : '/usr/local/bin/perl';
1545 my $make_command = "$make PERL=\'$perlguess\'";
1546 my $make_targets = "";
1547 $make_targets .= " depend" if $depflags ne $default_depflags && $make_depend;
1548 (system $make_command.$make_targets) == 0 or die "make $make_targets failed"
1549 if $make_targets ne "";
1550 &dofile("tools/c_rehash",$perlguess,
1552 '^my \$dir;$' => 'my $dir = "' . $openssldir . '";',
1553 '^my \$prefix;$' => 'my $prefix = "' . $prefix . '";');
1554 &dofile("apps/CA.pl",$perlguess,
1556 if ($depflags ne $default_depflags && !$make_depend) {
1557 $warn_make_depend++;
1561 open (OUT,">crypto/buildinf.h") || die "Can't open buildinf.h";
1564 /* auto-generated by Configure for crypto/cversion.c:
1565 * for Unix builds, crypto/Makefile.ssl generates functional definitions;
1566 * Windows builds (and other mk1mf builds) compile cversion.c with
1567 * -DMK1MF_BUILD and use definitions added to this file by util/mk1mf.pl. */
1568 #error "Windows builds (PLATFORM=$target) use mk1mf.pl-created Makefiles"
1573 # create the ms/version32.rc file if needed
1574 if (! grep /^netware/, @build_scheme) {
1575 my ($v1, $v2, $v3, $v4);
1576 if ($version_num =~ /^0x([0-9a-f]{1})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{1})L$/i) {
1582 open (OUT,">ms/version32.rc") || die "Can't open ms/version32.rc";
1589 FILEVERSION $v1,$v2,$v3,$v4
1590 PRODUCTVERSION $v1,$v2,$v3,$v4
1597 FILEOS VOS__WINDOWS32
1601 BLOCK "StringFileInfo"
1606 VALUE "CompanyName", "The OpenSSL Project, http://www.openssl.org/\\0"
1607 VALUE "FileDescription", "OpenSSL Shared Library\\0"
1608 VALUE "FileVersion", "$version\\0"
1610 VALUE "InternalName", "libeay32\\0"
1611 VALUE "OriginalFilename", "libeay32.dll\\0"
1613 VALUE "InternalName", "ssleay32\\0"
1614 VALUE "OriginalFilename", "ssleay32.dll\\0"
1616 VALUE "ProductName", "The OpenSSL Toolkit\\0"
1617 VALUE "ProductVersion", "$version\\0"
1619 //VALUE "Comments", "\\0"
1620 VALUE "LegalCopyright", "Copyright © 1998-2015 The OpenSSL Project. Copyright © 1995-1998 Eric A. Young, Tim J. Hudson. All rights reserved.\\0"
1621 //VALUE "LegalTrademarks", "\\0"
1622 //VALUE "PrivateBuild", "\\0"
1623 //VALUE "SpecialBuild", "\\0"
1628 VALUE "Translation", 0x409, 0x4b0
1637 my ($builder, @builder_opts) = @build_scheme;
1638 $builders{$builder}->(@builder_opts);
1642 Configured for $target.
1645 print <<"EOF" if (!$no_threads && !$threads);
1647 The library could not be configured for supporting multi-threaded
1648 applications as the compiler options required on this system are not known.
1649 See file INSTALL for details if you need multi-threading.
1652 print <<"EOF" if ($no_shared_warn);
1654 You gave the option 'shared', which is not supported on this platform, so
1655 we will pretend you gave the option 'no-shared'. If you know how to implement
1656 shared libraries, please let us know (but please first make sure you have
1657 tried with a current version of OpenSSL).
1660 print <<"EOF" if ($warn_make_depend);
1662 *** Because of configuration changes, you MUST do the following before
1670 ######################################################################
1672 # Helpers and utility functions
1675 # Configuration file reading #########################################
1677 # Helper function to implement conditional inheritance depending on the
1678 # value of $no_asm. Used in inherit_from values as follows:
1680 # inherit_from => [ "template", asm("asm_tmpl") ]
1689 # Helper function to implement adding values to already existing configuration
1690 # values. It handles elements that are ARRAYs, CODEs and scalars
1692 my $separator = shift;
1694 # If there's any ARRAY in the collection of values, we will return
1695 # an ARRAY of combined values, otherwise a string of joined values
1696 # with $separator as the separator.
1697 my $found_array = 0;
1701 if (ref($_) eq "ARRAY") {
1712 join($separator, @values);
1716 my $separator = shift;
1718 sub { _add($separator, @x, @_) };
1721 my $separator = shift;
1723 sub { _add($separator, @_, @x) };
1726 # configuration reader, evaluates the input file as a perl script and expects
1727 # it to fill %targets with target configurations. Those are then added to
1731 open(CONFFILE, "< $fname")
1732 or die "Can't open configuration file '$fname'!\n";
1735 my $content = <CONFFILE>;
1740 local %table = %::table; # Protect %table from tampering
1746 # For each target, check that it's configured with a hash table.
1747 foreach (keys %targets) {
1748 if (ref($targets{$_}) ne "HASH") {
1749 if (ref($targets{$_}) eq "") {
1750 warn "Deprecated target configuration for $_, ignoring...\n";
1752 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
1754 delete $targets{$_};
1758 %table = (%table, %targets);
1762 # configuration resolver. Will only resolve all the lazy evalutation
1763 # codeblocks for the chozen target and all those it inherits from,
1765 sub resolve_config {
1767 my @breadcrumbs = @_;
1769 if (grep { $_ eq $target } @breadcrumbs) {
1770 die "inherit_from loop! target backtrace:\n "
1771 ,$target,"\n ",join("\n ", @breadcrumbs),"\n";
1774 if (!defined($table{$target})) {
1775 warn "Warning! target $target doesn't exist!\n";
1778 # Recurse through all inheritances. They will be resolved on the
1779 # fly, so when this operation is done, they will all just be a
1780 # bunch of attributes with string values.
1781 # What we get here, though, are keys with references to lists of
1782 # the combined values of them all. We will deal with lists after
1783 # this stage is done.
1784 my %combined_inheritance = ();
1785 if ($table{$target}->{inherit_from}) {
1787 map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
1788 foreach (@inherit_from) {
1789 my %inherited_config = resolve_config($_, $target, @breadcrumbs);
1791 # 'template' is a marker that's considered private to
1792 # the config that had it.
1793 delete $inherited_config{template};
1796 if (!$combined_inheritance{$_}) {
1797 $combined_inheritance{$_} = [];
1799 push @{$combined_inheritance{$_}}, $inherited_config{$_};
1800 } keys %inherited_config;
1804 # We won't need inherit_from in this target any more, since we've
1805 # resolved all the inheritances that lead to this
1806 delete $table{$target}->{inherit_from};
1808 # Now is the time to deal with those lists. Here's the place to
1809 # decide what shall be done with those lists, all based on the
1810 # values of the target we're currently dealing with.
1811 # - If a value is a coderef, it will be executed with the list of
1812 # inherited values as arguments.
1813 # - If the corresponding key doesn't have a value at all or is the
1814 # emoty string, the inherited value list will be run through the
1815 # default combiner (below), and the result becomes this target's
1817 # - Otherwise, this target's value is assumed to be a string that
1818 # will simply override the inherited list of values.
1819 my $default_combiner = add(" ");
1822 map { $_ => 1 } (keys %combined_inheritance,
1823 keys %{$table{$target}});
1824 foreach (sort keys %all_keys) {
1826 # Current target doesn't have a value for the current key?
1827 # Assign it the default combiner, the rest of this loop body
1828 # will handle it just like any other coderef.
1829 if (!exists $table{$target}->{$_}) {
1830 $table{$target}->{$_} = $default_combiner;
1833 my $valuetype = ref($table{$target}->{$_});
1834 if ($valuetype eq "CODE") {
1835 # CODE reference, execute it with the inherited values as
1837 $table{$target}->{$_} =
1838 $table{$target}->{$_}->(@{$combined_inheritance{$_}});
1839 } elsif ($valuetype eq "ARRAY" || $valuetype eq "") {
1840 # ARRAY or Scalar, just leave it as is.
1842 # Some other type of reference that we don't handle.
1843 # Better to abort at this point.
1844 die "cannot handle reference type $valuetype,"
1845 ," found in target $target -> $_\n";
1849 # Finally done, return the result.
1850 return %{$table{$target}};
1855 print STDERR $usage;
1856 print STDERR "\npick os/compiler from:\n";
1860 foreach $i (sort keys %table)
1862 next if $table{$i}->{template};
1863 next if $i =~ /^debug/;
1864 $k += length($i) + 1;
1870 print STDERR $i . " ";
1872 foreach $i (sort keys %table)
1874 next if $table{$i}->{template};
1875 next if $i !~ /^debug/;
1876 $k += length($i) + 1;
1882 print STDERR $i . " ";
1884 print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
1892 foreach $path (split /:/, $ENV{PATH})
1894 if (-f "$path/$name$exe_ext" and -x _)
1896 return "$path/$name$exe_ext" unless ($name eq "perl" and
1897 system("$path/$name$exe_ext -e " . '\'exit($]<5.0);\''));
1904 my $f; my $p; my %m; my @a; my $k; my $ff;
1907 open(IN,"<$f.in") || open(IN,"<$f") || die "unable to open $f:$!\n";
1910 foreach $k (keys %m)
1912 grep(/$k/ && ($_=sprintf($m{$k}."\n",$p)),@a);
1914 open(OUT,">$f.new") || die "unable to open $f.new:$!\n";
1917 rename($f,"$f.bak") || die "unable to rename $f\n" if -e $f;
1918 rename("$f.new",$f) || die "unable to rename $f.new\n";
1921 sub print_table_entry
1924 my %target = resolve_config($target);
1927 # Don't print the templates
1928 return if $target{template};
1930 if ($type eq "TABLE") {
1935 \$cflags = $target{cflags}
1936 \$debug_cflags = $target{debug_cflags}
1937 \$release_cflags = $target{release_cflags}
1938 \$unistd = $target{unistd}
1939 \$thread_cflag = $target{thread_cflag}
1940 \$sys_id = $target{sys_id}
1941 \$lflags = $target{lflags}
1942 \$debug_lflags = $target{debug_lflags}
1943 \$release_lflags = $target{release_lflags}
1944 \$bn_ops = $target{bn_ops}
1945 \$cpuid_obj = $target{cpuid_obj}
1946 \$bn_obj = $target{bn_obj}
1947 \$ec_obj = $target{ec_obj}
1948 \$des_obj = $target{des_obj}
1949 \$aes_obj = $target{aes_obj}
1950 \$bf_obj = $target{bf_obj}
1951 \$md5_obj = $target{md5_obj}
1952 \$sha1_obj = $target{sha1_obj}
1953 \$cast_obj = $target{cast_obj}
1954 \$rc4_obj = $target{rc4_obj}
1955 \$rmd160_obj = $target{rmd160_obj}
1956 \$rc5_obj = $target{rc5_obj}
1957 \$wp_obj = $target{wp_obj}
1958 \$cmll_obj = $target{cmll_obj}
1959 \$modes_obj = $target{modes_obj}
1960 \$engines_obj = $target{engines_obj}
1961 \$chacha_obj = $target{chacha_obj}
1962 \$poly1305_obj = $target{poly1305_obj}
1963 \$perlasm_scheme = $target{perlasm_scheme}
1964 \$dso_scheme = $target{dso_scheme}
1965 \$shared_target= $target{shared_target}
1966 \$shared_cflag = $target{shared_cflag}
1967 \$shared_ldflag = $target{shared_ldflag}
1968 \$shared_extension = $target{shared_extension}
1969 \$ranlib = $target{ranlib}
1970 \$arflags = $target{arflags}
1971 \$multilib = $target{multilib}
1973 } elsif ($type eq "HASH") {
2015 length((sort { length($a) <=> length($b) } @sequence)[-1]);
2016 print " '$target' => {\n";
2017 foreach (@sequence) {
2019 print " '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
2028 perl => sub { my $x = shift;
2029 $x =~ s/([\\\$\@"])/\\$1/g;
2030 return '"'.$x.'"'; },
2034 defined($processors{$for}) ? $processors{$for} : sub { shift; };
2036 map { $processor->($_); } @_;