X-Git-Url: https://git.openssl.org/?p=openssl.git;a=blobdiff_plain;f=Configure;h=080bc06fd4ec5d352d92531038f2bd9462953abd;hp=d5637401c47b95eabf6c2fb8653d9c1a800a3ac7;hb=317be63875e59efa34be0075eaff3c033ef6969f;hpb=9ab6fc5936be62f6fee1c433938eae4c89aa23da;ds=sidebyside diff --git a/Configure b/Configure index d5637401c4..080bc06fd4 100755 --- a/Configure +++ b/Configure @@ -10,11 +10,12 @@ require 5.000; use strict; use File::Basename; -use File::Spec::Functions; +use File::Spec::Functions qw/:DEFAULT abs2rel rel2abs/; +use File::Path qw/mkpath/; # see INSTALL for instructions. -my $usage="Usage: Configure [no- ...] [enable- ...] [experimental- ...] [-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"; +my $usage="Usage: Configure [no- ...] [enable- ...] [-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"; # Options: # @@ -31,10 +32,6 @@ my $usage="Usage: Configure [no- ...] [enable- ...] [experimenta # This becomes the value of OPENSSLDIR in Makefile and in C. # (Default: PREFIX/ssl) # -# --install_prefix Additional prefix for package builders (empty by -# default). This needn't be set in advance, you can -# just as well use "make INSTALL_PREFIX=/whatever install". -# # --cross-compile-prefix Add specified prefix to binutils components. # # --api One of 0.9.8, 1.0.0 or 1.1.0. Do not compile support for @@ -49,6 +46,8 @@ my $usage="Usage: Configure [no- ...] [enable- ...] [experimenta # multithreaded applications (default is "threads" if we # know how to do it) # [no-]shared [don't] try to create shared libraries when supported. +# [no-]pic [don't] try to build position independent code when supported. +# If disabled, it also disables shared and dynamic-engine. # no-asm do not use assembler # no-dso do not compile in any native shared-library methods. This # will ensure that all methods just return NULL. @@ -65,32 +64,8 @@ my $usage="Usage: Configure [no- ...] [enable- ...] [experimenta # DEBUG_SAFESTACK use type-safe stacks to enforce type-safety on stack items # provided to stack calls. Generates unique stack functions for # each possible stack type. -# DES_PTR use pointer lookup vs arrays in the DES in crypto/des/des_locl.h -# DES_RISC1 use different DES_ENCRYPT macro that helps reduce register -# dependancies but needs to more registers, good for RISC CPU's -# DES_RISC2 A different RISC variant. -# DES_UNROLL unroll the inner DES loop, sometimes helps, somtimes hinders. -# DES_INT use 'int' instead of 'long' for DES_LONG in crypto/des/des.h -# This is used on the DEC Alpha where long is 8 bytes -# and int is 4 # BN_LLONG use the type 'long long' in crypto/bn/bn.h -# MD2_CHAR use 'char' instead of 'int' for MD2_INT in crypto/md2/md2.h -# MD2_LONG use 'long' instead of 'int' for MD2_INT in crypto/md2/md2.h -# IDEA_SHORT use 'short' instead of 'int' for IDEA_INT in crypto/idea/idea.h -# IDEA_LONG use 'long' instead of 'int' for IDEA_INT in crypto/idea/idea.h -# RC2_SHORT use 'short' instead of 'int' for RC2_INT in crypto/rc2/rc2.h -# RC2_LONG use 'long' instead of 'int' for RC2_INT in crypto/rc2/rc2.h # RC4_CHAR use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h -# RC4_LONG use 'long' instead of 'int' for RC4_INT in crypto/rc4/rc4.h -# RC4_INDEX define RC4_INDEX in crypto/rc4/rc4_locl.h. This turns on -# array lookups instead of pointer use. -# RC4_CHUNK enables code that handles data aligned at long (natural CPU -# word) boundary. -# RC4_CHUNK_LL enables code that handles data aligned at long long boundary -# (intended for 64-bit CPUs running 32-bit OS). -# BF_PTR use 'pointer arithmatic' for Blowfish (unsafe on Alpha). -# BF_PTR2 intel specific version (generic version is more efficient). -# # Following are set automatically by this script # # MD5_ASM use some extra md5 assember, @@ -103,32 +78,45 @@ my $usage="Usage: Configure [no- ...] [enable- ...] [experimenta # Minimum warning options... any contributions to OpenSSL should at least get # past these. -my $gcc_devteam_warn = "-Wall -pedantic -DPEDANTIC -Wno-long-long -Wsign-compare -Wmissing-prototypes -Wshadow -Wformat -Wtype-limits -Werror -DREF_CHECK -DDEBUG_UNUSED"; +my $gcc_devteam_warn = "-DPEDANTIC -DREF_DEBUG -DDEBUG_UNUSED -DBIO_DEBUG" + . " -pedantic" + . " -Wall" + . " -Wno-long-long" + . " -Wsign-compare" + . " -Wmissing-prototypes" + . " -Wshadow" + . " -Wformat" + . " -Wtype-limits" + . " -Werror" + ; # These are used in addition to $gcc_devteam_warn when the compiler is clang. # TODO(openssl-team): fix problems and investigate if (at least) the # following warnings can also be enabled: -# -Wswitch-enum, -Wunused-macros, -Wmissing-field-initializers, -# -Wcast-align, -# -Wunreachable-code -Wunused-parameter -Wlanguage-extension-token -# -Wextended-offsetof -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"; - -# Warn that "make depend" should be run? -my $warn_make_depend = 0; - -# These are used in addition to $gcc_devteam_warn unless this is a mingw build. -# This adds backtrace information to the memory leak info. -my $memleak_devteam_backtrace = "-rdynamic -DCRYPTO_MDEBUG_BACKTRACE"; - +# -Wswitch-enum +# -Wcast-align +# -Wunreachable-code +# -Wlanguage-extension-token -- no, we use asm() +# -Wunused-macros -- no, too tricky for BN and _XOPEN_SOURCE etc +# -Wextended-offsetof -- no, needed in CMS ASN1 code +my $clang_devteam_warn = "" + . " -Qunused-arguments" + . " -Wextra" + . " -Wno-unused-parameter" + . " -Wno-missing-field-initializers" + . " -Wno-language-extension-token" + . " -Wno-extended-offsetof" + . " -Wconditional-uninitialized" + . " -Wincompatible-pointer-types-discards-qualifiers" + . " -Wmissing-variable-declarations" + ; + +# This adds backtrace information to the memory leak info. Is only used +# when crypto-mdebug-backtrace is enabled. +my $memleak_devteam_backtrace = "-rdynamic"; my $strict_warnings = 0; -my $x86_gcc_des="DES_PTR DES_RISC1 DES_UNROLL"; - -# MD2_CHAR slags pentium pros -my $x86_gcc_opts="RC4_INDEX MD2_INT"; - # As for $BSDthreads. Idea is to maintain "collective" set of flags, # which would cover all BSD flavors. -pthread applies to them all, # but is treated differently. OpenBSD expands is as -D_POSIX_THREAD @@ -169,6 +157,14 @@ sub resolve_config; # Information collection ############################################# +# Unified build supports separate build dir +my $srcdir = catdir(absolutedir(dirname($0))); # catdir ensures local syntax +my $blddir = catdir(absolutedir(".")); # catdir ensures local syntax +my $dofile = abs2rel(catfile($srcdir, "util/dofile.pl")); + +$config{sourcedir} = abs2rel($srcdir); +$config{builddir} = abs2rel($blddir); + # Collect version numbers $config{version} = "unknown"; $config{version_num} = "unknown"; @@ -176,8 +172,7 @@ $config{shlib_version_number} = "unknown"; $config{shlib_version_history} = "unknown"; collect_information( - ' sub { $config{version} = $1; }, qr/OPENSSL.VERSION.NUMBER.*(0x\S+)/ => sub { $config{version_num}=$1 }, qr/SHLIB_VERSION_NUMBER *"([^"]+)"/ => sub { $config{shlib_version_number}=$1 }, @@ -196,8 +191,7 @@ die "erroneous version information in opensslv.h: ", # Collect target configurations -my ($vol, $dir, $dummy) = File::Spec->splitpath($0); -my $pattern = File::Spec->catpath($vol, $dir, "Configurations/*.conf"); +my $pattern = catfile(dirname($0), "Configurations", "*.conf"); foreach (sort glob($pattern) ) { &read_config($_); } @@ -210,19 +204,11 @@ $config{prefix}=""; $config{openssldir}=""; $config{processor}=""; $config{libdir}=""; -$config{install_prefix}= "$ENV{'INSTALL_PREFIX'}"; $config{cross_compile_prefix}=""; $config{fipslibdir}="/usr/local/ssl/fips-2.0/lib/"; my $nofipscanistercheck=0; $config{baseaddr}="0xFB00000"; -my $no_threads=0; my $threads=0; -$config{no_shared}=0; # but "no-shared" is default -my $zlib=1; # but "no-zlib" is default -my $no_rfc3779=0; -my $no_asm=0; -my $no_dso=0; -my $Makefile="Makefile"; my $default_ranlib; $config{fips}=0; @@ -236,7 +222,7 @@ $config{sdirs} = [ "bn", "ec", "rsa", "dsa", "dh", "dso", "engine", "buffer", "bio", "stack", "lhash", "rand", "err", "evp", "asn1", "pem", "x509", "x509v3", "conf", "txt_db", "pkcs7", "pkcs12", "comp", "ocsp", "ui", - "cms", "ts", "jpake", "srp", "store", "cmac", "ct", "async", "kdf" + "cms", "ts", "srp", "cmac", "ct", "async", "kdf" ]; # Known TLS and DTLS protocols @@ -250,6 +236,9 @@ my @dtls = qw(dtls1 dtls1_2); my @disablables = ( "aes", "asm", + "async", + "autoalginit", + "autoerrinit", "bf", "camellia", "capieng", @@ -259,6 +248,7 @@ my @disablables = ( "cms", "comp", "crypto-mdebug", + "crypto-mdebug-backtrace", "ct", "deprecated", "des", @@ -267,20 +257,21 @@ my @disablables = ( "dsa", "dso", "dtls", - "dynamic[-_]engine", + "dynamic-engine", "ec", "ec2m", "ecdh", "ecdsa", "ec_nistp_64_gcc_128", + "egd", "engine", - "err", # Really??? + "err", + "filenames", "heartbeats", "hmac", "hw(-.+)?", "idea", - "jpake", - "locking", # Really??? + "locking", "md2", "md4", "md5", @@ -289,6 +280,7 @@ my @disablables = ( "nextprotoneg", "ocb", "ocsp", + "pic", "poly1305", "posix-io", "psk", @@ -298,6 +290,7 @@ my @disablables = ( "rdrand", "rfc3779", "rijndael", # Old AES name + "ripemd", "rmd160", "rsa", "scrypt", @@ -314,9 +307,10 @@ my @disablables = ( "ssl-trace", "static-engine", "stdio", - "store", "threads", "tls", + "ts", + "ui", "unit-test", "whirlpool", "zlib", @@ -328,24 +322,26 @@ foreach my $proto ((@tls, @dtls)) push(@disablables, "$proto-method"); } +my @deprecated_disablables = ( + "ssl2", + ); + # All of the following is disabled by default (RC5 was enabled before 0.9.8): -my %disabled = ( # "what" => "comment" [or special keyword "experimental"] - "ec_nistp_64_gcc_128" => "default", - "egd" => "default", - "jpake" => "experimental", - "md2" => "default", - "rc5" => "default", - "sctp" => "default", - "shared" => "default", - "ssl-trace" => "default", - "store" => "experimental", - "unit-test" => "default", - "zlib" => "default", - "zlib-dynamic" => "default", - "crypto-mdebug" => "default", - ); -my @experimental = (); +our %disabled = ( # "what" => "comment" + "ec_nistp_64_gcc_128" => "default", + "egd" => "default", + "md2" => "default", + "rc5" => "default", + "sctp" => "default", + "shared" => "default", + "ssl-trace" => "default", + "static-engine" => "default", + "unit-test" => "default", + "zlib" => "default", + "crypto-mdebug" => "default", + "heartbeats" => "default", + ); # Note: => pair form used for aesthetics, not to truly make a hash table my @disable_cascades = ( @@ -358,7 +354,6 @@ my @disable_cascades = ( "rijndael" => [ "aes" ], "des" => [ "mdc2" ], "ec" => [ "ecdsa", "ecdh" ], - "psk" => [ "jpake" ], "dgram" => [ "dtls" ], "dtls" => [ @dtls ], @@ -385,6 +380,14 @@ my @disable_cascades = ( # SRP and HEARTBEATS require TLSEXT "tlsext" => [ "srp", "heartbeats" ], + + "crypto-mdebug" => [ "crypto-mdebug-backtrace" ], + + # Without DSO, we can't load dynamic engines, so don't build them dynamic + "dso" => [ "dynamic-engine" ], + + # Without position independent code, there can be no shared libraries or DSOs + "pic" => [ "shared", "dynamic-engine" ], ); # Avoid protocol support holes. Also disable all versions below N, if version @@ -405,30 +408,28 @@ while ((my $first, my $second) = (shift @list, shift @list)) { unshift @list, $second; } -# Construct the string of what $config{depflags} should look like with the defaults -# from %disabled above. (we need this to see if we should advise the user -# to run "make depend"): -my $default_depflags = join(" ", - map { my $x = $_; $x =~ tr{[a-z]-}{[A-Z]_}; "-DOPENSSL_NO_$x"; } - grep { $disabled{$_} !~ /\(no-depflags\)$/ } - sort keys %disabled); - # Explicit "no-..." options will be collected in %disabled along with the defaults. -# To remove something from %disabled, use "enable-foo" (unless it's experimental). +# To remove something from %disabled, use "enable-foo". # For symmetry, "disable-foo" is a synonym for "no-foo". -# For features called "experimental" here, a more explicit "experimental-foo" is needed to enable. -# We will collect such requests in @experimental. -# To avoid accidental use of experimental features, applications will have to use -DOPENSSL_EXPERIMENTAL_FOO. +my @generated_headers = ( + "include/openssl/opensslconf.h", + "crypto/include/internal/bn_conf.h", + "crypto/include/internal/dso_conf.h" + ); + +my @generated_by_make_headers = ( + "crypto/buildinf.h" + ); my $no_sse2=0; &usage if ($#ARGV < 0); -my $flags=""; -$config{depflags}=""; -$config{openssl_experimental_defines}=[]; +my $user_cflags=""; +my @user_defines=(); +my $unified = 0; $config{openssl_api_defines}=[]; $config{openssl_algorithm_defines}=[]; $config{openssl_thread_defines}=[]; @@ -437,7 +438,6 @@ $config{openssl_other_defines}=[]; my $libs=""; my $target=""; $config{options}=""; -my $make_depend=0; my %withargs=(); my $build_prefix = "release_"; @@ -471,7 +471,7 @@ if (grep /^reconf(igure)?$/, @argvcopy) { # centered information gathering the reading configdata.pm # while () { - chomp; + s|\R$||; if (/^CONFIGURE_ARGS=\s*(.*)\s*/) { # Older form, we split the string and hope for the best @argvcopy = split /\s+/, $_; @@ -494,8 +494,16 @@ if (grep /^reconf(igure)?$/, @argvcopy) { $config{perlargv} = [ @argvcopy ]; my %unsupported_options = (); +my %deprecated_options = (); foreach (@argvcopy) { + # VMS is a case insensitive environment, and depending on settings + # out of our control, we may receive options uppercased. Let's + # downcase at least the part before any equal sign. + if ($^O eq "VMS") + { + s/^([^=]*)/lc($1)/e; + } s /^-no-/no-/; # some people just can't read the instructions # rewrite some options in "enable-..." form @@ -505,10 +513,15 @@ foreach (@argvcopy) s /^zlib$/enable-zlib/; s /^zlib-dynamic$/enable-zlib-dynamic/; - if (/^(no|disable|enable|experimental)-(.+)$/) + if (/^(no|disable|enable)-(.+)$/) { my $word = $2; - if (!grep { $word =~ /^${_}$/ } @disablables) + if (grep { $word =~ /^${_}$/ } @deprecated_disablables) + { + $deprecated_options{$_} = 1; + next; + } + elsif (!grep { $word =~ /^${_}$/ } @disablables) { $unsupported_options{$_} = 1; next; @@ -516,52 +529,59 @@ foreach (@argvcopy) } if (/^no-(.+)$/ || /^disable-(.+)$/) { - if (!($disabled{$1} eq "experimental")) - { - foreach my $proto ((@tls, @dtls)) - { - if ($1 eq "$proto-method") - { - $disabled{"$proto"} = "option($proto-method)"; - last; - } - } - if ($1 eq "dtls") - { - foreach my $proto (@dtls) - { - $disabled{$proto} = "option(dtls)"; - } - } - elsif ($1 eq "ssl") - { - # Last one of its kind - $disabled{"ssl3"} = "option(ssl)"; - } - elsif ($1 eq "tls") - { - # XXX: Tests will fail if all SSL/TLS - # protocols are disabled. - foreach my $proto (@tls) - { - $disabled{$proto} = "option(tls)"; - } - } - else - { - $disabled{$1} = "option"; - } - } + foreach my $proto ((@tls, @dtls)) + { + if ($1 eq "$proto-method") + { + $disabled{"$proto"} = "option($proto-method)"; + last; + } + } + if ($1 eq "dtls") + { + foreach my $proto (@dtls) + { + $disabled{$proto} = "option(dtls)"; + } + } + elsif ($1 eq "ssl") + { + # Last one of its kind + $disabled{"ssl3"} = "option(ssl)"; + } + elsif ($1 eq "tls") + { + # XXX: Tests will fail if all SSL/TLS + # protocols are disabled. + foreach my $proto (@tls) + { + $disabled{$proto} = "option(tls)"; + } + } + elsif ($1 eq "static-engine") + { + delete $disabled{"dynamic-engine"}; + } + elsif ($1 eq "dynamic-engine") + { + $disabled{"dynamic-engine"} = "option"; + } + else + { + $disabled{$1} = "option"; + } } - elsif (/^enable-(.+)$/ || /^experimental-(.+)$/) + elsif (/^enable-(.+)$/) { + if ($1 eq "static-engine") + { + $disabled{"dynamic-engine"} = "option"; + } + elsif ($1 eq "dynamic-engine") + { + delete $disabled{"dynamic-engine"}; + } my $algo = $1; - if ($disabled{$algo} eq "experimental") - { - die "You are requesting an experimental feature; please say 'experimental-$algo' if you are sure\n" - unless (/^experimental-/); - push @experimental, $algo; - } delete $disabled{$algo}; $threads = 1 if ($algo eq "threads"); @@ -597,9 +617,15 @@ foreach (@argvcopy) } elsif (/^[-+]/) { - if (/^--prefix=(.*)$/) + if (/^--unified$/) + { + $unified=1; + } + elsif (/^--prefix=(.*)$/) { $config{prefix}=$1; + die "Directory given with --prefix MUST be absolute\n" + unless file_name_is_absolute($config{prefix}); } elsif (/^--api=(.*)$/) { @@ -613,17 +639,13 @@ foreach (@argvcopy) { $config{openssldir}=$1; } - elsif (/^--install.prefix=(.*)$/) - { - $config{install_prefix}=$1; - } elsif (/^--with-zlib-lib=(.*)$/) { - $withargs{"zlib-lib"}=$1; + $withargs{zlib_lib}=$1; } elsif (/^--with-zlib-include=(.*)$/) { - $withargs{"zlib-include"}="-I$1"; + $withargs{zlib_include}="-I$1"; } elsif (/^--with-fipslibdir=(.*)$/) { @@ -645,17 +667,16 @@ foreach (@argvcopy) { $libs.=$_." "; } + elsif (/^-D(.*)$/) + { + push @user_defines, $1; + } else # common if (/^[-+]/), just pass down... { $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei; - $flags.=$_." "; + $user_cflags.=" ".$_; } } - elsif ($_ =~ /^([^:]+):(.+)$/) - { - eval "\$table{\$1} = \"$2\""; # allow $xxx constructs in the string - $target=$1; - } else { die "target already defined - $target (offending arg: $_)\n" if ($target ne ""); @@ -678,6 +699,11 @@ foreach (@argvcopy) die "***** Unsupported api compatibility level: $config{api}\n", } + if (keys %deprecated_options) + { + warn "***** Deprecated options: ", + join(", ", keys %deprecated_options), "\n"; + } if (keys %unsupported_options) { die "***** Unsupported options: ", @@ -743,40 +769,45 @@ foreach (sort (keys %disabled)) printf " no-%-12s %-10s", $_, "[$disabled{$_}]"; if (/^dso$/) - { $no_dso = 1; } + { } elsif (/^threads$/) - { $no_threads = 1; } + { } elsif (/^shared$/) - { $config{no_shared} = 1; } + { } + elsif (/^pic$/) + { } elsif (/^zlib$/) - { $zlib = 0; } - elsif (/^static-engine$/) + { } + elsif (/^dynamic-engine$/) { } elsif (/^zlib-dynamic$/) { } elsif (/^sse2$/) { $no_sse2 = 1; } elsif (/^engine$/) - { @{$config{dirs}} = grep !/^engine$/, @{$config{dirs}}; } + { + @{$config{dirs}} = grep !/^engines$/, @{$config{dirs}}; + @{$config{sdirs}} = grep !/^engine$/, @{$config{sdirs}}; + push @{$config{openssl_other_defines}}, "OPENSSL_NO_ENGINE"; + } else { my ($ALGO, $algo); ($ALGO = $algo = $_) =~ tr/[\-a-z]/[_A-Z]/; - if (/^asm$/ || /^err$/ || /^hw$/ || /^hw-/) + if (/^asm$/ || /^err$/ || /^hw$/ || /^hw-/ || /^async$/ + || /^autoalginit/ || /^autoerrinit/) { push @{$config{openssl_other_defines}}, "OPENSSL_NO_$ALGO"; print " OPENSSL_NO_$ALGO"; - if (/^err$/) { $flags .= "-DOPENSSL_NO_ERR "; } - elsif (/^asm$/) { $no_asm = 1; } + if (/^err$/) { push @user_defines, "OPENSSL_NO_ERR"; } } else { ($ALGO,$algo) = ("RMD160","rmd160") if ($algo eq "ripemd"); push @{$config{openssl_algorithm_defines}}, "OPENSSL_NO_$ALGO"; - $config{depflags} .= " -DOPENSSL_NO_$ALGO"; print " OPENSSL_NO_$ALGO"; # fix-up crypto/directory name(s) @@ -791,18 +822,6 @@ foreach (sort (keys %disabled)) print "\n"; } -my $exp_cflags = ""; - -foreach (sort @experimental) - { - my $ALGO; - ($ALGO = $_) =~ tr/[a-z]/[A-Z]/; - - # opensslconf.h will set OPENSSL_NO_... unless OPENSSL_EXPERIMENTAL_... is defined - push @{$config{openssl_experimental_defines}}, "OPENSSL_NO_$ALGO"; - $exp_cflags .= " -DOPENSSL_EXPERIMENTAL_$ALGO"; - } - print "Configuring for $target\n"; # Support for legacy targets having a name starting with 'debug-' @@ -817,15 +836,26 @@ if ($d) { } $config{target} = $target; delete $table{$base_target}->{template}; # or the next test will fail. -my %target = ( %{$table{$base_target}}, resolve_config($target) ); +my %target = resolve_config($target); &usage if (!%target || $target{template}); +# Set up defaults +my %target = ( %{$table{$base_target}}, %target ); + $target{exe_extension}=""; -$target{exe_extension}=".exe" if ($config{target} eq "Cygwin" || $config{target} eq "DJGPP" || $config{target} =~ /^mingw/); +$target{exe_extension}=".exe" if ($config{target} eq "DJGPP" + || $config{target} =~ /^(?:Cygwin|mingw)/); $target{exe_extension}=".nlm" if ($config{target} =~ /netware/); $target{exe_extension}=".pm" if ($config{target} =~ /vos/); +($target{shared_extension_simple}=$target{shared_extension}) + =~ s|\.\$\(SHLIB_MAJOR\)\.\$\(SHLIB_MINOR\)||; +$target{dso_extension}=$target{shared_extension_simple}; +($target{shared_import_extension}=$target{shared_extension_simple}.".a") + if ($config{target} =~ /^(?:Cygwin|mingw)/); + + $default_ranlib = which("ranlib") || "true"; $config{perl} = $ENV{'PERL'} || which("perl5") || which("perl") || "perl"; my $make = $ENV{'MAKE'} || "make"; @@ -833,22 +863,26 @@ my $make = $ENV{'MAKE'} || "make"; $config{cross_compile_prefix} = $ENV{'CROSS_COMPILE'} if $config{cross_compile_prefix} eq ""; -$config{prefix} = "/usr/local" if !$config{prefix}; -$config{openssldir} = "ssl" if !$config{openssldir}; -$config{openssldir} = catdir($config{prefix}, $config{openssldir}) - unless file_name_is_absolute($config{openssldir}); - # Allow environment CC to override compiler... $target{cc} = $ENV{CC} || $target{cc}; -# For cflags and lflags, add the debug_ or release_ attributes +# For cflags, lflags, plib_lflags, ex_libs and defines, add the debug_ +# or release_ attributes. # Do it in such a way that no spurious space is appended (hence the grep). +$config{defines} = [ @{$target{defines}}, + @{$target{$build_prefix."defines"}} ]; $config{cflags} = join(" ", grep { $_ ne "" } ($target{cflags}, $target{$build_prefix."cflags"})); $config{lflags} = join(" ", grep { $_ ne "" } ($target{lflags}, $target{$build_prefix."lflags"})); +$config{plib_lflags} = join(" ", + grep { $_ ne "" } ($target{plib_lflags}, + $target{$build_prefix."plib_lflags"})); +$config{ex_libs} = join(" ", + grep { $_ ne "" } ($target{ex_libs}, + $target{$build_prefix."ex_libs"})); $target{ranlib} = $ENV{'RANLIB'} || $target{ranlib} || $default_ranlib; $target{ar} = $ENV{'AR'} || "ar"; @@ -858,29 +892,26 @@ $target{nm} = "nm"; $target{build_scheme} = [ $target{build_scheme} ] if ref($target{build_scheme}) ne "ARRAY"; -# if $config{prefix}/lib$target{multilib} is not an existing directory, then -# assume that it's not searched by linker automatically, in -# which case adding $target{multilib} suffix causes more grief than -# we're ready to tolerate, so don't... -$target{multilib}="" if !-d "$config{prefix}/lib$target{multilib}"; - -$config{libdir}="lib$target{multilib}" if $config{libdir} eq ""; -$config{enginesdir}=$config{prefix} . "/" . $config{libdir} . "/engines"; - -$config{cflags} .= "$exp_cflags"; +###### TO BE REMOVED BEFORE FINAL RELEASE +###### +###### If the user has chosen --unified, we give it to them. +###### The same happens if we detect that they try to build out-of-source. +if ($target{build_file} eq "Makefile" + && $target{build_scheme}->[0] eq "unixmake" + && ($unified || $srcdir ne $blddir)) { + $target{build_scheme} = [ "unified", "unix" ]; +} -# '%' in $config{lflags} is used to split flags to "pre-" and post-flags -my ($pre,$post)=split('%',$config{lflags}); -if (defined($post)) { $config{prelflags}=$pre; $config{lflags}=$post; } -else { $config{prelflags}=""; $config{lflags}=$pre; } +my ($builder, $builder_platform, @builder_opts) = + @{$target{build_scheme}}; -if ($target =~ /^mingw/ && `$target{cc} --target-help 2>&1` !~ m/-mno-cygwin/m) +if ($target =~ /^mingw/ && `$target{cc} --target-help 2>&1` =~ m/-mno-cygwin/m) { - $config{cflags} =~ s/-mno-cygwin\s*//; - $target{shared_ldflag} =~ s/-mno-cygwin\s*//; + $config{cflags} .= " -mno-cygwin"; + $target{shared_ldflag} .= " -mno-cygwin"; } -if ($target =~ /linux.*-mips/ && !$no_asm && $flags !~ /-m(ips|arch=)/) { +if ($target =~ /linux.*-mips/ && !$disabled{asm} && $user_cflags !~ /-m(ips|arch=)/) { # minimally required architecture flags for assembly modules $config{cflags}="-mips2 $config{cflags}" if ($target =~ /mips32/); $config{cflags}="-mips3 $config{cflags}" if ($target =~ /mips64/); @@ -888,9 +919,7 @@ if ($target =~ /linux.*-mips/ && !$no_asm && $flags !~ /-m(ips|arch=)/) { my $no_shared_warn=0; my $no_user_cflags=0; - -if ($flags ne "") { $config{cflags}="$flags$config{cflags}"; } -else { $no_user_cflags=1; } +my $no_user_defines=0; # The DSO code currently always implements all functions so that no # applications will have to worry about that from a compilation point @@ -898,28 +927,28 @@ else { $no_user_cflags=1; } # has support compiled in for them. Currently each method is enabled # by a define "DSO_" ... we translate the "dso_scheme" config # string entry into using the following logic; -my $dso_cflags; -if (!$no_dso && $target{dso_scheme} ne "") +if (!$disabled{dso} && $target{dso_scheme} ne "") { $target{dso_scheme} =~ tr/[a-z]/[A-Z]/; if ($target{dso_scheme} eq "DLFCN") { - $dso_cflags = "-DDSO_DLFCN -DHAVE_DLFCN_H"; + $config{defines} = [ "DSO_DLFCN", "HAVE_DLFCN_H", + @{$config{defines}} ] } elsif ($target{dso_scheme} eq "DLFCN_NO_H") { - $dso_cflags = "-DDSO_DLFCN"; + $config{defines} = [ "DSO_DLFCN", @{$config{defines}} ] } else { - $dso_cflags = "-DDSO_$target{dso_scheme}"; + $config{defines} = [ "DSO_$target{dso_scheme}", + @{$config{defines}} ] } - $config{cflags} = "$dso_cflags $config{cflags}"; } -my $thread_cflags; +my $thread_cflags = ""; my @thread_defines; -if ($target{thread_cflag} ne "(unknown)" && !$no_threads) +if ($target{thread_cflag} ne "(unknown)" && !$disabled{threads}) { # If we know how to do it, support threads by default. $threads = 1; @@ -929,60 +958,52 @@ if ($target{thread_cflag} eq "(unknown)" && $threads) # If the user asked for "threads", [s]he is also expected to # provide any system-dependent compiler options that are # necessary. - if ($no_user_cflags) + if ($no_user_cflags && $no_user_defines) { print "You asked for multi-threading support, but didn't\n"; print "provide any system-specific compiler options\n"; exit(1); } - $thread_cflags="-DOPENSSL_THREADS $config{cflags}" ; push @thread_defines, "OPENSSL_THREADS"; } else { - $thread_cflags="-DOPENSSL_THREADS $target{thread_cflag} $config{cflags}"; - push @thread_defines, "OPENSSL_THREADS"; -# my $def; -# foreach $def (split ' ',$target{thread_cflag}) -# { -# if ($def =~ s/^-D// && $def !~ /^_/) -# { -# push @thread_defines, "$def"; -# } -# } + $thread_cflags=" $target{thread_cflag}"; + push @thread_defines, @{$target{thread_defines}}, "OPENSSL_THREADS"; } -$config{lflags}="$libs$config{lflags}" if ($libs ne ""); +$config{ex_libs}="$libs$config{ex_libs}" if ($libs ne ""); -if ($no_asm) +if ($disabled{asm}) { - $config{cflags}=~s/-D[BL]_ENDIAN// if ($config{fips}); - $thread_cflags=~s/-D[BL]_ENDIAN// if ($config{fips}); + @{$config{defines}} = grep !/^[BL]_ENDIAN$/, @{$config{defines}} + if ($config{fips}); } if ($threads) { - $config{cflags}=$thread_cflags; + $config{cflags} = "$thread_cflags $config{cflags}" if $thread_cflags; + push @{$config{defines}}, @thread_defines; push @{$config{openssl_thread_defines}}, @thread_defines; } -if ($zlib) +unless ($disabled{zlib}) { - $config{cflags} = "-DZLIB $config{cflags}"; + push @{$config{defines}}, "ZLIB"; if (defined($disabled{"zlib-dynamic"})) { - if (defined($withargs{"zlib-lib"})) + if (defined($withargs{zlib_lib})) { - $config{lflags} .= " -L" . $withargs{"zlib-lib"} . " -lz"; + $config{ex_libs} .= " -L" . $withargs{zlib_lib} . " -lz"; } else { - $config{lflags} .= " -lz"; + $config{ex_libs} .= " -lz"; } } else { - $config{cflags} = "-DZLIB_SHARED $config{cflags}"; + push @{$config{defines}}, "ZLIB_SHARED"; } } @@ -993,83 +1014,39 @@ if (defined($disabled{"deprecated"})) { if ($target{shared_target} eq "") { - $no_shared_warn = 1 if !$config{no_shared} && !$config{fips}; - $config{no_shared} = 1; - } -if (!$config{no_shared}) - { - if ($target{shared_cflag} ne "") - { - $config{cflags} = "$target{shared_cflag} -DOPENSSL_PIC $config{cflags}"; - } + $no_shared_warn = 1 + if ((!$disabled{shared} || !$disabled{"dynamic-engine"}) + && !$config{fips}); + $disabled{shared} = "no-shared-target"; + $disabled{pic} = $disabled{shared} = $disabled{"dynamic-engine"} = + "no-shared-target"; } -if ($target{build_scheme}->[0] ne "mk1mf") - { - # add {no-}static-engine to options to allow mkdef.pl to work without extra arguments - if ($config{no_shared}) - { - push @{$config{openssl_other_defines}}, "OPENSSL_NO_DYNAMIC_ENGINE"; - $config{options}.=" static-engine"; - } - else - { - push @{$config{openssl_other_defines}}, "OPENSSL_NO_STATIC_ENGINE"; - $config{options}.=" no-static-engine"; - } - } +if ($disabled{"dynamic-engine"}) { + push @{$config{defines}}, "OPENSSL_NO_DYNAMIC_ENGINE"; + $config{dynamic_engines} = 0; +} else { + push @{$config{defines}}, "OPENSSL_NO_STATIC_ENGINE"; + $config{dynamic_engines} = 1; +} # # Platform fix-ups # -if ($target =~ /-icc$/) # Intel C compiler + +# This saves the build files from having to check +if ($disabled{pic}) { - my $iccver=0; - if (open(FD,"$target{cc} -V 2>&1 |")) - { - while() { $iccver=$1 if (/Version ([0-9]+)\./); } - close(FD); - } - if ($iccver>=8) - { - $config{cflags}=~s/-KPIC/-fPIC/; - # Eliminate unnecessary dependency from libirc.a. This is - # essential for shared library support, as otherwise - # apps/openssl can end up in endless loop upon startup... - $config{cflags}.=" -Dmemcpy=__builtin_memcpy -Dmemset=__builtin_memset"; - } - if ($iccver>=9) - { - $config{lflags}.=" -i-static"; - $config{lflags}=~s/-no_cpprt/-no-cpprt/; - } - if ($iccver>=10) - { - $config{lflags}=~s/-i-static/-static-intel/; - } - if ($iccver>=11) - { - $config{cflags}.=" -no-intel-extensions"; # disable Cilk - $config{lflags}=~s/-no-cpprt/-no-cxxlib/; - } + $target{shared_cflag} = $target{shared_ldflag} = + $target{shared_rcflag} = ""; } - -# Unlike other OSes (like Solaris, Linux, Tru64, IRIX) BSD run-time -# linkers (tested OpenBSD, NetBSD and FreeBSD) "demand" RPATH set on -# .so objects. Apparently application RPATH is not global and does -# not apply to .so linked with other .so. Problem manifests itself -# when libssl.so fails to load libcrypto.so. One can argue that we -# should engrave this into Makefile.shared rules or into BSD-* config -# lines above. Meanwhile let's try to be cautious and pass -rpath to -# linker only when --prefix is not /usr. -if ($target =~ /^BSD-/) +else { - $target{shared_ldflag}.=" -Wl,-rpath,\$\$(LIBRPATH)" if ($config{prefix} !~ m|^/usr[/]*$|); + push @{$config{defines}}, "OPENSSL_PIC"; } if ($target{sys_id} ne "") { - #$config{cflags}="-DOPENSSL_SYS_$target{sys_id} $config{cflags}"; push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}"; } @@ -1078,150 +1055,102 @@ if ($target{ranlib} eq "") $target{ranlib} = $default_ranlib; } -if (!$no_asm) { - $target{cpuid_obj}=$table{BASE}->{cpuid_obj} if ($config{processor} eq "386"); - $target{cpuid_obj}.=" uplink.o uplink-x86.o" if ($config{cflags} =~ /-DOPENSSL_USE_APPLINK/); - - $target{bn_obj} =~ s/\w+-gf2m.o// if (defined($disabled{ec2m})); +unless ($disabled{asm}) { + $target{cpuid_asm_src}=$table{BASE}->{cpuid_asm_src} if ($config{processor} eq "386"); + $target{bn_asm_src} =~ s/\w+-gf2m.c// if (defined($disabled{ec2m})); # bn-586 is the only one implementing bn_*_part_words - $config{cflags}.=" -DOPENSSL_BN_ASM_PART_WORDS" if ($target{bn_obj} =~ /bn-586/); - $config{cflags}.=" -DOPENSSL_IA32_SSE2" if (!$no_sse2 && $target{bn_obj} =~ /86/); + push @{$config{defines}}, "OPENSSL_BN_ASM_PART_WORDS" if ($target{bn_asm_src} =~ /bn-586/); + push @{$config{defines}}, "OPENSSL_IA32_SSE2" if (!$no_sse2 && $target{bn_asm_src} =~ /86/); - $config{cflags}.=" -DOPENSSL_BN_ASM_MONT" if ($target{bn_obj} =~ /-mont/); - $config{cflags}.=" -DOPENSSL_BN_ASM_MONT5" if ($target{bn_obj} =~ /-mont5/); - $config{cflags}.=" -DOPENSSL_BN_ASM_GF2m" if ($target{bn_obj} =~ /-gf2m/); + push @{$config{defines}}, "OPENSSL_BN_ASM_MONT" if ($target{bn_asm_src} =~ /-mont/); + push @{$config{defines}}, "OPENSSL_BN_ASM_MONT5" if ($target{bn_asm_src} =~ /-mont5/); + push @{$config{defines}}, "OPENSSL_BN_ASM_GF2m" if ($target{bn_asm_src} =~ /-gf2m/); if ($config{fips}) { push @{$config{openssl_other_defines}}, "OPENSSL_FIPS"; } - if ($target{sha1_obj} =~ /\.o$/) { - $config{cflags}.=" -DSHA1_ASM" if ($target{sha1_obj} =~ /sx86/ || $target{sha1_obj} =~ /sha1/); - $config{cflags}.=" -DSHA256_ASM" if ($target{sha1_obj} =~ /sha256/); - $config{cflags}.=" -DSHA512_ASM" if ($target{sha1_obj} =~ /sha512/); - if ($target{sha1_obj} =~ /sse2/) { - if ($no_sse2) { - $target{sha1_obj} =~ s/\S*sse2\S+//; - } elsif ($config{cflags} !~ /OPENSSL_IA32_SSE2/) { - $config{cflags}.=" -DOPENSSL_IA32_SSE2"; - } - } + if ($target{sha1_asm_src}) { + push @{$config{defines}}, "SHA1_ASM" if ($target{sha1_asm_src} =~ /sx86/ || $target{sha1_asm_src} =~ /sha1/); + push @{$config{defines}}, "SHA256_ASM" if ($target{sha1_asm_src} =~ /sha256/); + push @{$config{defines}}, "SHA512_ASM" if ($target{sha1_asm_src} =~ /sha512/); } - if ($target{md5_obj} =~ /\.o$/) { - $config{cflags}.=" -DMD5_ASM"; + if ($target{md5_asm_src}) { + push @{$config{defines}}, "MD5_ASM"; } - $target{cast_obj}=$table{BASE}->{cast_obj} if (!$config{no_shared}); # CAST assembler is not PIC - if ($target{rmd160_obj} =~ /\.o$/) { - $config{cflags}.=" -DRMD160_ASM"; + $target{cast_asm_src}=$table{BASE}->{cast_asm_src} unless $disabled{pic}; # CAST assembler is not PIC + if ($target{rmd160_asm_src}) { + push @{$config{defines}}, "RMD160_ASM"; } - if ($target{aes_obj} =~ /\.o$/) { - $config{cflags}.=" -DAES_ASM" if ($target{aes_obj} =~ m/\baes-/);; - # aes-ctr.o is not a real file, only indication that assembler + if ($target{aes_asm_src}) { + push @{$config{defines}}, "AES_ASM" if ($target{aes_asm_src} =~ m/\baes-/);; + # aes-ctr.fake is not a real file, only indication that assembler # module implements AES_ctr32_encrypt... - $config{cflags}.=" -DAES_CTR_ASM" if ($target{aes_obj} =~ s/\s*aes-ctr\.o//); - # aes-xts.o indicates presence of AES_xts_[en|de]crypt... - $config{cflags}.=" -DAES_XTS_ASM" if ($target{aes_obj} =~ s/\s*aes-xts\.o//); - $target{aes_obj} =~ s/\s*(vpaes|aesni)-x86\.o//g if ($no_sse2); - $config{cflags}.=" -DVPAES_ASM" if ($target{aes_obj} =~ m/vpaes/); - $config{cflags}.=" -DBSAES_ASM" if ($target{aes_obj} =~ m/bsaes/); + push @{$config{defines}}, "AES_CTR_ASM" if ($target{aes_asm_src} =~ s/\s*aes-ctr\.fake//); + # aes-xts.fake indicates presence of AES_xts_[en|de]crypt... + push @{$config{defines}}, "AES_XTS_ASM" if ($target{aes_asm_src} =~ s/\s*aes-xts\.fake//); + $target{aes_asm_src} =~ s/\s*(vpaes|aesni)-x86\.s//g if ($no_sse2); + push @{$config{defines}}, "VPAES_ASM" if ($target{aes_asm_src} =~ m/vpaes/); + push @{$config{defines}}, "BSAES_ASM" if ($target{aes_asm_src} =~ m/bsaes/); } - if ($target{wp_obj} =~ /mmx/ && $config{processor} eq "386") { - $target{wp_obj}=$table{BASE}->{wp_obj}; - } elsif (!$disabled{"whirlpool"}) { - $config{cflags}.=" -DWHIRLPOOL_ASM"; + if ($target{wp_asm_src} =~ /mmx/) { + if ($config{processor} eq "386") { + $target{wp_asm_src}=$table{BASE}->{wp_asm_src}; + } elsif (!$disabled{"whirlpool"}) { + $config{cflags}.=" -DWHIRLPOOL_ASM"; + } } - if ($target{modes_obj} =~ /ghash-/) { - $config{cflags}.=" -DGHASH_ASM"; + if ($target{modes_asm_src} =~ /ghash-/) { + push @{$config{defines}}, "GHASH_ASM"; } - if ($target{ec_obj} =~ /ecp_nistz256/) { - $config{cflags}.=" -DECP_NISTZ256_ASM"; + if ($target{ec_asm_src} =~ /ecp_nistz256/) { + push @{$config{defines}}, "ECP_NISTZ256_ASM"; } - if ($target{poly1305_obj} =~ /\.o$/) { - $config{cflags}.=" -DPOLY1305_ASM"; + if ($target{poly1305_asm_src} ne "") { + push @{$config{defines}}, "POLY1305_ASM"; } } -$config{makedepprog} = "makedepend"; -if ($target{cc} eq "gcc" || ($target{cc} eq 'cc' && $config{target} =~ /darwin/)) { - $config{makedepprog} = $target{cc}; -} -# On different platforms, shared library suffixes takes interesting forms. -# On Most Unixen, it's .so.{version} or .sl.{version}, while on MacOS X, -# it's .{version}.dylib. We're want to separate the two so we can calculate -# symlinks. -# FIXME: is this actually needed any more? Makefile.shared seems to just -# symlink a file name without SOVER to the file with full SOVER, nothing in -# between. -if ($target{shared_extension} =~ /^(|(?\.s[ol])(?\..*)|(?\..*)(?\.dylib))$/) { - my @vernums = split /\./, $+{v}; - shift @vernums; # Because the initial period in shlib_extension. - my @s = (); - while (@vernums) { - pop @vernums; - push @s, join(".", $+{e} eq ".dylib" ? "" : $+{e}, - @vernums, - $+{e} eq ".dylib" ? $+{e} : () ); +my $ecc = $target{cc}; +if ($^O ne "VMS") { + # Is the compiler gcc or clang? $ecc is used below to see if + # error-checking can be turned on. + my $ccpcc = "$config{cross_compile_prefix}$target{cc}"; + $config{makedepprog} = 'makedepend'; + open(PIPE, "$ccpcc --version 2>&1 | head -2 |"); + while ( ) { + $config{makedepprog} = $ccpcc if /clang|gcc/; + $ecc = "clang" if /clang/; + $ecc = "gcc" if /gcc/; } - $config{shared_link_extensions} = join(" ", @s); -} else { - $config{shared_link_extensions} = ""; + close(PIPE); } -$config{depflags} =~ s/^\s*//; # Deal with bn_ops ################################################### -$config{des_ptr} =0; -$config{des_risc1} =0; -$config{des_risc2} =0; -$config{des_unroll} =0; $config{bn_ll} =0; -$config{rc4_idx} =0; -$config{bf_ptr} =0; $config{export_var_as_fn} =0; my $def_int="unsigned int"; $config{rc4_int} =$def_int; -$config{rc4_chunk} =""; -$config{md2_int} =$def_int; -$config{idea_int} =$def_int; -$config{rc2_int} =$def_int; -($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8})=(0,0,1,0,0); - -$config{des_int} = "unsigned long"; +($config{b64l},$config{b64},$config{b32})=(0,0,1); +my $count = 0; foreach (sort split(/\s+/,$target{bn_ops})) { - $config{des_ptr}=1 if /DES_PTR/; - $config{des_risc1}=1 if /DES_RISC1/; - $config{des_risc2}=1 if /DES_RISC2/; - $config{des_unroll}=1 if /DES_UNROLL/; - $config{des_int}="unsigned int" if /DES_INT/; - $config{bn_ll}=1 if /BN_LLONG/; - $config{rc4_int}="unsigned char" if /RC4_CHAR/; - $config{rc4_int}="unsigned long" if /RC4_LONG/; - $config{rc4_idx}=1 if /RC4_INDEX/; - $config{rc4_chunk}="unsigned long" if /RC4_CHUNK/; - $config{rc4_chunk}="unsigned long long" if /RC4_CHUNK_LL/; - $config{md2_int}="unsigned char" if /MD2_CHAR/; - $config{md2_int}="unsigned long" if /MD2_LONG/; - $config{idea_int}="unsigned char" if /IDEA_CHAR/; - $config{idea_int}="unsigned long" if /IDEA_LONG/; - $config{rc2_int}="unsigned char" if /RC2_CHAR/; - $config{rc2_int}="unsigned long" if /RC2_LONG/; - $config{bf_ptr}=1 if $_ eq "BF_PTR"; - $config{bf_ptr}=2 if $_ eq "BF_PTR2"; - ($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8}) - =(0,1,0,0,0) if /SIXTY_FOUR_BIT/; - ($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8}) - =(1,0,0,0,0) if /SIXTY_FOUR_BIT_LONG/; - ($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8}) - =(0,0,1,0,0) if /THIRTY_TWO_BIT/; - ($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8}) - =(0,0,0,1,0) if /SIXTEEN_BIT/; - ($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8}) - =(0,0,0,0,1) if /EIGHT_BIT/; - $config{export_var_as_fn}=1 if /EXPORT_VAR_AS_FN/; + $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/; + $config{export_var_as_fn}=1 if $_ eq 'EXPORT_VAR_AS_FN'; + $config{bn_ll}=1 if $_ eq 'BN_LLONG'; + $config{rc4_int}="unsigned char" if $_ eq 'RC4_CHAR'; + ($config{b64l},$config{b64},$config{b32}) + =(0,1,0) if $_ eq 'SIXTY_FOUR_BIT'; + ($config{b64l},$config{b64},$config{b32}) + =(1,0,0) if $_ eq 'SIXTY_FOUR_BIT_LONG'; + ($config{b64l},$config{b64},$config{b32}) + =(0,0,1) if $_ eq 'THIRTY_TWO_BIT'; } +die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n" + if $count > 1; # Hack cflags for better warnings (dev option) ####################### @@ -1232,42 +1161,437 @@ $config{cflags} =~ s/([\\\"])/\\\1/g; if (defined($config{api})) { $config{openssl_api_defines} = [ "OPENSSL_MIN_API=".$apitable->{$config{api}} ]; - my $apiflag = sprintf("-DOPENSSL_API_COMPAT=%s", $apitable->{$config{api}}); - $default_depflags .= " $apiflag"; - $config{cflags} .= " $apiflag"; + my $apiflag = sprintf("OPENSSL_API_COMPAT=%s", $apitable->{$config{api}}); + push @{$config{defines}}, $apiflag; } -my $ecc = $target{cc}; -$ecc = "clang" if `$target{cc} --version 2>&1` =~ /clang/; - if ($strict_warnings) { my $wopt; - die "ERROR --strict-warnings requires gcc or clang" unless ($ecc =~ /gcc(-\d(\.\d)*)?$/ or $ecc =~ /clang$/); + die "ERROR --strict-warnings requires gcc or clang" + unless $ecc eq 'gcc' || $ecc eq 'clang'; foreach $wopt (split /\s+/, $gcc_devteam_warn) { - $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(^|\s)$wopt(\s|$)/) + $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/) } if ($ecc eq "clang") { foreach $wopt (split /\s+/, $clang_devteam_warn) { - $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(^|\s)$wopt(\s|$)/) + $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/) } } - if ($target !~ /^mingw/) + } + +unless ($disabled{"crypto-mdebug-backtrace"}) + { + foreach my $wopt (split /\s+/, $memleak_devteam_backtrace) { - foreach $wopt (split /\s+/, $memleak_devteam_backtrace) - { - $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(^|\s)$wopt(\s|$)/) - } - if ($target =~ /^BSD-/) - { - $config{lflags} .= " -lexecinfo"; - } + $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/) + } + if ($target =~ /^BSD-/) + { + $config{ex_libs} .= " -lexecinfo"; } } +if ($user_cflags ne "") { $config{cflags}="$config{cflags}$user_cflags"; } +else { $no_user_cflags=1; } +if (@user_defines) { $config{defines}=[ @{$config{defines}}, @user_defines ]; } +else { $no_user_defines=1; } + +# ALL MODIFICATIONS TO %config and %target MUST BE DONE FROM HERE ON + +# If we use the unified build, collect information from build.info files +my %unified_info = (); + +if ($builder eq "unified") { + # Store the name of the template file we will build the build file from + # in %config. This may be useful for the build file itself. + my $build_file_template = + catfile($srcdir, "Configurations", + $builder_platform."-".$target{build_file}.".tmpl"); + $build_file_template = + catfile($srcdir, "Configurations", $target{build_file}.".tmpl") + if (! -f $build_file_template); + $config{build_file_template} = $build_file_template; + + use lib catdir(dirname(__FILE__),"util"); + use with_fallback qw(Text::Template); + + sub cleandir { + my $base = shift; + my $dir = shift; + my $relativeto = shift || "."; + + $dir = catdir($base,$dir) unless isabsolute($dir); + + # Make sure the directories we're building in exists + mkpath($dir); + + my $res = abs2rel(absolutedir($dir), rel2abs($relativeto)); + #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n"; + return $res; + } + + sub cleanfile { + my $base = shift; + my $file = shift; + my $relativeto = shift || "."; + + $file = catfile($base,$file) unless isabsolute($file); + + my $d = dirname($file); + my $f = basename($file); + + # Make sure the directories we're building in exists + mkpath($d); + + my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto)); + #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n"; + return $res; + } + + my @build_infos = ( [ ".", "build.info" ] ); + foreach (@{$config{dirs}}) { + push @build_infos, [ $_, "build.info" ] + if (-f catfile($srcdir, $_, "build.info")); + } + foreach (@{$config{sdirs}}) { + push @build_infos, [ catdir("crypto", $_), "build.info" ] + if (-f catfile($srcdir, "crypto", $_, "build.info")); + } + foreach (@{$config{engdirs}}) { + push @build_infos, [ catdir("engines", $_), "build.info" ] + if (-f catfile($srcdir, "engines", $_, "build.info")); + } + + $config{build_infos} = [ ]; + + foreach (@build_infos) { + my $sourced = catdir($srcdir, $_->[0]); + my $buildd = catdir($blddir, $_->[0]); + + mkpath($buildd); + + my $f = $_->[1]; + # The basic things we're trying to build + my @programs = (); + my @libraries = (); + my @engines = (); + my @scripts = (); + my @extra = (); + my @intermediates = (); + my @rawlines = (); + + my %ordinals = (); + my %sources = (); + my %includes = (); + my %depends = (); + my %renames = (); + my %sharednames = (); + + push @{$config{build_infos}}, catfile(abs2rel($sourced, $blddir), $f); + my $template = Text::Template->new(TYPE => 'FILE', + SOURCE => catfile($sourced, $f)); + die "Something went wrong with $sourced/$f: $!\n" unless $template; + my @text = + split /^/m, + $template->fill_in(HASH => { config => \%config, + target => \%target, + disabled => \%disabled, + builddir => abs2rel($buildd, $blddir), + sourcedir => abs2rel($sourced, $blddir), + buildtop => abs2rel($blddir, $blddir), + sourcetop => abs2rel($srcdir, $blddir) }, + DELIMITERS => [ "{-", "-}" ]); + + # The top item of this stack has the following values + # -2 positive already run and we found ELSE (following ELSIF should fail) + # -1 positive already run (skip until ENDIF) + # 0 negatives so far (if we're at a condition, check it) + # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF) + # 2 positive ELSE (following ELSIF should fail) + my @skip = (); + collect_information( + collect_from_array([ @text ], + qr/\\$/ => sub { my $l1 = shift; my $l2 = shift; + $l1 =~ s/\\$//; $l1.$l2 }), + # Info we're looking for + qr/^\s*IF\[((?:\\.|[^\\\]])*)\]\s*$/ + => sub { push @skip, !! $1; }, + qr/^\s*ELSIF\[((?:\\.|[^\\\]])*)\]\s*$/ + => sub { die "ELSIF out of scope" if ! @skip; + die "ELSIF following ELSE" if abs($skip[$#skip]) == 2; + $skip[$#skip] = -1 if $skip[$#skip] != 0; + $skip[$#skip] = !! $1 + if $skip[$#skip] == 0; }, + qr/^\s*ELSE\s*$/ + => sub { die "ELSE out of scope" if ! @skip; + $skip[$#skip] = -2 if $skip[$#skip] != 0; + $skip[$#skip] = 2 if $skip[$#skip] == 0; }, + qr/^\s*ENDIF\s*$/ + => sub { die "ENDIF out of scope" if ! @skip; + pop @skip; }, + qr/^\s*PROGRAMS\s*=\s*(.*)\s*$/ + => sub { push @programs, split(/\s+/, $1) + if !@skip || $skip[$#skip] > 0 }, + qr/^\s*LIBS\s*=\s*(.*)\s*$/ + => sub { push @libraries, split(/\s+/, $1) + if !@skip || $skip[$#skip] > 0 }, + qr/^\s*ENGINES\s*=\s*(.*)\s*$/ + => sub { push @engines, split(/\s+/, $1) + if !@skip || $skip[$#skip] > 0 }, + qr/^\s*SCRIPTS\s*=\s*(.*)\s*$/ + => sub { push @scripts, split(/\s+/, $1) + if !@skip || $skip[$#skip] > 0 }, + qr/^\s*EXTRA\s*=\s*(.*)\s*$/ + => sub { push @extra, split(/\s+/, $1) + if !@skip || $skip[$#skip] > 0 }, + + qr/^\s*ORDINALS\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/, + => sub { push @{$ordinals{$1}}, split(/\s+/, $2) + if !@skip || $skip[$#skip] > 0 }, + qr/^\s*SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/ + => sub { push @{$sources{$1}}, split(/\s+/, $2) + if !@skip || $skip[$#skip] > 0 }, + qr/^\s*INCLUDE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/ + => sub { push @{$includes{$1}}, split(/\s+/, $2) + if !@skip || $skip[$#skip] > 0 }, + qr/^\s*DEPEND\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/ + => sub { push @{$depends{$1}}, split(/\s+/, $2) + if !@skip || $skip[$#skip] > 0 }, + qr/^\s*RENAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/ + => sub { push @{$renames{$1}}, split(/\s+/, $2) + if !@skip || $skip[$#skip] > 0 }, + qr/^\s*SHARED_NAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/ + => sub { push @{$sharednames{$1}}, split(/\s+/, $2) + if !@skip || $skip[$#skip] > 0 }, + qr/^\s*BEGINRAW\[((?:\\.|[^\\\]])+)\]\s*$/ + => sub { + my $lineiterator = shift; + my $target_kind = $1; + while (defined $lineiterator->()) { + s|\R$||; + if (/^\s*ENDRAW\[((?:\\.|[^\\\]])+)\]\s*$/) { + die "ENDRAW doesn't match BEGINRAW" + if $1 ne $target_kind; + last; + } + next if @skip && $skip[$#skip] <= 0; + push @rawlines, $_ + if ($target_kind eq $target{build_file} + || $target_kind eq $target{build_file}."(".$builder_platform.")"); + } + }, + qr/^(?:#.*|\s*)$/ => sub { }, + "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" } + ); + die "runaway IF?" if (@skip); + + foreach (keys %renames) { + die "$_ renamed to more than one thing: " + ,join(" ", @{$renames{$_}}),"\n" + if scalar @{$renames{$_}} > 1; + my $dest = cleanfile($buildd, $_, $blddir); + my $to = cleanfile($buildd, $renames{$_}->[0], $blddir); + die "$dest renamed to more than one thing: " + ,$unified_info{rename}->{$dest}, $to + unless !defined($unified_info{rename}->{$dest}) + or $unified_info{rename}->{$dest} eq $to; + $unified_info{rename}->{$dest} = $to; + } + + foreach (@programs) { + my $program = cleanfile($buildd, $_, $blddir); + if ($unified_info{rename}->{$program}) { + $program = $unified_info{rename}->{$program}; + } + $unified_info{programs}->{$program} = 1; + } + + foreach (@libraries) { + my $library = cleanfile($buildd, $_, $blddir); + if ($unified_info{rename}->{$library}) { + $library = $unified_info{rename}->{$library}; + } + $unified_info{libraries}->{$library} = 1; + } + + die <<"EOF" if scalar @engines and !$config{dynamic_engines}; +ENGINES can only be used if configured with 'dynamic-engine'. +This is usually a fault in a build.info file. +EOF + foreach (@engines) { + my $library = cleanfile($buildd, $_, $blddir); + if ($unified_info{rename}->{$library}) { + $library = $unified_info{rename}->{$library}; + } + $unified_info{engines}->{$library} = 1; + } + + foreach (@scripts) { + my $script = cleanfile($buildd, $_, $blddir); + if ($unified_info{rename}->{$script}) { + $script = $unified_info{rename}->{$script}; + } + $unified_info{scripts}->{$script} = 1; + } + + foreach (@extra) { + my $extra = cleanfile($buildd, $_, $blddir); + $unified_info{extra}->{$extra} = 1; + } + + push @{$unified_info{rawlines}}, @rawlines; + + unless ($disabled{shared}) { + # Check sharednames. + foreach (keys %sharednames) { + my $dest = cleanfile($buildd, $_, $blddir); + if ($unified_info{rename}->{$dest}) { + $dest = $unified_info{rename}->{$dest}; + } + die "shared_name for $dest with multiple values: " + ,join(" ", @{$sharednames{$_}}),"\n" + if scalar @{$sharednames{$_}} > 1; + my $to = cleanfile($buildd, $sharednames{$_}->[0], $blddir); + die "shared_name found for a library $dest that isn't defined\n" + unless $unified_info{libraries}->{$dest}; + die "shared_name for $dest with multiple values: " + ,$unified_info{sharednames}->{$dest}, ", ", $to + unless !defined($unified_info{sharednames}->{$dest}) + or $unified_info{sharednames}->{$dest} eq $to; + $unified_info{sharednames}->{$dest} = $to; + } + + # Additionally, we set up sharednames for libraries that don't + # have any, as themselves. + foreach (keys %{$unified_info{libraries}}) { + if (!defined $unified_info{sharednames}->{$_}) { + $unified_info{sharednames}->{$_} = $_ + } + } + } + + foreach (keys %ordinals) { + my $dest = $_; + my $ddest = cleanfile($buildd, $_, $blddir); + if ($unified_info{rename}->{$ddest}) { + $ddest = $unified_info{rename}->{$ddest}; + } + foreach (@{$ordinals{$dest}}) { + my %known_ordinals = + ( + crypto => + cleanfile($sourced, catfile("util", "libeay.num"), $blddir), + ssl => + cleanfile($sourced, catfile("util", "ssleay.num"), $blddir) + ); + my $o = $known_ordinals{$_}; + die "Ordinals for $ddest defined more than once\n" + if $unified_info{ordinals}->{$ddest}; + $unified_info{ordinals}->{$ddest} = [ $_, $o ]; + } + } + + foreach (keys %sources) { + my $dest = $_; + my $ddest = cleanfile($buildd, $_, $blddir); + if ($unified_info{rename}->{$ddest}) { + $ddest = $unified_info{rename}->{$ddest}; + } + foreach (@{$sources{$dest}}) { + my $s = cleanfile($sourced, $_, $blddir); + + # If it isn't in the source tree, we assume it's generated + # in the build tree + if (! -f $s) { + $s = cleanfile($buildd, $_, $blddir); + } + # We recognise C and asm files + if ($s =~ /\.[csS]\b$/) { + (my $o = $_) =~ s/\.[csS]\b$/.o/; + $o = cleanfile($buildd, $o, $blddir); + $unified_info{sources}->{$ddest}->{$o} = 1; + $unified_info{sources}->{$o}->{$s} = 1; + } else { + $unified_info{sources}->{$ddest}->{$s} = 1; + } + } + } + + foreach (keys %depends) { + my $dest = $_; + my $ddest = cleanfile($buildd, $_, $blddir); + if ($unified_info{rename}->{$ddest}) { + $ddest = $unified_info{rename}->{$ddest}; + } + foreach (@{$depends{$dest}}) { + my $d = cleanfile($sourced, $_, $blddir); + + # If we know it's generated, or assume it is because we can't + # find it in the source tree, we set file we depend on to be + # in the build tree rather than the source tree, and assume + # and that there are lines to build it in a BEGINRAW..ENDRAW + # section or in the Makefile template. + if (! -f $d + || !(grep { $d eq $_ } + map { cleanfile($srcdir, $_, $blddir) } + (@generated_headers, @generated_by_make_headers))) { + $d = cleanfile($buildd, $_, $blddir); + } + # Take note if the file to depend on is being renamed + if ($unified_info{rename}->{$d}) { + $d = $unified_info{rename}->{$d}; + } + $unified_info{depends}->{$ddest}->{$d} = 1; + # If we depend on a header file, let's make sure it + # can get included + if ($d =~ /\.h$/) { + my $i = dirname($d); + push @{$unified_info{includes}->{$ddest}}, $i + unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}}; + } + } + } + + foreach (keys %includes) { + my $dest = $_; + my $ddest = cleanfile($buildd, $_, $blddir); + if ($unified_info{rename}->{$ddest}) { + $ddest = $unified_info{rename}->{$ddest}; + } + foreach (@{$includes{$dest}}) { + my $i = cleandir($sourced, $_, $blddir); + push @{$unified_info{includes}->{$ddest}}, $i + unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}}; + } + } + } + + ### Make unified_info a bit more efficient + # One level structures + foreach (("programs", "libraries", "engines", "scripts", "extra")) { + $unified_info{$_} = [ sort keys %{$unified_info{$_}} ]; + } + # Two level structures + foreach my $l1 (("sources", "ldadd", "depends")) { + foreach my $l2 (sort keys %{$unified_info{$l1}}) { + $unified_info{$l1}->{$l2} = + [ sort keys %{$unified_info{$l1}->{$l2}} ]; + } + } +} + +# For the schemes that need it, we provide the old *_obj configs +# from the *_asm_obj ones +foreach (grep /_(asm|aux)_src$/, keys %target) { + my $src = $_; + (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/; + ($target{$obj} = $target{$src}) =~ s/\.[csS]\b/.o/g; +} + # Write down our configuration where it fits ######################### open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n"; @@ -1280,7 +1604,7 @@ use warnings; use Exporter; #use vars qw(\@ISA \@EXPORT); our \@ISA = qw(Exporter); -our \@EXPORT = qw(\%config \%target %withargs); +our \@EXPORT = qw(\%config \%target %disabled %withargs %unified_info); EOF print OUT "our %config = (\n"; @@ -1310,6 +1634,21 @@ foreach (sort keys %target) { print OUT <<"EOF"; ); +EOF +print OUT "our \%available_protocols = (\n"; +print OUT " tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n"; +print OUT " dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n"; +print OUT <<"EOF"; +); + +EOF +print OUT "our \%disabled = (\n"; +foreach (sort keys %disabled) { + print OUT " ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n"; +} +print OUT <<"EOF"; +); + EOF print OUT "our %withargs = (\n"; foreach (sort keys %withargs) { @@ -1324,14 +1663,60 @@ foreach (sort keys %withargs) { print OUT <<"EOF"; ); -1; EOF +if ($builder eq "unified") { + my $recurse; + $recurse = sub { + my $indent = shift; + foreach (@_) { + if (ref $_ eq "ARRAY") { + print OUT " "x$indent, "[\n"; + foreach (@$_) { + $recurse->($indent + 4, $_); + } + print OUT " "x$indent, "],\n"; + } elsif (ref $_ eq "HASH") { + my %h = %$_; + print OUT " "x$indent, "{\n"; + foreach (sort keys %h) { + if (ref $h{$_} eq "") { + print OUT " "x($indent + 4), quotify("perl", $_), " => ", quotify("perl", $h{$_}), ",\n"; + } else { + print OUT " "x($indent + 4), quotify("perl", $_), " =>\n"; + $recurse->($indent + 8, $h{$_}); + } + } + print OUT " "x$indent, "},\n"; + } else { + print OUT " "x$indent, quotify("perl", $_), ",\n"; + } + } + }; + print OUT "our %unified_info = (\n"; + foreach (sort keys %unified_info) { + if (ref $unified_info{$_} eq "") { + print OUT " "x4, quotify("perl", $_), " => ", quotify("perl", $unified_info{$_}), ",\n"; + } else { + print OUT " "x4, quotify("perl", $_), " =>\n"; + $recurse->(8, $unified_info{$_}); + } + } + print OUT <<"EOF"; +); + +EOF +} +print OUT "1;\n"; close(OUT); -print "IsMK1MF =", ($target{build_scheme}->[0] eq "mk1mf" ? "yes" : "no"), "\n"; + +print "IsMK1MF =", ($builder eq "mk1mf" ? "yes" : "no"), "\n"; print "CC =$target{cc}\n"; print "CFLAG =$config{cflags}\n"; -print "EX_LIBS =$config{lflags}\n"; +print "DEFINES =",join(" ", @{$config{defines}}),"\n"; +print "LFLAG =$config{lflags}\n"; +print "PLIB_LFLAG =$config{plib_lflags}\n"; +print "EX_LIBS =$config{ex_libs}\n"; print "CPUID_OBJ =$target{cpuid_obj}\n"; print "BN_ASM =$target{bn_obj}\n"; print "EC_ASM =$target{ec_obj}\n"; @@ -1346,93 +1731,80 @@ print "SHA1_OBJ_ASM =$target{sha1_obj}\n"; print "RMD160_OBJ_ASM=$target{rmd160_obj}\n"; print "CMLL_ENC =$target{cmll_obj}\n"; print "MODES_OBJ =$target{modes_obj}\n"; -print "ENGINES_OBJ =$target{engines_obj}\n"; +print "PADLOCK_OBJ =$target{padlock_obj}\n"; print "CHACHA_ENC =$target{chacha_obj}\n"; print "POLY1305_OBJ =$target{poly1305_obj}\n"; print "PROCESSOR =$config{processor}\n"; print "RANLIB =$target{ranlib}\n"; print "ARFLAGS =$target{arflags}\n"; print "PERL =$config{perl}\n"; - -run_dofile("$Makefile.in","$Makefile"); - -run_dofile("include/openssl/opensslconf.h.in", "include/openssl/opensslconf.h"); - -foreach my $alg ( 'bf', 'bn', 'des', 'rc4' ) { - run_dofile("crypto/include/internal/${alg}_conf.h.in", - "crypto/include/internal/${alg}_conf.h"); -} - -# Fix the date - +print "\n"; print "SIXTY_FOUR_BIT_LONG mode\n" if $config{b64l}; print "SIXTY_FOUR_BIT mode\n" if $config{b64}; print "THIRTY_TWO_BIT mode\n" if $config{b32}; -print "SIXTEEN_BIT mode\n" if $config{b16}; -print "EIGHT_BIT mode\n" if $config{b8}; -print "DES_PTR used\n" if $config{des_ptr}; -print "DES_RISC1 used\n" if $config{des_risc1}; -print "DES_RISC2 used\n" if $config{des_risc2}; -print "DES_UNROLL used\n" if $config{des_unroll}; -print "DES_INT used\n" if $config{des_int} =~ / int$/; print "BN_LLONG mode\n" if $config{bn_ll}; print "RC4 uses $config{rc4_int}\n" if $config{rc4_int} != $def_int; -print "RC4_INDEX mode\n" if $config{rc4_idx}; -print "RC4_CHUNK is undefined\n" unless $config{rc4_chunk}; -print "RC4_CHUNK is $config{rc4_chunk}\n" if $config{rc4_chunk}; -print "MD2 uses $config{md2_int}\n" if $config{md2_int} != $def_int; -print "IDEA uses $config{idea_int}\n" if $config{idea_int} != $def_int; -print "RC2 uses $config{rc2_int}\n" if $config{rc2_int} != $def_int; -print "BF_PTR used\n" if $config{bf_ptr} == 1; -print "BF_PTR2 used\n" if $config{bf_ptr} == 2; - -# Copy all Makefile.in to Makefile (except top-level) -use File::Find; -use IO::File; -find(sub { - return if ($_ ne "Makefile.in" || $File::Find::dir eq "."); - my $in = IO::File->new($_, "r") or - die sprintf "Error reading Makefile.in in %s: !$\n", - $File::Find::dir; - my $out = IO::File->new("Makefile", "w") or - die sprintf "Error writing Makefile in %s: !$\n", - $File::Find::dir; - print $out "# Generated from $_, do not edit\n"; - while (my $line = <$in>) { print $out $line } - $in->close() or - die sprintf "Error reading Makefile.in in %s: !$\n", - $File::Find::dir; - $out->close() or - die sprintf "Error writing Makefile in %s: !$\n", - $File::Find::dir; - }, "."); + +for (@generated_headers) { + mkpath(catdir($blddir, dirname($_))); + run_dofile(catfile($blddir, $_), + catfile($srcdir, $_.".in")); +} + +### +### When the old "unixmake" scheme goes away, so does this function +### +sub build_Makefile { + run_dofile("Makefile","Makefile.in"); + + # Copy all Makefile.in to Makefile (except top-level) + use File::Find; + use IO::File; + find( + { + preprocess => sub { + grep(!/^\./, @_); + }, + wanted => sub { + return if ($_ ne "Makefile.in" || $File::Find::dir eq "."); + my $in = IO::File->new($_, "r") or + die sprintf "Error reading Makefile.in in %s: !$\n", + $File::Find::dir; + my $out = IO::File->new("Makefile", "w") or + die sprintf "Error writing Makefile in %s: !$\n", + $File::Find::dir; + print $out "# Generated from $_, do not edit\n"; + while (my $line = <$in>) { print $out $line } + $in->close() or + die sprintf "Error reading Makefile.in in %s: !$\n", + $File::Find::dir; + $out->close() or + die sprintf "Error writing Makefile in %s: !$\n", + $File::Find::dir; + }, + }, + "."); +} my %builders = ( + unified => sub { + run_dofile(catfile($blddir, $target{build_file}), + $config{build_file_template}, + catfile($srcdir, "Configurations", "common.tmpl")); + }, unixmake => sub { - my $make_command = "$make PERL=\'$config{perl}\'"; - my $make_targets = ""; - $make_targets .= " depend" if $config{depflags} ne $default_depflags && $make_depend; - (system $make_command.$make_targets) == 0 or die "make $make_targets failed" - if $make_targets ne ""; - if ($config{depflags} ne $default_depflags && !$make_depend) { - $warn_make_depend++; - } + build_Makefile(); + + run_dofile("util/domd", "util/domd.in"); + chmod 0755, "util/domd"; }, mk1mf => sub { - open (OUT,">crypto/buildinf.h") || die "Can't open buildinf.h"; - printf OUT <<"EOF"; -#ifndef MK1MF_BUILD - /* auto-generated by Configure for crypto/cversion.c: - * for Unix builds, crypto/Makefile.ssl generates functional definitions; - * Windows builds (and other mk1mf builds) compile cversion.c with - * -DMK1MF_BUILD and use definitions added to this file by util/mk1mf.pl. */ - #error "Windows builds (PLATFORM=$target) use mk1mf.pl-created Makefiles" -#endif -EOF - close(OUT); + my $platform = shift; + # The only reason we do this is to have something to build MINFO from + build_Makefile(); # create the ms/version32.rc file if needed - if (! grep /^netware/, @{$target{build_scheme}}) { + if ($platform ne "netware") { my ($v1, $v2, $v3, $v4); 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) { $v1=hex $1; @@ -1495,15 +1867,14 @@ EOF }, ); -my ($builder, @builder_opts) = @{$target{build_scheme}}; -$builders{$builder}->(@builder_opts); +$builders{$builder}->($builder_platform, @builder_opts); print <<"EOF"; Configured for $target. EOF -print <<"EOF" if (!$no_threads && !$threads); +print <<"EOF" if (!$disabled{threads} && !$threads); The library could not be configured for supporting multi-threaded applications as the compiler options required on this system are not known. @@ -1512,19 +1883,45 @@ EOF print <<"EOF" if ($no_shared_warn); -You gave the option 'shared', which is not supported on this platform, so -we will pretend you gave the option 'no-shared'. If you know how to implement -shared libraries, please let us know (but please first make sure you have -tried with a current version of OpenSSL). +The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this +platform, so we will pretend you gave the option 'no-pic', which also disables +'shared' and 'dynamic-engine'. If you know how to implement shared libraries +or position independent code, please let us know (but please first make sure +you have tried with a current version of OpenSSL). EOF -print <<"EOF" if ($warn_make_depend); +###### TO BE REMOVED BEFORE FINAL RELEASE +###### +###### If the user hasn't chosen --unified, try to nudge them. +if ($target{build_file} eq "Makefile" + && $target{build_scheme}->[0] eq "unixmake" + && !$unified) { -*** Because of configuration changes, you MUST do the following before -*** building: + my $plausible_builddir = + abs2rel(rel2abs("../_openssl-build_$target"),rel2abs(".")); + my $plausible_to_sourcedir = + abs2rel(rel2abs("."),rel2abs("../_openssl-build_$target")); + print <<"EOF"; + +---------------------------------------------------------------------- +Please consider configuring with the flag --unified . +It's to test out a new "unified" building system. + +One cool feature is that you can have your build directory elsewhere, +for example: + + make clean # Clean the current configuration away + mkdir $plausible_builddir + cd $plausible_builddir + $plausible_to_sourcedir/config --unified + make + make test + +Please report any problem you have. +---------------------------------------------------------------------- - make depend EOF +} exit(0); @@ -1536,14 +1933,14 @@ exit(0); # Configuration file reading ######################################### # Helper function to implement conditional inheritance depending on the -# value of $no_asm. Used in inherit_from values as follows: +# value of $disabled{asm}. Used in inherit_from values as follows: # # inherit_from => [ "template", asm("asm_tmpl") ] # sub asm { my @x = @_; sub { - $no_asm ? () : @x; + $disabled{asm} ? () : @x; } } @@ -1552,10 +1949,10 @@ sub asm { sub _add { my $separator = shift; - # If there's any ARRAY in the collection of values, we will return - # an ARRAY of combined values, otherwise a string of joined values - # with $separator as the separator. - my $found_array = 0; + # If there's any ARRAY in the collection of values OR the separator + # is undef, we will return an ARRAY of combined values, otherwise a + # string of joined values with $separator as the separator. + my $found_array = !defined($separator); my @values = map { @@ -1574,12 +1971,20 @@ sub _add { } } sub add_before { - my $separator = shift; + my $separator = " "; + if (ref($_[$#_]) eq "HASH") { + my $opts = pop; + $separator = $opts->{separator}; + } my @x = @_; sub { _add($separator, @x, @_) }; } sub add { - my $separator = shift; + my $separator = " "; + if (ref($_[$#_]) eq "HASH") { + my $opts = pop; + $separator = $opts->{separator}; + } my @x = @_; sub { _add($separator, @_, @x) }; } @@ -1677,7 +2082,7 @@ sub resolve_config { # value. # - Otherwise, this target's value is assumed to be a string that # will simply override the inherited list of values. - my $default_combiner = add(" "); + my $default_combiner = add(); my %all_keys = map { $_ => 1 } (keys %combined_inheritance, @@ -1748,11 +2153,17 @@ sub usage sub run_dofile() { - my $in = shift; my $out = shift; + my @templates = @_; - # should we remove $out ? - system("$config{perl} -I. -Mconfigdata util/dofile.pl -o\"Configure\" $in > $out.new"); + unlink $out || warn "Can't remove $out, $!" + if -f $out; + foreach (@templates) { + die "Can't open $_, $!" unless -f $_; + } + my $cmd = "$config{perl} \"-I.\" \"-Mconfigdata\" $dofile -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\""; + #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n"; + system($cmd); exit 1 if $? != 0; rename("$out.new", $out) || die "Can't rename $out.new, $!"; } @@ -1769,16 +2180,26 @@ sub print_table_entry return if $target{template}; my @sequence = ( + "sys_id", "cc", "cflags", + "defines", "debug_cflags", + "debug_defines", "release_cflags", - "unistd", + "release_defines", "thread_cflag", - "sys_id", + "unistd", + "ld", "lflags", + "plib_lflags", + "ex_libs", "debug_lflags", + "debug_plib_lflags", + "debug_ex_libs", "release_lflags", + "release_plib_lflags", + "release_ex_libs", "bn_ops", "cpuid_obj", "bn_obj", @@ -1795,29 +2216,47 @@ sub print_table_entry "wp_obj", "cmll_obj", "modes_obj", - "engines_obj", + "padlock_obj", "perlasm_scheme", "dso_scheme", "shared_target", "shared_cflag", "shared_ldflag", + "shared_rcflag", "shared_extension", + "shared_extension_simple", + "shared_import_extension", + "dso_extension", + "obj_extension", + "exe_extension", "ranlib", + "ar", "arflags", "multilib", + "build_scheme", ); if ($type eq "TABLE") { print "\n"; print "*** $target\n"; - printf "\$%-12s = %s\n", $_, $target{$_} foreach (@sequence); + foreach (@sequence) { + if (ref($target{$_}) eq "ARRAY") { + printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}}); + } else { + printf "\$%-12s = %s\n", $_, $target{$_}; + } + } } elsif ($type eq "HASH") { my $largest = length((sort { length($a) <=> length($b) } @sequence)[-1]); print " '$target' => {\n"; foreach (@sequence) { if ($target{$_}) { - print " '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n"; + if (ref($target{$_}) eq "ARRAY") { + print " '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n"; + } else { + print " '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n"; + } } } print " },\n"; @@ -1826,6 +2265,46 @@ sub print_table_entry # Utility routines ################################################### +# On VMS, if the given file is a logical name, File::Spec::Functions +# will consider it an absolute path. There are cases when we want a +# purely syntactic check without checking the environment. +sub isabsolute { + my $file = shift; + + # On non-platforms, we just use file_name_is_absolute(). + return file_name_is_absolute($file) unless $^O eq "VMS"; + + # If the file spec includes a device or a directpry spec, + # file_name_is_absolute() is perfectly safe. + return file_name_is_absolute($file) if $file =~ m|[:\[]|; + + # Here, we know the given file spec isn't absolute + return 0; +} + +# Makes a directory absolute and cleans out /../ in paths like foo/../bar +# On some platforms, this uses rel2abs(), while on others, realpath() is used. +# realpath() requires that at least all path components except the last is an +# existing directory. On VMS, the last component of the directory spec must +# exist. +sub absolutedir { + my $dir = shift; + + # realpath() is quite buggy on VMS. It uses LIB$FID_TO_NAME, which + # will return the volume name for the device, no matter what. Also, + # it will return an incorrect directory spec if the argument is a + # directory that doesn't exist. + if ($^O eq "VMS") { + return rel2abs($dir); + } + + # We use realpath() on Unix, since no other will properly clean out + # a directory spec. + use Cwd qw/realpath/; + + return realpath($dir); +} + sub which { my($name)=@_; @@ -1853,34 +2332,87 @@ sub quotify { map { $processor->($_); } @_; } -# collect_information($filename, $line_continue, $regexp => $CODEref, ...) -# $filename is the file to read. -# $line_continue is either undef (which is a noop), or two arguments, where -# the first is a regexp detecting a line continuation ending, and the -# following argument is a CODEref that takes care of concatenating two -# lines. +# collect_from_file($filename, $line_concat_cond_re, $line_concat) +# $filename is a file name to read from +# $line_concat_cond_re is a regexp detecting a line continuation ending +# $line_concat is a CODEref that takes care of concatenating two lines +sub collect_from_file { + my $filename = shift; + my $line_concat_cond_re = shift; + my $line_concat = shift; + + open my $fh, $filename || die "unable to read $filename: $!\n"; + return sub { + my $saved_line = ""; + $_ = ""; + while (<$fh>) { + s|\R$||; + if (defined $line_concat) { + $_ = $line_concat->($saved_line, $_); + $saved_line = ""; + } + if (defined $line_concat_cond_re && /$line_concat_cond_re/) { + $saved_line = $_; + next; + } + return $_; + } + die "$filename ending with continuation line\n" if $_; + close $fh; + return undef; + } +} + +# collect_from_array($array, $line_concat_cond_re, $line_concat) +# $array is an ARRAYref of lines +# $line_concat_cond_re is a regexp detecting a line continuation ending +# $line_concat is a CODEref that takes care of concatenating two lines +sub collect_from_array { + my $array = shift; + my $line_concat_cond_re = shift; + my $line_concat = shift; + my @array = (@$array); + + return sub { + my $saved_line = ""; + $_ = ""; + while (defined($_ = shift @array)) { + s|\R$||; + if (defined $line_concat) { + $_ = $line_concat->($saved_line, $_); + $saved_line = ""; + } + if (defined $line_concat_cond_re && /$line_concat_cond_re/) { + $saved_line = $_; + next; + } + return $_; + } + die "input text ending with continuation line\n" if $_; + return undef; + } +} + +# collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...) +# $lineiterator is a CODEref that delivers one line at a time. # All following arguments are regex/CODEref pairs, where the regexp detects a # line and the CODEref does something with the result of the regexp. sub collect_information { - my $filename = shift; - my $line_continue_re = shift; - my $line_concat = defined($line_continue_re) ? shift : undef; + my $lineiterator = shift; my %collectors = @_; - my $saved_line = ""; - open IN, $filename || die "unable to read $filename: $!\n"; - while() { - chomp; - if (defined $line_concat) { - $_ = $line_concat->($saved_line, $_); - } - if (defined $line_continue_re && /$line_continue_re/) { - $saved_line = $_; - next; - } - foreach my $re (keys %collectors) { - if (/$re/) { $collectors{$re}->() }; - } + while(defined($_ = $lineiterator->())) { + s|\R$||; + my $found = 0; + foreach my $re (keys %collectors) { + if ($re ne "OTHERWISE" && /$re/) { + $collectors{$re}->($lineiterator); + $found = 1; + }; + } + if ($collectors{"OTHERWISE"}) { + $collectors{"OTHERWISE"}->($lineiterator, $_) + unless $found || !defined $collectors{"OTHERWISE"}; + } } - close IN; }