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
155 # Forward declarations ###############################################
157 # read_config(filename)
159 # Reads a configuration file and populates %table with the contents
160 # (which the configuration file places in %targets).
163 # resolve_config(target)
165 # Resolves all the late evalutations, inheritances and so on for the
166 # chosen target and any target it inherits from.
170 my ($vol, $dir, $dummy) = File
::Spec
->splitpath($0);
171 my $pattern = File
::Spec
->catpath($vol, $dir, "Configurations/*.conf");
172 foreach (sort glob($pattern) ) {
179 $config{openssldir
}="";
180 $config{processor
}="";
183 my $install_prefix= "$ENV{'INSTALL_PREFIX'}";
184 my $cross_compile_prefix="";
185 my $fipslibdir="/usr/local/ssl/fips-2.0/lib/";
186 my $nofipscanistercheck=0;
187 my $baseaddr="0xFB00000";
190 my $no_shared=0; # but "no-shared" is default
191 my $zlib=1; # but "no-zlib" is default
196 my $Makefile="Makefile";
200 # Known TLS and DTLS protocols
201 my @tls = qw(ssl3 tls1 tls1_1 tls1_2);
202 my @dtls = qw(dtls1 dtls1_2);
204 # Explicitelly known options that are possible to disable. They can
205 # be regexps, and will be used like this: /^no-${option}$/
206 # For developers: keep it sorted alphabetically
233 "ec_nistp_64_gcc_128",
242 "locking", # Really???
259 "rijndael", # Old AES name
284 foreach my $proto ((@tls, @dtls))
286 push(@disablables, $proto);
287 push(@disablables, "$proto-method");
290 # All of the following is disabled by default (RC5 was enabled before 0.9.8):
292 my %disabled = ( # "what" => "comment" [or special keyword "experimental"]
293 "ec_nistp_64_gcc_128" => "default",
295 "jpake" => "experimental",
299 "shared" => "default",
300 "ssl-trace" => "default",
301 "store" => "experimental",
302 "unit-test" => "default",
304 "zlib-dynamic" => "default",
305 "crypto-mdebug" => "default",
307 my @experimental = ();
309 # Note: => pair form used for aesthetics, not to truly make a hash table
310 my @disable_cascades = (
311 # "what" => [ "cascade", ... ]
312 sub { $config{processor
} eq "386" }
315 "ssl3-method" => [ "ssl3" ],
316 "zlib" => [ "zlib-dynamic" ],
317 "rijndael" => [ "aes" ],
319 "ec" => [ "ecdsa", "ecdh", "gost" ],
322 "psk" => [ "jpake" ],
324 "dgram" => [ "dtls" ],
327 # SSL 3.0, (D)TLS 1.0 and TLS 1.1 require MD5 and SHA
328 "md5" => [ "ssl", "tls1", "tls1_1", "dtls1" ],
329 "sha" => [ "ssl", "tls1", "tls1_1", "dtls1" ],
331 # Additionally, SSL 3.0 requires either RSA or DSA+DH
333 && ($disabled{dsa
} || $disabled{dh
}); }
336 # (D)TLS 1.0 and TLS 1.1 also require either RSA or DSA+DH
337 # or ECDSA + ECDH. (D)TLS 1.2 has this requirement as well.
338 # (XXX: We don't support PSK-only builds).
340 && ($disabled{dsa
} || $disabled{dh
})
341 && ($disabled{ecdsa
} || $disabled{ecdh
}); }
342 => [ "tls1", "tls1_1", "tls1_2",
343 "dtls1", "dtls1_2" ],
347 # SRP and HEARTBEATS require TLSEXT
348 "tlsext" => [ "srp", "heartbeats" ],
351 # Avoid protocol support holes. Also disable all versions below N, if version
352 # N is disabled while N+1 is enabled.
354 my @list = (reverse @tls);
355 while ((my $first, my $second) = (shift @list, shift @list)) {
357 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
359 unshift @list, $second;
361 my @list = (reverse @dtls);
362 while ((my $first, my $second) = (shift @list, shift @list)) {
364 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
366 unshift @list, $second;
369 # Construct the string of what $depflags should look like with the defaults
370 # from %disabled above. (we need this to see if we should advise the user
371 # to run "make depend"):
372 my $default_depflags = " ".join(" ",
373 map { my $x = $_; $x =~ tr{[a-z]-}{[A-Z]_}; "-DOPENSSL_NO_$x"; }
374 grep { $disabled{$_} !~ /\(no-depflags\)$/ }
375 sort keys %disabled);
377 # Explicit "no-..." options will be collected in %disabled along with the defaults.
378 # To remove something from %disabled, use "enable-foo" (unless it's experimental).
379 # For symmetry, "disable-foo" is a synonym for "no-foo".
381 # For features called "experimental" here, a more explicit "experimental-foo" is needed to enable.
382 # We will collect such requests in @experimental.
383 # To avoid accidental use of experimental features, applications will have to use -DOPENSSL_EXPERIMENTAL_FOO.
388 &usage
if ($#ARGV < 0);
392 $config{openssl_experimental_defines
}=[];
393 $config{openssl_api_defines
}=[];
394 $config{openssl_algorithm_defines
}=[];
395 $config{openssl_thread_defines
}=[];
396 $config{openssl_sys_defines
}=[];
397 $config{openssl_other_defines
}=[];
404 my $build_prefix = "release_";
408 if (grep /^reconf(igure)?$/, @argvcopy) {
409 if (open IN
, "<$Makefile") {
412 if (/^CONFIGURE_ARGS=\s*(.*)\s*/) {
414 if ($line =~ /^\s*\(/) {
415 # New form perl expression saved in Makefile, eval it
416 @argvcopy = eval $line;
418 # Older form, we split the string and hope for the best
419 @argvcopy = split /\s+/, $line;
421 die "Incorrect data to reconfigure, please do a normal configuration\n"
422 if (grep(/^reconf/,@argvcopy));
423 } elsif (/^CROSS_COMPILE=\s*(.*)/) {
424 $ENV{CROSS_COMPILE
}=$1;
425 } elsif (/^CC=\s*(?:\$\(CROSS_COMPILE\))?(.*?)$/) {
429 print "Reconfiguring with: ", join(" ",@argvcopy), "\n";
430 print " CROSS_COMPILE = ",$ENV{CROSS_COMPILE
},"\n"
431 if $ENV{CROSS_COMPILE
};
432 print " CC = ",$ENV{CC
},"\n" if $ENV{CC
};
435 die "Insufficient data to reconfigure, please do a normal configuration\n";
440 my %unsupported_options = ();
443 s
/^-no-/no-/; # some people just can't read the instructions
445 # rewrite some options in "enable-..." form
446 s
/^-?-?shared$/enable
-shared
/;
447 s
/^sctp$/enable
-sctp
/;
448 s
/^threads$/enable
-threads
/;
449 s
/^zlib$/enable
-zlib
/;
450 s
/^zlib-dynamic$/enable
-zlib
-dynamic
/;
452 if (/^(no|disable|enable|experimental)-(.+)$/)
455 if (!grep { $word =~ /^${_}$/ } @disablables)
457 $unsupported_options{$_} = 1;
461 if (/^no-(.+)$/ || /^disable-(.+)$/)
463 if (!($disabled{$1} eq "experimental"))
465 foreach my $proto ((@tls, @dtls))
467 if ($1 eq "$proto-method")
469 $disabled{"$proto"} = "option($proto-method)";
475 foreach my $proto (@dtls)
477 $disabled{$proto} = "option(dtls)";
482 # Last one of its kind
483 $disabled{"ssl3"} = "option(ssl)";
487 # XXX: Tests will fail if all SSL/TLS
488 # protocols are disabled.
489 foreach my $proto (@tls)
491 $disabled{$proto} = "option(tls)";
496 $disabled{$1} = "option";
500 elsif (/^enable-(.+)$/ || /^experimental-(.+)$/)
503 if ($disabled{$algo} eq "experimental")
505 die "You are requesting an experimental feature; please say 'experimental-$algo' if you are sure\n"
506 unless (/^experimental-/);
507 push @experimental, $algo;
509 delete $disabled{$algo};
511 $threads = 1 if ($algo eq "threads");
513 elsif (/^--strict-warnings$/)
515 $strict_warnings = 1;
519 $build_prefix = "debug_";
521 elsif (/^--release$/)
523 $build_prefix = "release_";
526 { $config{processor
}=386; }
533 # No RSAref support any more since it's not needed.
534 # The check for the option is there so scripts aren't
537 elsif (/^nofipscanistercheck$/)
540 $nofipscanistercheck = 1;
544 if (/^--prefix=(.*)$/)
548 elsif (/^--api=(.*)$/)
552 elsif (/^--libdir=(.*)$/)
556 elsif (/^--openssldir=(.*)$/)
558 $config{openssldir
}=$1;
560 elsif (/^--install.prefix=(.*)$/)
564 elsif (/^--with-zlib-lib=(.*)$/)
566 $withargs{"zlib-lib"}=$1;
568 elsif (/^--with-zlib-include=(.*)$/)
570 $withargs{"zlib-include"}="-I$1";
572 elsif (/^--with-fipslibdir=(.*)$/)
576 elsif (/^--with-baseaddr=(.*)$/)
580 elsif (/^--cross-compile-prefix=(.*)$/)
582 $cross_compile_prefix=$1;
584 elsif (/^--config=(.*)$/)
588 elsif (/^-[lL](.*)$/ or /^-Wl,/)
592 else # common if (/^[-+]/), just pass down...
594 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
598 elsif ($_ =~ /^([^:]+):(.+)$/)
600 eval "\$table{\$1} = \"$2\""; # allow $xxx constructs in the string
605 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
608 unless ($_ eq $target || /^no-/ || /^disable-/)
610 # "no-..." follows later after implied disactivations
611 # have been derived. (Don't take this too seroiusly,
612 # we really only write OPTIONS to the Makefile out of
615 if ($config{options
} eq "")
616 { $config{options
} = $_; }
618 { $config{options
} .= " ".$_; }
621 if (defined($api) && !exists $apitable->{$api}) {
622 die "***** Unsupported api compatibility level: $api\n",
625 if (keys %unsupported_options)
627 die "***** Unsupported options: ",
628 join(", ", keys %unsupported_options), "\n";
634 delete $disabled{"shared"} if ($disabled{"shared"} =~ /^default/);
637 my @tocheckfor = (keys %disabled);
638 while (@tocheckfor) {
639 my %new_tocheckfor = ();
640 my @cascade_copy = (@disable_cascades);
641 while (@cascade_copy) {
642 my ($test, $descendents) = (shift @cascade_copy, shift @cascade_copy);
643 if (ref($test) eq "CODE" ?
$test->() : defined($disabled{$test})) {
645 $new_tocheckfor{$_} => 1; $disabled{$_} = "forced";
646 } grep { !defined($disabled{$_}) } @
$descendents;
649 @tocheckfor = (keys %new_tocheckfor);
652 if ($target eq "TABLE") {
653 foreach (sort keys %table) {
654 print_table_entry
($_, "TABLE");
659 if ($target eq "LIST") {
660 foreach (sort keys %table) {
661 print $_,"\n" unless $table{$_}->{template
};
666 if ($target eq "HASH") {
667 print "%table = (\n";
668 foreach (sort keys %table) {
669 print_table_entry
($_, "HASH");
674 # Backward compatibility?
675 if ($target =~ m/^CygWin32(-.*)$/) {
676 $target = "Cygwin".$1;
679 foreach (sort (keys %disabled))
681 $config{options
} .= " no-$_";
683 printf " no-%-12s %-10s", $_, "[$disabled{$_}]";
693 elsif (/^static-engine$/)
695 elsif (/^zlib-dynamic$/)
702 ($ALGO = $algo = $_) =~ tr/[\-a-z]/[_A-Z]/;
704 if (/^asm$/ || /^err$/ || /^hw$/ || /^hw-/)
706 push @
{$config{openssl_other_defines
}}, "OPENSSL_NO_$ALGO";
707 print " OPENSSL_NO_$ALGO";
709 if (/^err$/) { $flags .= "-DOPENSSL_NO_ERR "; }
710 elsif (/^asm$/) { $no_asm = 1; }
714 ($ALGO,$algo) = ("RMD160","rmd160") if ($algo eq "ripemd");
716 push @
{$config{openssl_algorithm_defines
}}, "OPENSSL_NO_$ALGO";
717 print " OPENSSL_NO_$ALGO";
720 # fix-up crypto/directory name(s)
721 $skip[$#skip]="whrlpool" if $algo eq "whirlpool";
722 $skip[$#skip]="ripemd" if $algo eq "rmd160";
726 $depflags .= " -DOPENSSL_NO_$ALGO";
735 foreach (sort @experimental)
738 ($ALGO = $_) =~ tr/[a-z]/[A-Z]/;
740 # opensslconf.h will set OPENSSL_NO_... unless OPENSSL_EXPERIMENTAL_... is defined
741 push @
{$config{openssl_experimental_defines
}}, "OPENSSL_NO_$ALGO";
742 $exp_cflags .= " -DOPENSSL_EXPERIMENTAL_$ALGO";
745 print "Configuring for $target\n";
747 # Support for legacy targets having a name starting with 'debug-'
748 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
750 $build_prefix = "debug_";
752 # If we do not find debug-foo in the table, the target is set to foo.
753 if (!$table{$target}) {
757 $config{target
} = $target;
758 delete $table{$base_target}->{template
}; # or the next test will fail.
759 my %target = ( %{$table{$base_target}}, resolve_config
($target) );
761 &usage
if (!%target || $target{template
});
763 $exe_ext=".exe" if ($target eq "Cygwin" || $target eq "DJGPP" || $target =~ /^mingw/);
764 $exe_ext=".nlm" if ($target =~ /netware/);
765 $exe_ext=".pm" if ($target =~ /vos/);
767 $default_ranlib = which
("ranlib") || "true";
768 $config{perl
} = $ENV{'PERL'} || which
("perl5") || which
("perl") || "perl";
769 my $make = $ENV{'MAKE'} || "make";
771 $cross_compile_prefix=$ENV{'CROSS_COMPILE'} if $cross_compile_prefix eq "";
773 $config{prefix
} = "/usr/local" if !$config{prefix
};
774 $config{openssldir
} = "ssl" if !$config{openssldir
};
775 $config{openssldir
} = catdir
($config{prefix
}, $config{openssldir
})
776 unless file_name_is_absolute
($config{openssldir
});
778 # Allow environment CC to override compiler...
779 $target{cc
} = $ENV{CC
} || $target{cc
};
781 # For cflags and lflags, add the debug_ or release_ attributes
782 # Do it in such a way that no spurious space is appended (hence the grep).
783 my $cflags = join(" ",
784 grep { $_ } ($target{cflags
},
785 $target{$build_prefix."cflags"}));
786 my $lflags = join(" ",
787 grep { $_ } ($target{lflags
},
788 $target{$build_prefix."lflags"}));
790 $target{ranlib
} = $ENV{'RANLIB'} || $target{ranlib
} || $default_ranlib;
791 $target{ar
} = $ENV{'AR'} || "ar";
792 # Make sure build_scheme is consistent.
793 $target{build_scheme
} = [ $target{build_scheme
} ]
794 if ref($target{build_scheme
}) ne "ARRAY";
796 # if $config{prefix}/lib$target{multilib} is not an existing directory, then
797 # assume that it's not searched by linker automatically, in
798 # which case adding $target{multilib} suffix causes more grief than
799 # we're ready to tolerate, so don't...
800 $target{multilib
}="" if !-d
"$config{prefix}/lib$target{multilib}";
802 $libdir="lib$target{multilib}" if $libdir eq "";
803 $config{enginesdir
}=$config{prefix
} . "/" . $libdir . "/engines";
805 $cflags = "$cflags$exp_cflags";
807 # '%' in $lflags is used to split flags to "pre-" and post-flags
808 my ($prelflags,$postlflags)=split('%',$lflags);
809 if (defined($postlflags)) { $lflags=$postlflags; }
810 else { $lflags=$prelflags; undef $prelflags; }
812 if ($target =~ /^mingw/ && `$target{cc} --target-help 2>&1` !~ m/\-mno\-cygwin/m)
814 $cflags =~ s/\-mno\-cygwin\s*//;
815 $target{shared_ldflag
} =~ s/\-mno\-cygwin\s*//;
818 if ($target =~ /linux.*\-mips/ && !$no_asm && $flags !~ /\-m(ips|arch=)/) {
819 # minimally required architecture flags for assembly modules
820 $cflags="-mips2 $cflags" if ($target =~ /mips32/);
821 $cflags="-mips3 $cflags" if ($target =~ /mips64/);
824 my $no_shared_warn=0;
825 my $no_user_cflags=0;
827 if ($flags ne "") { $cflags="$flags$cflags"; }
828 else { $no_user_cflags=1; }
830 # The DSO code currently always implements all functions so that no
831 # applications will have to worry about that from a compilation point
832 # of view. However, the "method"s may return zero unless that platform
833 # has support compiled in for them. Currently each method is enabled
834 # by a define "DSO_<name>" ... we translate the "dso_scheme" config
835 # string entry into using the following logic;
837 if (!$no_dso && $target{dso_scheme
} ne "")
839 $target{dso_scheme
} =~ tr/[a-z]/[A-Z]/;
840 if ($target{dso_scheme
} eq "DLFCN")
842 $dso_cflags = "-DDSO_DLFCN -DHAVE_DLFCN_H";
844 elsif ($target{dso_scheme
} eq "DLFCN_NO_H")
846 $dso_cflags = "-DDSO_DLFCN";
850 $dso_cflags = "-DDSO_$target{dso_scheme}";
852 $cflags = "$dso_cflags $cflags";
857 if ($target{thread_cflag
} ne "(unknown)" && !$no_threads)
859 # If we know how to do it, support threads by default.
862 if ($target{thread_cflag
} eq "(unknown)" && $threads)
864 # If the user asked for "threads", [s]he is also expected to
865 # provide any system-dependent compiler options that are
869 print "You asked for multi-threading support, but didn't\n";
870 print "provide any system-specific compiler options\n";
873 $thread_cflags="-DOPENSSL_THREADS $cflags" ;
874 push @thread_defines, "OPENSSL_THREADS";
878 $thread_cflags="-DOPENSSL_THREADS $target{thread_cflag} $cflags";
879 push @thread_defines, "OPENSSL_THREADS";
881 # foreach $def (split ' ',$target{thread_cflag})
883 # if ($def =~ s/^-D// && $def !~ /^_/)
885 # push @thread_defines, "$def";
890 $lflags="$libs$lflags" if ($libs ne "");
894 $cflags=~s/\-D[BL]_ENDIAN// if ($fips);
895 $thread_cflags=~s/\-D[BL]_ENDIAN// if ($fips);
900 $cflags=$thread_cflags;
901 push @
{$config{openssl_thread_defines
}}, @thread_defines;
906 $cflags = "-DZLIB $cflags";
907 if (defined($disabled{"zlib-dynamic"}))
909 if (defined($withargs{"zlib-lib"}))
911 $lflags = "$lflags -L" . $withargs{"zlib-lib"} . " -lz";
915 $lflags = "$lflags -lz";
920 $cflags = "-DZLIB_SHARED $cflags";
924 # With "deprecated" disable all deprecated features.
925 if (defined($disabled{"deprecated"})) {
929 # You will find shlib_mark1 and shlib_mark2 explained in Makefile.in
930 my $shared_mark = "";
931 if ($target{shared_target
} eq "")
933 $no_shared_warn = 1 if !$no_shared && !$fips;
938 if ($target{shared_cflag
} ne "")
940 $cflags = "$target{shared_cflag} -DOPENSSL_PIC $cflags";
944 if ($target{build_scheme
}->[0] ne "mk1mf")
946 # add {no-}static-engine to options to allow mkdef.pl to work without extra arguments
949 push @
{$config{openssl_other_defines
}}, "OPENSSL_NO_DYNAMIC_ENGINE";
950 $config{options
}.=" static-engine";
954 push @
{$config{openssl_other_defines
}}, "OPENSSL_NO_STATIC_ENGINE";
955 $config{options
}.=" no-static-engine";
962 if ($target =~ /\-icc$/) # Intel C compiler
965 if (open(FD
,"$target{cc} -V 2>&1 |"))
967 while(<FD
>) { $iccver=$1 if (/Version ([0-9]+)\./); }
972 $cflags=~s/\-KPIC/-fPIC/;
973 # Eliminate unnecessary dependency from libirc.a. This is
974 # essential for shared library support, as otherwise
975 # apps/openssl can end up in endless loop upon startup...
976 $cflags.=" -Dmemcpy=__builtin_memcpy -Dmemset=__builtin_memset";
980 $lflags.=" -i-static";
981 $lflags=~s/\-no_cpprt/-no-cpprt/;
985 $lflags=~s/\-i\-static/-static-intel/;
989 $cflags.=" -no-intel-extensions"; # disable Cilk
990 $lflags=~s/\-no\-cpprt/-no-cxxlib/;
994 # Unlike other OSes (like Solaris, Linux, Tru64, IRIX) BSD run-time
995 # linkers (tested OpenBSD, NetBSD and FreeBSD) "demand" RPATH set on
996 # .so objects. Apparently application RPATH is not global and does
997 # not apply to .so linked with other .so. Problem manifests itself
998 # when libssl.so fails to load libcrypto.so. One can argue that we
999 # should engrave this into Makefile.shared rules or into BSD-* config
1000 # lines above. Meanwhile let's try to be cautious and pass -rpath to
1001 # linker only when --prefix is not /usr.
1002 if ($target =~ /^BSD\-/)
1004 $target{shared_ldflag
}.=" -Wl,-rpath,\$\$(LIBRPATH)" if ($config{prefix
} !~ m
|^/usr[/]*$|);
1007 if ($target{sys_id
} ne "")
1009 #$cflags="-DOPENSSL_SYS_$target{sys_id} $cflags";
1010 push @
{$config{openssl_sys_defines
}}="OPENSSL_SYS_$target{sys_id}";
1013 if ($target{ranlib
} eq "")
1015 $target{ranlib
} = $default_ranlib;
1019 $target{cpuid_obj
}=$table{BASE
}->{cpuid_obj
} if ($config{processor
} eq "386");
1020 $target{cpuid_obj
}.=" uplink.o uplink-x86.o" if ($cflags =~ /\-DOPENSSL_USE_APPLINK/);
1022 $target{bn_obj
} =~ s/\w+-gf2m.o// if (defined($disabled{ec2m
}));
1024 # bn-586 is the only one implementing bn_*_part_words
1025 $cflags.=" -DOPENSSL_BN_ASM_PART_WORDS" if ($target{bn_obj
} =~ /bn-586/);
1026 $cflags.=" -DOPENSSL_IA32_SSE2" if (!$no_sse2 && $target{bn_obj
} =~ /86/);
1028 $cflags.=" -DOPENSSL_BN_ASM_MONT" if ($target{bn_obj
} =~ /-mont/);
1029 $cflags.=" -DOPENSSL_BN_ASM_MONT5" if ($target{bn_obj
} =~ /-mont5/);
1030 $cflags.=" -DOPENSSL_BN_ASM_GF2m" if ($target{bn_obj
} =~ /-gf2m/);
1033 push @
{$config{openssl_other_defines
}}, "OPENSSL_FIPS";
1036 if ($target{sha1_obj
} =~ /\.o$/) {
1037 $cflags.=" -DSHA1_ASM" if ($target{sha1_obj
} =~ /sx86/ || $target{sha1_obj
} =~ /sha1/);
1038 $cflags.=" -DSHA256_ASM" if ($target{sha1_obj
} =~ /sha256/);
1039 $cflags.=" -DSHA512_ASM" if ($target{sha1_obj
} =~ /sha512/);
1040 if ($target{sha1_obj
} =~ /sse2/) {
1042 $target{sha1_obj
} =~ s/\S*sse2\S+//;
1043 } elsif ($cflags !~ /OPENSSL_IA32_SSE2/) {
1044 $cflags.=" -DOPENSSL_IA32_SSE2";
1048 if ($target{md5_obj
} =~ /\.o$/) {
1049 $cflags.=" -DMD5_ASM";
1051 $target{cast_obj
}=$table{BASE
}->{cast_obj
} if (!$no_shared); # CAST assembler is not PIC
1052 if ($target{rmd160_obj
} =~ /\.o$/) {
1053 $cflags.=" -DRMD160_ASM";
1055 if ($target{aes_obj
} =~ /\.o$/) {
1056 $cflags.=" -DAES_ASM" if ($target{aes_obj
} =~ m/\baes\-/);;
1057 # aes-ctr.o is not a real file, only indication that assembler
1058 # module implements AES_ctr32_encrypt...
1059 $cflags.=" -DAES_CTR_ASM" if ($target{aes_obj
} =~ s/\s*aes\-ctr\.o//);
1060 # aes-xts.o indicates presence of AES_xts_[en|de]crypt...
1061 $cflags.=" -DAES_XTS_ASM" if ($target{aes_obj
} =~ s/\s*aes\-xts\.o//);
1062 $target{aes_obj
} =~ s/\s*(vpaes|aesni)\-x86\.o//g if ($no_sse2);
1063 $cflags.=" -DVPAES_ASM" if ($target{aes_obj
} =~ m/vpaes/);
1064 $cflags.=" -DBSAES_ASM" if ($target{aes_obj
} =~ m/bsaes/);
1066 if ($target{wp_obj
} =~ /mmx/ && $config{processor
} eq "386") {
1067 $target{wp_obj
}=$table{BASE
}->{wp_obj
};
1068 } elsif (!$disabled{"whirlpool"}) {
1069 $cflags.=" -DWHIRLPOOL_ASM";
1071 if ($target{modes_obj
} =~ /ghash\-/) {
1072 $cflags.=" -DGHASH_ASM";
1074 if ($target{ec_obj
} =~ /ecp_nistz256/) {
1075 $cflags.=" -DECP_NISTZ256_ASM";
1077 if ($target{poly1305_obj
} =~ /\.o$/) {
1078 $cflags.=" -DPOLY1305_ASM";
1083 # Deal with bn_ops ###################################################
1085 $config{des_ptr
} =0;
1086 $config{des_risc1
} =0;
1087 $config{des_risc2
} =0;
1088 $config{des_unroll
} =0;
1090 $config{rc4_idx
} =0;
1092 $config{export_var_as_fn
} =0;
1093 my $def_int="unsigned int";
1094 $config{rc4_int
} =$def_int;
1095 $config{rc4_chunk
} ="";
1096 $config{md2_int
} =$def_int;
1097 $config{idea_int
} =$def_int;
1098 $config{rc2_int
} =$def_int;
1099 ($config{b64l
},$config{b64
},$config{b32
},$config{b16
},$config{b8
})=(0,0,1,0,0);
1101 $config{des_int
} = "unsigned long";
1103 foreach (sort split(/\s+/,$target{bn_ops
})) {
1104 $config{des_ptr
}=1 if /DES_PTR/;
1105 $config{des_risc1
}=1 if /DES_RISC1/;
1106 $config{des_risc2
}=1 if /DES_RISC2/;
1107 $config{des_unroll
}=1 if /DES_UNROLL/;
1108 $config{des_int
}="unsigned int" if /DES_INT/;
1109 $config{bn_ll
}=1 if /BN_LLONG/;
1110 $config{rc4_int
}="unsigned char" if /RC4_CHAR/;
1111 $config{rc4_int
}="unsigned long" if /RC4_LONG/;
1112 $config{rc4_idx
}=1 if /RC4_INDEX/;
1113 $config{rc4_chunk
}="unsigned long" if /RC4_CHUNK/;
1114 $config{rc4_chunk
}="unsigned long long" if /RC4_CHUNK_LL/;
1115 $config{md2_int
}="unsigned char" if /MD2_CHAR/;
1116 $config{md2_int
}="unsigned long" if /MD2_LONG/;
1117 $config{idea_int
}="unsigned char" if /IDEA_CHAR/;
1118 $config{idea_int
}="unsigned long" if /IDEA_LONG/;
1119 $config{rc2_int
}="unsigned char" if /RC2_CHAR/;
1120 $config{rc2_int
}="unsigned long" if /RC2_LONG/;
1121 $config{bf_ptr
}=1 if $_ eq "BF_PTR";
1122 $config{bf_ptr
}=2 if $_ eq "BF_PTR2";
1123 ($config{b64l
},$config{b64
},$config{b32
},$config{b16
},$config{b8
})
1124 =(0,1,0,0,0) if /SIXTY_FOUR_BIT/;
1125 ($config{b64l
},$config{b64
},$config{b32
},$config{b16
},$config{b8
})
1126 =(1,0,0,0,0) if /SIXTY_FOUR_BIT_LONG/;
1127 ($config{b64l
},$config{b64
},$config{b32
},$config{b16
},$config{b8
})
1128 =(0,0,1,0,0) if /THIRTY_TWO_BIT/;
1129 ($config{b64l
},$config{b64
},$config{b32
},$config{b16
},$config{b8
})
1130 =(0,0,0,1,0) if /SIXTEEN_BIT/;
1131 ($config{b64l
},$config{b64
},$config{b32
},$config{b16
},$config{b8
})
1132 =(0,0,0,0,1) if /EIGHT_BIT/;
1133 $config{export_var_as_fn
}=1 if /EXPORT_VAR_AS_FN/;
1137 # Hack cflags for better warnings (dev option) #######################
1139 # "Stringify" the C flags string. This permits it to be made part of a string
1140 # and works as well on command lines.
1141 $cflags =~ s/([\\\"])/\\\1/g;
1143 $config{version
} = "unknown";
1144 $config{version_num
} = "unknown";
1145 $config{major
} = "unknown";
1146 $config{minor
} = "unknown";
1147 $config{shlib_version_number
} = "unknown";
1148 $config{shlib_version_history
} = "unknown";
1149 $config{shlib_major
} = "unknown";
1150 $config{shlib_minor
} = "unknown";
1152 open(IN
,'<include/openssl/opensslv.h') || die "unable to read opensslv.h:$!\n";
1155 $config{version
}=$1 if /OPENSSL.VERSION.TEXT.*OpenSSL (\S+) /;
1156 $config{version_num
}=$1 if /OPENSSL.VERSION.NUMBER.*(0x\S+)/;
1157 $config{shlib_version_number
}=$1 if /SHLIB_VERSION_NUMBER *"([^"]+)"/;
1158 $config{shlib_version_history
}=$1 if /SHLIB_VERSION_HISTORY *"([^"]*)"/;
1161 if ($config{shlib_version_history
} ne "") { $config{shlib_version_history
} .= ":"; }
1163 if ($config{version
} =~ /(^[0-9]*)\.([0-9\.]*)/)
1169 if ($config{shlib_version_number
} =~ /(^[0-9]*)\.([0-9\.]*)/)
1171 $config{shlib_major
}=$1;
1172 $config{shlib_minor
}=$2;
1175 if (defined($api)) {
1176 $config{openssl_api_defines
} = [ "OPENSSL_MIN_API=".$apitable->{$api} ];
1177 my $apiflag = sprintf("-DOPENSSL_API_COMPAT=%s", $apitable->{$api});
1178 $default_depflags .= " $apiflag";
1179 $cflags .= " $apiflag";
1182 my $ecc = $target{cc
};
1183 $ecc = "clang" if `$target{cc} --version 2>&1` =~ /clang/;
1185 if ($strict_warnings)
1188 die "ERROR --strict-warnings requires gcc or clang" unless ($ecc =~ /gcc(-\d(\.\d)*)?$/ or $ecc =~ /clang$/);
1189 foreach $wopt (split /\s+/, $gcc_devteam_warn)
1191 $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/)
1193 if ($ecc eq "clang")
1195 foreach $wopt (split /\s+/, $clang_devteam_warn)
1197 $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/)
1200 if ($target !~ /^mingw/)
1202 foreach $wopt (split /\s+/, $memleak_devteam_backtrace)
1204 $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/)
1206 if ($target =~ /^BSD-/)
1208 $lflags .= " -lexecinfo";
1213 # Write down our configuration where it fits #########################
1215 open(OUT
,">configdata.pm") || die "unable to create configdata.pm: $!\n";
1223 #use vars qw(\@ISA \@EXPORT);
1224 our \@ISA = qw(Exporter);
1225 our \
@EXPORT = qw(\%config \%target);
1228 print OUT
"our %config = (\n";
1229 foreach (sort keys %config) {
1230 if (ref($config{$_}) eq "ARRAY") {
1231 print OUT
" ", $_, " => [ ", join(", ",
1232 map { quotify
("perl", $_) }
1233 @
{$config{$_}}), " ],\n";
1235 print OUT
" ", $_, " => ", quotify
("perl", $config{$_}), ",\n"
1242 print OUT
"our %target = (\n";
1243 foreach (sort keys %target) {
1244 if (ref($target{$_}) eq "ARRAY") {
1245 print OUT
" ", $_, " => [ ", join(", ",
1246 map { quotify
("perl", $_) }
1247 @
{$target{$_}}), " ],\n";
1249 print OUT
" ", $_, " => ", quotify
("perl", $target{$_}), ",\n"
1259 open(IN
,"<Makefile.in") || die "unable to read Makefile.in: $!\n";
1260 open(OUT
,">$Makefile.new") || die "unable to create $Makefile.new:$!\n";
1261 print OUT
"### Generated automatically from Makefile.in by Configure.\n\n";
1267 $sdirs = 1 if /^SDIRS=/;
1270 foreach $dir (@skip) {
1275 $sdirs = 0 unless /\\$/;
1276 s/fips // if (/^DIRS=/ && !$fips);
1277 s/engines // if (/^DIRS=/ && $disabled{"engine"});
1278 s/^VERSION=.*/VERSION=$config{version}/;
1279 s/^MAJOR=.*/MAJOR=$config{major}/;
1280 s/^MINOR=.*/MINOR=$config{minor}/;
1281 s/^SHLIB_VERSION_NUMBER=.*/SHLIB_VERSION_NUMBER=$config{shlib_version_number}/;
1282 s/^SHLIB_VERSION_HISTORY=.*/SHLIB_VERSION_HISTORY=$config{shlib_version_history}/;
1283 s/^SHLIB_MAJOR=.*/SHLIB_MAJOR=$config{shlib_major}/;
1284 s/^SHLIB_MINOR=.*/SHLIB_MINOR=$config{shlib_minor}/;
1285 s/^SHLIB_EXT=.*/SHLIB_EXT=$target{shared_extension}/;
1286 s/^INSTALLTOP=.*$/INSTALLTOP=$config{prefix}/;
1287 s/^MULTILIB=.*$/MULTILIB=$target{multilib}/;
1288 s/^OPENSSLDIR=.*$/OPENSSLDIR=$config{openssldir}/;
1289 s/^LIBDIR=.*$/LIBDIR=$libdir/;
1290 s/^INSTALL_PREFIX=.*$/INSTALL_PREFIX=$install_prefix/;
1291 s/^PLATFORM=.*$/PLATFORM=$target/;
1292 s/^OPTIONS=.*$/OPTIONS=$config{options}/;
1293 my $argvstring = "(".join(", ", map { quotify
("perl", $_) } @argvcopy).")";
1294 s/^CONFIGURE_ARGS=.*$/CONFIGURE_ARGS=$argvstring/;
1295 if ($cross_compile_prefix)
1297 s/^CC=.*$/CROSS_COMPILE= $cross_compile_prefix\nCC= \$\(CROSS_COMPILE\)$target{cc}/;
1298 s/^AR=\s*/AR= \$\(CROSS_COMPILE\)/;
1299 s/^NM=\s*/NM= \$\(CROSS_COMPILE\)/;
1300 s/^RANLIB=\s*/RANLIB= \$\(CROSS_COMPILE\)/;
1301 s/^MAKEDEPPROG=.*$/MAKEDEPPROG= \$\(CROSS_COMPILE\)$target{cc}/ if $target{cc
} eq "gcc";
1304 s/^CC=.*$/CC= $target{cc}/;
1305 s/^AR=\s*ar/AR= $target{ar}/;
1306 s/^RANLIB=.*/RANLIB= $target{ranlib}/;
1307 s/^MAKEDEPPROG=.*$/MAKEDEPPROG= $target{cc}/ if $ecc eq "gcc" || $ecc eq "clang";
1309 s/^CFLAG=.*$/CFLAG= $cflags/;
1310 s/^DEPFLAG=.*$/DEPFLAG=$depflags/;
1311 s/^PEX_LIBS=.*$/PEX_LIBS= $prelflags/;
1312 s/^EX_LIBS=.*$/EX_LIBS= $lflags/;
1313 s/^EXE_EXT=.*$/EXE_EXT= $exe_ext/;
1314 s/^CPUID_OBJ=.*$/CPUID_OBJ= $target{cpuid_obj}/;
1315 s/^BN_ASM=.*$/BN_ASM= $target{bn_obj}/;
1316 s/^EC_ASM=.*$/EC_ASM= $target{ec_obj}/;
1317 s/^DES_ENC=.*$/DES_ENC= $target{des_obj}/;
1318 s/^AES_ENC=.*$/AES_ENC= $target{aes_obj}/;
1319 s/^BF_ENC=.*$/BF_ENC= $target{bf_obj}/;
1320 s/^CAST_ENC=.*$/CAST_ENC= $target{cast_obj}/;
1321 s/^RC4_ENC=.*$/RC4_ENC= $target{rc4_obj}/;
1322 s/^RC5_ENC=.*$/RC5_ENC= $target{rc5_obj}/;
1323 s/^MD5_ASM_OBJ=.*$/MD5_ASM_OBJ= $target{md5_obj}/;
1324 s/^SHA1_ASM_OBJ=.*$/SHA1_ASM_OBJ= $target{sha1_obj}/;
1325 s/^RMD160_ASM_OBJ=.*$/RMD160_ASM_OBJ= $target{rmd160_obj}/;
1326 s/^WP_ASM_OBJ=.*$/WP_ASM_OBJ= $target{wp_obj}/;
1327 s/^CMLL_ENC=.*$/CMLL_ENC= $target{cmll_obj}/;
1328 s/^MODES_ASM_OBJ.=*$/MODES_ASM_OBJ= $target{modes_obj}/;
1329 s/^ENGINES_ASM_OBJ.=*$/ENGINES_ASM_OBJ= $target{engines_obj}/;
1330 s/^CHACHA_ENC=.*$/CHACHA_ENC= $target{chacha_obj}/;
1331 s/^POLY1305_ASM_OBJ=.*$/POLY1305_ASM_OBJ= $target{poly1305_obj}/;
1332 s/^PERLASM_SCHEME=.*$/PERLASM_SCHEME= $target{perlasm_scheme}/;
1333 s/^PROCESSOR=.*/PROCESSOR= $config{processor}/;
1334 s/^ARFLAGS=.*/ARFLAGS= $target{arflags}/;
1335 s/^PERL=.*/PERL= $config{perl}/;
1336 s/^LIBZLIB=.*/LIBZLIB=$withargs{"zlib-lib"}/;
1337 s/^ZLIB_INCLUDE=.*/ZLIB_INCLUDE=$withargs{"zlib-include"}/;
1338 s/^FIPSLIBDIR=.*/FIPSLIBDIR=$fipslibdir/;
1339 s/^FIPSCANLIB=.*/FIPSCANLIB=libcrypto/ if $fips;
1340 s/^SHARED_FIPS=.*/SHARED_FIPS=/;
1341 s/^SHLIBDIRS=.*/SHLIBDIRS= crypto ssl/;
1342 s/^BASEADDR=.*/BASEADDR=$baseaddr/;
1343 s/^SHLIB_TARGET=.*/SHLIB_TARGET=$target{shared_target}/;
1344 s/^SHLIB_MARK=.*/SHLIB_MARK=$shared_mark/;
1345 s/^SHARED_LIBS=.*/SHARED_LIBS=\$(SHARED_CRYPTO) \$(SHARED_SSL)/ if (!$no_shared);
1346 if ($target{shared_extension
} ne "" && $target{shared_extension
} =~ /^\.s([ol])\.[^\.]*$/)
1349 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.s$sotmp/;
1351 elsif ($target{shared_extension
} ne "" && $target{shared_extension
} =~ /^\.[^\.]*\.dylib$/)
1353 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.dylib/;
1355 elsif ($target{shared_extension
} ne "" && $target{shared_extension
} =~ /^\.s([ol])\.[^\.]*\.[^\.]*$/)
1358 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.s$sotmp.\$(SHLIB_MAJOR) .s$sotmp/;
1360 elsif ($target{shared_extension
} ne "" && $target{shared_extension
} =~ /^\.[^\.]*\.[^\.]*\.dylib$/)
1362 s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.\$(SHLIB_MAJOR).dylib .dylib/;
1364 s/^SHARED_LDFLAGS=.*/SHARED_LDFLAGS=$target{shared_ldflag}/;
1369 rename("$Makefile.new",$Makefile) || die "unable to rename $Makefile.new\n";
1371 print "IsMK1MF =", ($target{build_scheme
}->[0] eq "mk1mf" ?
"yes" : "no"), "\n";
1372 print "CC =$target{cc}\n";
1373 print "CFLAG =$cflags\n";
1374 print "EX_LIBS =$lflags\n";
1375 print "CPUID_OBJ =$target{cpuid_obj}\n";
1376 print "BN_ASM =$target{bn_obj}\n";
1377 print "EC_ASM =$target{ec_obj}\n";
1378 print "DES_ENC =$target{des_obj}\n";
1379 print "AES_ENC =$target{aes_obj}\n";
1380 print "BF_ENC =$target{bf_obj}\n";
1381 print "CAST_ENC =$target{cast_obj}\n";
1382 print "RC4_ENC =$target{rc4_obj}\n";
1383 print "RC5_ENC =$target{rc5_obj}\n";
1384 print "MD5_OBJ_ASM =$target{md5_obj}\n";
1385 print "SHA1_OBJ_ASM =$target{sha1_obj}\n";
1386 print "RMD160_OBJ_ASM=$target{rmd160_obj}\n";
1387 print "CMLL_ENC =$target{cmll_obj}\n";
1388 print "MODES_OBJ =$target{modes_obj}\n";
1389 print "ENGINES_OBJ =$target{engines_obj}\n";
1390 print "CHACHA_ENC =$target{chacha_obj}\n";
1391 print "POLY1305_OBJ =$target{poly1305_obj}\n";
1392 print "PROCESSOR =$config{processor}\n";
1393 print "RANLIB =$target{ranlib}\n";
1394 print "ARFLAGS =$target{arflags}\n";
1395 print "PERL =$config{perl}\n";
1397 system("$config{perl} -I. -Mconfigdata util/dofile.pl < crypto/opensslconf.h.in > include/openssl/opensslconf.h.new");
1399 rename("include/openssl/opensslconf.h.new","include/openssl/opensslconf.h") || die "unable to rename include/openssl/opensslconf.h.new\n";
1404 print "SIXTY_FOUR_BIT_LONG mode\n" if $config{b64l
};
1405 print "SIXTY_FOUR_BIT mode\n" if $config{b64
};
1406 print "THIRTY_TWO_BIT mode\n" if $config{b32
};
1407 print "SIXTEEN_BIT mode\n" if $config{b16
};
1408 print "EIGHT_BIT mode\n" if $config{b8
};
1409 print "DES_PTR used\n" if $config{des_ptr
};
1410 print "DES_RISC1 used\n" if $config{des_risc1
};
1411 print "DES_RISC2 used\n" if $config{des_risc2
};
1412 print "DES_UNROLL used\n" if $config{des_unroll
};
1413 print "DES_INT used\n" if $config{des_int
} =~ / int$/;
1414 print "BN_LLONG mode\n" if $config{bn_ll
};
1415 print "RC4 uses $config{rc4_int}\n" if $config{rc4_int
} != $def_int;
1416 print "RC4_INDEX mode\n" if $config{rc4_idx
};
1417 print "RC4_CHUNK is undefined\n" unless $config{rc4_chunk
};
1418 print "RC4_CHUNK is $config{rc4_chunk}\n" if $config{rc4_chunk
};
1419 print "MD2 uses $config{md2_int}\n" if $config{md2_int
} != $def_int;
1420 print "IDEA uses $config{idea_int}\n" if $config{idea_int
} != $def_int;
1421 print "RC2 uses $config{rc2_int}\n" if $config{rc2_int
} != $def_int;
1422 print "BF_PTR used\n" if $config{bf_ptr
} == 1;
1423 print "BF_PTR2 used\n" if $config{bf_ptr
} == 2;
1425 # Copy all Makefile.in to Makefile (except top-level)
1429 return if ($_ ne "Makefile.in" || $File::Find
::dir
eq ".");
1430 my $in = IO
::File
->new($_, "r") or
1431 die sprintf "Error reading Makefile.in in %s: !$\n",
1433 my $out = IO
::File
->new("Makefile", "w") or
1434 die sprintf "Error writing Makefile in %s: !$\n",
1436 print $out "# Generated from $_, do not edit\n";
1437 while (my $line = <$in>) { print $out $line }
1439 die sprintf "Error reading Makefile.in in %s: !$\n",
1442 die sprintf "Error writing Makefile in %s: !$\n",
1448 my $make_command = "$make PERL=\'$config{perl}\'";
1449 my $make_targets = "";
1450 $make_targets .= " depend" if $depflags ne $default_depflags && $make_depend;
1451 (system $make_command.$make_targets) == 0 or die "make $make_targets failed"
1452 if $make_targets ne "";
1453 if ($depflags ne $default_depflags && !$make_depend) {
1454 $warn_make_depend++;
1458 open (OUT
,">crypto/buildinf.h") || die "Can't open buildinf.h";
1461 /* auto-generated by Configure for crypto/cversion.c:
1462 * for Unix builds, crypto/Makefile.ssl generates functional definitions;
1463 * Windows builds (and other mk1mf builds) compile cversion.c with
1464 * -DMK1MF_BUILD and use definitions added to this file by util/mk1mf.pl. */
1465 #error "Windows builds (PLATFORM=$target) use mk1mf.pl-created Makefiles"
1470 # create the ms/version32.rc file if needed
1471 if (! grep /^netware/, @
{$target{build_scheme
}}) {
1472 my ($v1, $v2, $v3, $v4);
1473 if ($config{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) {
1479 open (OUT
,">ms/version32.rc") || die "Can't open ms/version32.rc";
1486 FILEVERSION $v1,$v2,$v3,$v4
1487 PRODUCTVERSION $v1,$v2,$v3,$v4
1494 FILEOS VOS__WINDOWS32
1498 BLOCK "StringFileInfo"
1503 VALUE "CompanyName", "The OpenSSL Project, http://www.openssl.org/\\0"
1504 VALUE "FileDescription", "OpenSSL Shared Library\\0"
1505 VALUE "FileVersion", "$config{version}\\0"
1507 VALUE "InternalName", "libeay32\\0"
1508 VALUE "OriginalFilename", "libeay32.dll\\0"
1510 VALUE "InternalName", "ssleay32\\0"
1511 VALUE "OriginalFilename", "ssleay32.dll\\0"
1513 VALUE "ProductName", "The OpenSSL Toolkit\\0"
1514 VALUE "ProductVersion", "$config{version}\\0"
1516 //VALUE "Comments", "\\0"
1517 VALUE "LegalCopyright", "Copyright © 1998-2015 The OpenSSL Project. Copyright © 1995-1998 Eric A. Young, Tim J. Hudson. All rights reserved.\\0"
1518 //VALUE "LegalTrademarks", "\\0"
1519 //VALUE "PrivateBuild", "\\0"
1520 //VALUE "SpecialBuild", "\\0"
1525 VALUE "Translation", 0x409, 0x4b0
1534 my ($builder, @builder_opts) = @
{$target{build_scheme
}};
1535 $builders{$builder}->(@builder_opts);
1539 Configured for $target.
1542 print <<"EOF" if (!$no_threads && !$threads);
1544 The library could not be configured for supporting multi-threaded
1545 applications as the compiler options required on this system are not known.
1546 See file INSTALL for details if you need multi-threading.
1549 print <<"EOF" if ($no_shared_warn);
1551 You gave the option 'shared', which is not supported on this platform, so
1552 we will pretend you gave the option 'no-shared'. If you know how to implement
1553 shared libraries, please let us know (but please first make sure you have
1554 tried with a current version of OpenSSL).
1557 print <<"EOF" if ($warn_make_depend);
1559 *** Because of configuration changes, you MUST do the following before
1567 ######################################################################
1569 # Helpers and utility functions
1572 # Configuration file reading #########################################
1574 # Helper function to implement conditional inheritance depending on the
1575 # value of $no_asm. Used in inherit_from values as follows:
1577 # inherit_from => [ "template", asm("asm_tmpl") ]
1586 # Helper function to implement adding values to already existing configuration
1587 # values. It handles elements that are ARRAYs, CODEs and scalars
1589 my $separator = shift;
1591 # If there's any ARRAY in the collection of values, we will return
1592 # an ARRAY of combined values, otherwise a string of joined values
1593 # with $separator as the separator.
1594 my $found_array = 0;
1598 if (ref($_) eq "ARRAY") {
1609 join($separator, @values);
1613 my $separator = shift;
1615 sub { _add
($separator, @x, @_) };
1618 my $separator = shift;
1620 sub { _add
($separator, @_, @x) };
1623 # configuration reader, evaluates the input file as a perl script and expects
1624 # it to fill %targets with target configurations. Those are then added to
1628 open(CONFFILE
, "< $fname")
1629 or die "Can't open configuration file '$fname'!\n";
1632 my $content = <CONFFILE
>;
1637 local %table = %::table
; # Protect %table from tampering
1643 # For each target, check that it's configured with a hash table.
1644 foreach (keys %targets) {
1645 if (ref($targets{$_}) ne "HASH") {
1646 if (ref($targets{$_}) eq "") {
1647 warn "Deprecated target configuration for $_, ignoring...\n";
1649 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
1651 delete $targets{$_};
1655 %table = (%table, %targets);
1659 # configuration resolver. Will only resolve all the lazy evalutation
1660 # codeblocks for the chozen target and all those it inherits from,
1662 sub resolve_config
{
1664 my @breadcrumbs = @_;
1666 if (grep { $_ eq $target } @breadcrumbs) {
1667 die "inherit_from loop! target backtrace:\n "
1668 ,$target,"\n ",join("\n ", @breadcrumbs),"\n";
1671 if (!defined($table{$target})) {
1672 warn "Warning! target $target doesn't exist!\n";
1675 # Recurse through all inheritances. They will be resolved on the
1676 # fly, so when this operation is done, they will all just be a
1677 # bunch of attributes with string values.
1678 # What we get here, though, are keys with references to lists of
1679 # the combined values of them all. We will deal with lists after
1680 # this stage is done.
1681 my %combined_inheritance = ();
1682 if ($table{$target}->{inherit_from
}) {
1684 map { ref($_) eq "CODE" ?
$_->() : $_ } @
{$table{$target}->{inherit_from
}};
1685 foreach (@inherit_from) {
1686 my %inherited_config = resolve_config
($_, $target, @breadcrumbs);
1688 # 'template' is a marker that's considered private to
1689 # the config that had it.
1690 delete $inherited_config{template
};
1693 if (!$combined_inheritance{$_}) {
1694 $combined_inheritance{$_} = [];
1696 push @
{$combined_inheritance{$_}}, $inherited_config{$_};
1697 } keys %inherited_config;
1701 # We won't need inherit_from in this target any more, since we've
1702 # resolved all the inheritances that lead to this
1703 delete $table{$target}->{inherit_from
};
1705 # Now is the time to deal with those lists. Here's the place to
1706 # decide what shall be done with those lists, all based on the
1707 # values of the target we're currently dealing with.
1708 # - If a value is a coderef, it will be executed with the list of
1709 # inherited values as arguments.
1710 # - If the corresponding key doesn't have a value at all or is the
1711 # emoty string, the inherited value list will be run through the
1712 # default combiner (below), and the result becomes this target's
1714 # - Otherwise, this target's value is assumed to be a string that
1715 # will simply override the inherited list of values.
1716 my $default_combiner = add
(" ");
1719 map { $_ => 1 } (keys %combined_inheritance,
1720 keys %{$table{$target}});
1721 foreach (sort keys %all_keys) {
1723 # Current target doesn't have a value for the current key?
1724 # Assign it the default combiner, the rest of this loop body
1725 # will handle it just like any other coderef.
1726 if (!exists $table{$target}->{$_}) {
1727 $table{$target}->{$_} = $default_combiner;
1730 my $valuetype = ref($table{$target}->{$_});
1731 if ($valuetype eq "CODE") {
1732 # CODE reference, execute it with the inherited values as
1734 $table{$target}->{$_} =
1735 $table{$target}->{$_}->(@
{$combined_inheritance{$_}});
1736 } elsif ($valuetype eq "ARRAY" || $valuetype eq "") {
1737 # ARRAY or Scalar, just leave it as is.
1739 # Some other type of reference that we don't handle.
1740 # Better to abort at this point.
1741 die "cannot handle reference type $valuetype,"
1742 ," found in target $target -> $_\n";
1746 # Finally done, return the result.
1747 return %{$table{$target}};
1752 print STDERR
$usage;
1753 print STDERR
"\npick os/compiler from:\n";
1757 foreach $i (sort keys %table)
1759 next if $table{$i}->{template
};
1760 next if $i =~ /^debug/;
1761 $k += length($i) + 1;
1767 print STDERR
$i . " ";
1769 foreach $i (sort keys %table)
1771 next if $table{$i}->{template
};
1772 next if $i !~ /^debug/;
1773 $k += length($i) + 1;
1779 print STDERR
$i . " ";
1781 print STDERR
"\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
1785 # Configuration printer ##############################################
1787 sub print_table_entry
1790 my %target = resolve_config
($target);
1793 # Don't print the templates
1794 return if $target{template
};
1835 if ($type eq "TABLE") {
1837 print "*** $target\n";
1838 printf "\$%-12s = %s\n", $_, $target{$_} foreach (@sequence);
1839 } elsif ($type eq "HASH") {
1841 length((sort { length($a) <=> length($b) } @sequence)[-1]);
1842 print " '$target' => {\n";
1843 foreach (@sequence) {
1845 print " '",$_,"'"," " x
($largest - length($_))," => '",$target{$_},"',\n";
1852 # Utility routines ###################################################
1858 foreach $path (split /:/, $ENV{PATH
})
1860 if (-f
"$path/$name$exe_ext" and -x _
)
1862 return "$path/$name$exe_ext" unless ($name eq "perl" and
1863 system("$path/$name$exe_ext -e " . '\'exit($]<5.0);\''));
1868 sub print_table_entry
1871 my %target = resolve_config
($target);
1874 # Don't print the templates
1875 return if $target{template
};
1877 if ($type eq "TABLE") {
1882 \$cflags = $target{cflags}
1883 \$debug_cflags = $target{debug_cflags}
1884 \$release_cflags = $target{release_cflags}
1885 \$unistd = $target{unistd}
1886 \$thread_cflag = $target{thread_cflag}
1887 \$sys_id = $target{sys_id}
1888 \$lflags = $target{lflags}
1889 \$debug_lflags = $target{debug_lflags}
1890 \$release_lflags = $target{release_lflags}
1891 \$bn_ops = $target{bn_ops}
1892 \$cpuid_obj = $target{cpuid_obj}
1893 \$bn_obj = $target{bn_obj}
1894 \$ec_obj = $target{ec_obj}
1895 \$des_obj = $target{des_obj}
1896 \$aes_obj = $target{aes_obj}
1897 \$bf_obj = $target{bf_obj}
1898 \$md5_obj = $target{md5_obj}
1899 \$sha1_obj = $target{sha1_obj}
1900 \$cast_obj = $target{cast_obj}
1901 \$rc4_obj = $target{rc4_obj}
1902 \$rmd160_obj = $target{rmd160_obj}
1903 \$rc5_obj = $target{rc5_obj}
1904 \$wp_obj = $target{wp_obj}
1905 \$cmll_obj = $target{cmll_obj}
1906 \$modes_obj = $target{modes_obj}
1907 \$engines_obj = $target{engines_obj}
1908 \$chacha_obj = $target{chacha_obj}
1909 \$poly1305_obj = $target{poly1305_obj}
1910 \$perlasm_scheme = $target{perlasm_scheme}
1911 \$dso_scheme = $target{dso_scheme}
1912 \$shared_target= $target{shared_target}
1913 \$shared_cflag = $target{shared_cflag}
1914 \$shared_ldflag = $target{shared_ldflag}
1915 \$shared_extension = $target{shared_extension}
1916 \$ranlib = $target{ranlib}
1917 \$arflags = $target{arflags}
1918 \$multilib = $target{multilib}
1920 } elsif ($type eq "HASH") {
1962 length((sort { length($a) <=> length($b) } @sequence)[-1]);
1963 print " '$target' => {\n";
1964 foreach (@sequence) {
1966 print " '",$_,"'"," " x
($largest - length($_))," => '",$target{$_},"',\n";
1975 perl
=> sub { my $x = shift;
1976 $x =~ s/([\\\$\@"])/\\$1/g;
1977 return '"'.$x.'"'; },
1981 defined($processors{$for}) ?
$processors{$for} : sub { shift; };
1983 map { $processor->($_); } @_;