die "Incorrect data to reconfigure, please do a normal configuration\n"
if (grep(/^reconf/,@argvcopy));
$config{perlenv} = $configdata::config{perlenv} // {};
-
- print "Reconfiguring with: ", join(" ",@argvcopy), "\n";
- foreach (sort keys %{$config{perlenv}}) {
- print " $_ = $config{perlenv}->{$_}\n";
- }
} else {
die "Insufficient data to reconfigure, please do a normal configuration\n";
}
}
}
+# Save away perl command information
+$config{perl_cmd} = $^X;
+$config{perl_version} = $Config{version};
+$config{perl_archname} = $Config{archname};
+
$config{prefix}="";
$config{openssldir}="";
$config{processor}="";
$config{libdir}="";
-$config{cross_compile_prefix}="";
my $auto_threads=1; # enable threads automatically? true by default
my $default_ranlib;
"ssl3" => "default",
"ssl3-method" => "default",
"ubsan" => "default",
- #TODO(TLS1.3): Temporarily disabled while this is a WIP
- "tls1_3" => "default",
"tls13downgrade" => "default",
"unit-test" => "default",
"weak-ssl-ciphers" => "default",
# To remove something from %disabled, use "enable-foo".
# For symmetry, "disable-foo" is a synonym for "no-foo".
-my $no_sse2=0;
-
&usage if ($#ARGV < 0);
# For the "make variables" CINCLUDES and CDEFINES, we support lists with
CPPFLAGS => [], # -D, -I, -Wp,
CPPDEFINES => [], # Alternative for -D
CPPINCLUDES => [], # Alternative for -I
+ CROSS_COMPILE => undef,
HASHBANGPERL=> undef,
LD => undef,
LDFLAGS => [], # -L, -Wl,
RCFLAGS => [],
RM => undef,
);
+# Info about what "make variables" may be prefixed with the cross compiler
+# prefix. This should NEVER mention any such variable with a list for value.
+my @user_crossable = qw ( AR AS CC CXX CPP LD MT RANLIB RC );
# The same but for flags given as Configure options. These are *additional*
# input, as opposed to the VAR=string option that override the corresponding
# config target attributes
HASHBANGPERL=> 'PERL',
RC => 'WINDRES',
);
-my %user_to_target = (
- # If not given here, the value is the lc of the key
- CPPDEFINES => 'defines',
- CPPINCLUDES => 'includes',
- LDFLAGS => 'lflags',
- LDLIBS => 'ex_libs',
+
+# Some target attributes have been renamed, this is the translation table
+my %target_attr_translate =(
+ ar => 'AR',
+ as => 'AS',
+ cc => 'CC',
+ cxx => 'CXX',
+ cpp => 'CPP',
+ hashbangperl => 'HASHBANGPERL',
+ ld => 'LD',
+ mt => 'MT',
+ ranlib => 'RANLIB',
+ rc => 'RC',
+ rm => 'RM',
);
+# Initialisers coming from 'config' scripts
+$config{defines} = [ split(/$list_separator_re/, env('__CNF_CPPDEFINES')) ],
+$config{includes} = [ split(/$list_separator_re/, env('__CNF_CPPINCLUDES')) ],
+$config{cppflags} = [ env('__CNF_CPPFLAGS') || () ],
+$config{cflags} = [ env('__CNF_CFLAGS') || () ],
+$config{cxxflags} = [ env('__CNF_CXXFLAGS') || () ],
+$config{lflags} = [ env('__CNF_LDFLAGS') || () ],
+$config{ex_libs} = [ env('__CNF_LDLIBS') || () ],
+
$config{openssl_api_defines}=[];
$config{openssl_algorithm_defines}=[];
$config{openssl_thread_defines}=[];
}
elsif (/^--cross-compile-prefix=(.*)$/)
{
- $config{cross_compile_prefix}=$1;
+ $user{CROSS_COMPILE}=$1;
}
elsif (/^--config=(.*)$/)
{
"***** any of asan, msan or ubsan\n";
}
-if (scalar(@seed_sources) == 0) {
- print "Using implicit seed configuration\n";
- push @seed_sources, 'os';
-}
-die "Cannot seed with none and anything else"
- if scalar(grep { $_ eq 'none' } @seed_sources) > 0
- && scalar(@seed_sources) > 1;
-push @{$config{openssl_other_defines}},
- map { (my $x = $_) =~ tr|[\-a-z]|[_A-Z]|; "OPENSSL_RAND_SEED_$x" }
- @seed_sources;
-
my @tocheckfor = (keys %disabled);
while (@tocheckfor) {
my %new_tocheckfor = ();
exit 0;
}
-print "Configuring OpenSSL version $config{version} ($config{version_num})\n";
+print "Configuring OpenSSL version $config{version} ($config{version_num}) ";
print "for $target\n";
+if (scalar(@seed_sources) == 0) {
+ print "Using os-specific seed configuration\n";
+ push @seed_sources, 'os';
+}
+die "Cannot seed with none and anything else"
+ if scalar(grep { $_ eq 'none' } @seed_sources) > 0
+ && scalar(@seed_sources) > 1;
+push @{$config{openssl_other_defines}},
+ map { (my $x = $_) =~ tr|[\-a-z]|[_A-Z]|; "OPENSSL_RAND_SEED_$x" }
+ @seed_sources;
+
# Backward compatibility?
if ($target =~ m/^CygWin32(-.*)$/) {
$target = "Cygwin".$1;
&usage if (!%target || $target{template});
+foreach (keys %target_attr_translate) {
+ $target{$target_attr_translate{$_}} = $target{$_}
+ if $target{$_};
+ delete $target{$_};
+}
+
%target = ( %{$table{DEFAULTS}}, %target );
# Make the flags to build DSOs the same as for shared libraries unless they
# are already defined
-$target{dso_cflags} = $target{shared_cflag} unless defined $target{dso_cflags};
-$target{dso_cxxflags} = $target{shared_cxxflag} unless defined $target{dso_cxxflags};
-$target{dso_lflags} = $target{shared_ldflag} unless defined $target{dso_lflags};
+$target{module_cflags} = $target{shared_cflag} unless defined $target{module_cflags};
+$target{module_cxxflags} = $target{shared_cxxflag} unless defined $target{module_cxxflags};
+$target{module_ldflags} = $target{shared_ldflag} unless defined $target{module_ldflags};
{
my $shared_info_pl =
catfile(dirname($0), "Configurations", "shared-info.pl");
# Windows and VMS.
if (defined $si) {
# Just as above, copy certain shared_* attributes to the corresponding
- # dso_ attribute unless the latter is already defined
- $si->{dso_cflags} = $si->{shared_cflag} unless defined $si->{dso_cflags};
- $si->{dso_cxxflags} = $si->{shared_cxxflag} unless defined $si->{dso_cxxflags};
- $si->{dso_lflags} = $si->{shared_ldflag} unless defined $si->{dso_lflags};
+ # module_ attribute unless the latter is already defined
+ $si->{module_cflags} = $si->{shared_cflag} unless defined $si->{module_cflags};
+ $si->{module_cxxflags} = $si->{shared_cxxflag} unless defined $si->{module_cxxflags};
+ $si->{module_ldflags} = $si->{shared_ldflag} unless defined $si->{module_ldflags};
foreach (sort keys %$si) {
$target{$_} = defined $target{$_}
? add($si->{$_})->($target{$_})
}
}
-foreach (sort (keys %disabled))
- {
- $config{options} .= " no-$_";
-
- printf " no-%-12s %-10s", $_, "[$disabled{$_}]";
-
- if (/^dso$/)
- { }
- elsif (/^threads$/)
- { }
- elsif (/^shared$/)
- { }
- elsif (/^pic$/)
- { }
- elsif (/^zlib$/)
- { }
- elsif (/^dynamic-engine$/)
- { }
- elsif (/^makedepend$/)
- { }
- elsif (/^zlib-dynamic$/)
- { }
- elsif (/^sse2$/)
- { $no_sse2 = 1; }
- elsif (/^engine$/)
- {
- @{$config{dirs}} = grep !/^engines$/, @{$config{dirs}};
- @{$config{sdirs}} = grep !/^engine$/, @{$config{sdirs}};
- push @{$config{openssl_other_defines}}, "OPENSSL_NO_ENGINE";
- print " OPENSSL_NO_ENGINE (skip engines)";
- }
- else
- {
- my ($WHAT, $what);
-
- ($WHAT = $what = $_) =~ tr/[\-a-z]/[_A-Z]/;
-
- # Fix up C macro end names
- $WHAT = "RMD160" if $what eq "ripemd";
-
- # fix-up crypto/directory name(s)
- $what = "ripemd" if $what eq "rmd160";
- $what = "whrlpool" if $what eq "whirlpool";
-
- if ($what ne "async" && $what ne "err"
- && grep { $_ eq $what } @{$config{sdirs}})
- {
- push @{$config{openssl_algorithm_defines}}, "OPENSSL_NO_$WHAT";
- @{$config{sdirs}} = grep { $_ ne $what} @{$config{sdirs}};
-
- print " OPENSSL_NO_$WHAT (skip dir)";
- }
- else
- {
- push @{$config{openssl_other_defines}}, "OPENSSL_NO_$WHAT";
- print " OPENSSL_NO_$WHAT";
-
- if (/^err$/)
- {
- push @{$useradd{CPPDEFINES}}, "OPENSSL_NO_ERR";
- }
- }
- }
-
- print "\n";
- }
-
-$target{cxxflags}=$target{cflags} unless defined $target{cxxflags};
+$target{CXXFLAGS}//=$target{CFLAGS} if $target{CXX};
+$target{cxxflags}//=$target{cflags} if $target{CXX};
$target{exe_extension}="";
$target{exe_extension}=".exe" if ($config{target} eq "DJGPP"
|| $config{target} =~ /^(?:Cygwin|mingw)/);
($target{shared_import_extension}=$target{shared_extension_simple}.".a")
if ($config{target} =~ /^(?:Cygwin|mingw)/);
-
-$config{cross_compile_prefix} = env('CROSS_COMPILE')
- if $config{cross_compile_prefix} eq "";
-
# Allow overriding the names of some tools. USE WITH CARE
# Note: only Unix cares about HASHBANGPERL... that explains
# the default string.
$config{perl} = ($^O ne "VMS" ? $^X : "perl");
foreach (keys %user) {
- my $target_key = $user_to_target{$_} // lc $_;
my $ref_type = ref $user{$_};
# Temporary function. Takes an intended ref type (empty string or "ARRAY")
return $value;
};
- $config{$target_key} =
+ $config{$_} =
$mkvalue->($ref_type, $user{$_})
- || $mkvalue->($ref_type, $target{$target_key});
- if (defined $useradd{$_} && @{$useradd{$_}}) {
- if (defined $config{$target_key}) {
- push @{$config{$target_key}}, @{$useradd{$_}};
- } else {
- $config{$target_key} = [ @{$useradd{$_}} ];
- }
- }
- delete $config{$target_key} unless defined $config{$target_key};
+ || $mkvalue->($ref_type, $target{$_});
+ delete $config{$_} unless defined $config{$_};
}
-$config{plib_lflags} = [ $target{plib_lflags} ];
# Allow overriding the build file name
$config{build_file} = env('BUILDFILE') || $target{build_file} || "Makefile";
+my %disabled_info = (); # For configdata.pm
+foreach my $what (sort keys %disabled) {
+ $config{options} .= " no-$what";
+
+ if (!grep { $what eq $_ } ( 'dso', 'threads', 'shared', 'pic',
+ 'dynamic-engine', 'makedepend',
+ 'zlib-dynamic', 'zlib', 'sse2' )) {
+ (my $WHAT = uc $what) =~ s|-|_|g;
+
+ # Fix up C macro end names
+ $WHAT = "RMD160" if $what eq "ripemd";
+
+ # fix-up crypto/directory name(s)
+ $what = "ripemd" if $what eq "rmd160";
+ $what = "whrlpool" if $what eq "whirlpool";
+
+ my $macro = $disabled_info{$what}->{macro} = "OPENSSL_NO_$WHAT";
+
+ if ((grep { $what eq $_ } @{$config{sdirs}})
+ && $what ne 'async' && $what ne 'err') {
+ @{$config{sdirs}} = grep { $what ne $_} @{$config{sdirs}};
+ $disabled_info{$what}->{skipped} = [ catdir('crypto', $what) ];
+
+ if ($what ne 'engine') {
+ push @{$config{openssl_algorithm_defines}}, $macro;
+ } else {
+ @{$config{dirs}} = grep !/^engines$/, @{$config{dirs}};
+ push @{$disabled_info{engine}->{skipped}}, catdir('engines');
+ push @{$config{openssl_other_defines}}, $macro;
+ }
+ } else {
+ push @{$config{openssl_other_defines}}, $macro;
+ }
+
+ }
+}
+
# Make sure build_scheme is consistent.
$target{build_scheme} = [ $target{build_scheme} ]
if ref($target{build_scheme}) ne "ARRAY";
push @{$config{defines}}, "NDEBUG" if $config{build_type} eq "release";
-if ($target =~ /^mingw/ && `$config{cc} --target-help 2>&1` =~ m/-mno-cygwin/m)
+if ($target =~ /^mingw/ && `$config{CC} --target-help 2>&1` =~ m/-mno-cygwin/m)
{
push @{$config{cflags}}, "-mno-cygwin";
+ push @{$config{cxxflags}}, "-mno-cygwin" if $config{CXX};
push @{$config{shared_ldflag}}, "-mno-cygwin";
}
if ($target =~ /linux.*-mips/ && !$disabled{asm}
- && !grep { $_ !~ /-m(ips|arch=)/ } @{$user{CFLAGS}}) {
+ && !grep { $_ !~ /-m(ips|arch=)/ } (@{$user{CFLAGS}},
+ @{$useradd{CFLAGS}})) {
# minimally required architecture flags for assembly modules
- unshift @{$config{cflags}}, '-mips2' if ($target =~ /mips32/);
- unshift @{$config{cflags}}, '-mips3' if ($target =~ /mips64/);
+ my $value;
+ $value = '-mips2' if ($target =~ /mips32/);
+ $value = '-mips3' if ($target =~ /mips64/);
+ unshift @{$config{cflags}}, $value;
+ unshift @{$config{cxxflags}}, $value if $config{CXX};
}
# The DSO code currently always implements all functions so that no
# system-dependent compiler options that are necessary. We
# can't truly check that the given options are correct, but
# we expect the user to know what [s]He is doing.
- if (!@{$user{CFLAGS}} && !@{$user{CPPDEFINES}}) {
+ if (!@{$user{CFLAGS}} && !@{$useradd{CFLAGS}}
+ && !@{$user{CPPDEFINES}} && !@{$useradd{CPPDEFINES}}) {
die "You asked for multi-threading support, but didn't\n"
,"provide any system-specific compiler options\n";
}
unless ($disabled{asan}) {
push @{$config{cflags}}, "-fsanitize=address";
+ push @{$config{cxxflags}}, "-fsanitize=address" if $config{CXX};
}
unless ($disabled{ubsan}) {
# -DPEDANTIC or -fnosanitize=alignment may also be required on some
# platforms.
push @{$config{cflags}}, "-fsanitize=undefined", "-fno-sanitize-recover=all";
+ push @{$config{cxxflags}}, "-fsanitize=undefined", "-fno-sanitize-recover=all"
+ if $config{CXX};
}
unless ($disabled{msan}) {
push @{$config{cflags}}, "-fsanitize=memory";
+ push @{$config{cxxflags}}, "-fsanitize=memory" if $config{CXX};
}
unless ($disabled{"fuzz-libfuzzer"} && $disabled{"fuzz-afl"}
&& $disabled{asan} && $disabled{ubsan} && $disabled{msan}) {
push @{$config{cflags}}, "-fno-omit-frame-pointer", "-g";
+ push @{$config{cxxflags}}, "-fno-omit-frame-pointer", "-g" if $config{CXX};
}
#
# Platform fix-ups
if ($disabled{pic})
{
foreach (qw(shared_cflag shared_cxxflag shared_cppflag
- shared_defines shared_includes shared_ldflag
- dso_cflags dso_cxxflags dso_cppflags
- dso_defines dso_includes dso_lflags))
+ shared_defines shared_includes shared_ldflag
+ module_cflags module_cxxflags module_cppflags
+ module_defines module_includes module_lflags))
{
delete $config{$_};
$target{$_} = "";
unless ($disabled{asm}) {
$target{cpuid_asm_src}=$table{DEFAULTS}->{cpuid_asm_src} if ($config{processor} eq "386");
+ push @{$config{defines}}, "OPENSSL_CPUID_OBJ" if ($target{cpuid_asm_src} ne "mem_clr.c");
+
$target{bn_asm_src} =~ s/\w+-gf2m.c// if (defined($disabled{ec2m}));
# bn-586 is the only one implementing bn_*_part_words
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/);
+ push @{$config{defines}}, "OPENSSL_IA32_SSE2" if (!$disabled{sse2} && $target{bn_asm_src} =~ /86/);
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}}, "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);
+ $target{aes_asm_src} =~ s/\s*(vpaes|aesni)-x86\.s//g if ($disabled{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{ec_asm_src} =~ /ecp_nistz256/) {
push @{$config{defines}}, "ECP_NISTZ256_ASM";
}
+ if ($target{ec_asm_src} =~ /x25519/) {
+ push @{$config{defines}}, "X25519_ASM";
+ }
if ($target{padlock_asm_src} ne $table{DEFAULTS}->{padlock_asm_src}) {
push @{$config{defines}}, "PADLOCK_ASM";
}
}
}
-my %predefined = compiler_predefined($config{cc});
+my %predefined = compiler_predefined($config{CC});
# Check for makedepend capabilities.
if (!$disabled{makedepend}) {
} elsif ($predefined{__GNUC__} >= 3) {
# We know that GNU C version 3 and up as well as all clang
# versions support dependency generation
- $config{makedepprog} = "\$(CROSS_COMPILE)$config{cc}";
+ $config{makedepprog} = "\$(CROSS_COMPILE)$config{CC}";
} else {
# In all other cases, we look for 'makedepend', and disable the
# capability if not found.
# Hack cflags for better warnings (dev option) #######################
-# "Stringify" the C flags string. This permits it to be made part of a string
-# and works as well on command lines.
+# "Stringify" the C and C++ flags string. This permits it to be made part of
+# a string and works as well on command lines.
$config{cflags} = [ map { (my $x = $_) =~ s/([\\\"])/\\$1/g; $x }
@{$config{cflags}} ];
+$config{cxxflags} = [ map { (my $x = $_) =~ s/([\\\"])/\\$1/g; $x }
+ @{$config{cxxflags}} ] if $config{CXX};
if (defined($config{api})) {
$config{openssl_api_defines} = [ "OPENSSL_MIN_API=".$apitable->{$config{api}} ];
if (defined($predefined{__clang__}) && !$disabled{asm}) {
push @{$config{cflags}}, "-Qunused-arguments";
+ push @{$config{cxxflags}}, "-Qunused-arguments" if $config{CXX};
}
if ($strict_warnings)
{
push @{$config{cflags}}, $wopt
unless grep { $_ eq $wopt } @{$config{cflags}};
+ push @{$config{cxxflags}}, $wopt
+ if ($config{CXX}
+ && !grep { $_ eq $wopt } @{$config{cxxflags}});
}
if (defined($predefined{__clang__}))
{
{
push @{$config{cflags}}, $wopt
unless grep { $_ eq $wopt } @{$config{cflags}};
+ push @{$config{cxxflags}}, $wopt
+ if ($config{CXX}
+ && !grep { $_ eq $wopt } @{$config{cxxflags}});
}
}
}
{
push @{$config{cflags}}, $wopt
unless grep { $_ eq $wopt } @{$config{cflags}};
+ push @{$config{cxxflags}}, $wopt
+ if ($config{CXX}
+ && !grep { $_ eq $wopt } @{$config{cxxflags}});
}
if ($target =~ /^BSD-/)
{
$config{afalgeng}="";
if ($target =~ m/^linux/) {
my $minver = 4*10000 + 1*100 + 0;
- if ($config{cross_compile_prefix} eq "") {
+ if ($config{CROSS_COMPILE} eq "") {
my $verstr = `uname -r`;
my ($ma, $mi1, $mi2) = split("\\.", $verstr);
($mi2) = $mi2 =~ /(\d+)/;
push @{$config{openssl_other_defines}}, "OPENSSL_NO_AFALGENG" if ($disabled{afalgeng});
+# Finish up %config by appending things the user gave us on the command line
+# apart from "make variables"
+foreach (keys %useradd) {
+ # The must all be lists, so we assert that here
+ die "internal error: \$useradd{$_} isn't an ARRAY\n"
+ unless ref $useradd{$_} eq 'ARRAY';
+
+ if (defined $config{$_}) {
+ push @{$config{$_}}, @{$useradd{$_}};
+ } else {
+ $config{$_} = [ @{$useradd{$_}} ];
+ }
+}
+
# ALL MODIFICATIONS TO %config and %target MUST BE DONE FROM HERE ON
# If we use the unified build, collect information from build.info files
# If it isn't in the source tree, we assume it's generated
# in the build tree
- if (! -f $s) {
+ if (! -f $s || $generate{$_}) {
$s = cleanfile($buildd, $_, $blddir);
}
# We recognise C++, C and asm files
# If it isn't in the source tree, we assume it's generated
# in the build tree
- if (! -f $s) {
+ if (! -f $s || $generate{$_}) {
$s = cleanfile($buildd, $_, $blddir);
}
# Write down our configuration where it fits #########################
+print "Creating configdata.pm\n";
open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
print OUT <<"EOF";
+#! $config{HASHBANGPERL}
+
package configdata;
use strict;
EOF
}
-print OUT "1;\n";
-close(OUT);
+print OUT
+ "# The following data is only used when this files is use as a script\n";
+print OUT "my \@makevars = (\n";
+foreach (sort keys %user) {
+ print OUT " '",$_,"',\n";
+}
+print OUT ");\n";
+print OUT "my \%disabled_info = (\n";
+foreach my $what (sort keys %disabled_info) {
+ print OUT " '$what' => {\n";
+ foreach my $info (sort keys %{$disabled_info{$what}}) {
+ if (ref $disabled_info{$what}->{$info} eq 'ARRAY') {
+ print OUT " $info => [ ",
+ join(', ', map { "'$_'" } @{$disabled_info{$what}->{$info}}),
+ " ],\n";
+ } else {
+ print OUT " $info => '", $disabled_info{$what}->{$info},
+ "',\n";
+ }
+ }
+ print OUT " },\n";
+}
+print OUT ");\n";
+print OUT 'my @user_crossable = qw( ', join (' ', @user_crossable), " );\n";
+print OUT << 'EOF';
+# If run directly, we can give some answers, and even reconfigure
+unless (caller) {
+ use Getopt::Long;
+ use File::Spec::Functions;
+ use File::Basename;
+ use Pod::Usage;
+
+ my $here = dirname($0);
+
+ my $dump = undef;
+ my $cmdline = undef;
+ my $options = undef;
+ my $target = undef;
+ my $envvars = undef;
+ my $makevars = undef;
+ my $buildparams = undef;
+ my $reconf = undef;
+ my $verbose = undef;
+ my $help = undef;
+ my $man = undef;
+ GetOptions('dump|d' => \$dump,
+ 'command-line|c' => \$cmdline,
+ 'options|o' => \$options,
+ 'target|t' => \$target,
+ 'environment|e' => \$envvars,
+ 'make-variables|m' => \$makevars,
+ 'build-parameters|b' => \$buildparams,
+ 'reconfigure|reconf|r' => \$reconf,
+ 'verbose|v' => \$verbose,
+ 'help' => \$help,
+ 'man' => \$man)
+ or die "Errors in command line arguments\n";
+
+ unless ($dump || $cmdline || $options || $target || $envvars || $makevars
+ || $buildparams || $reconf || $verbose || $help || $man) {
+ print STDERR <<"_____";
+You must give at least one option.
+For more information, do '$0 --help'
+_____
+ exit(2);
+ }
+
+ if ($help) {
+ pod2usage(-exitval => 0,
+ -verbose => 1);
+ }
+ if ($man) {
+ pod2usage(-exitval => 0,
+ -verbose => 2);
+ }
+ if ($dump || $cmdline) {
+ print "\nCommand line (with current working directory = $here):\n\n";
+ print ' ',join(' ',
+ $config{perl},
+ catfile($config{sourcedir}, 'Configure'),
+ @{$config{perlargv}}), "\n";
+ print "\nPerl information:\n\n";
+ print ' ',$config{perl_cmd},"\n";
+ print ' ',$config{perl_version},' for ',$config{perl_archname},"\n";
+ }
+ if ($dump || $options) {
+ my $longest = 0;
+ my $longest2 = 0;
+ foreach my $what (@disablables) {
+ $longest = length($what) if $longest < length($what);
+ $longest2 = length($disabled{$what})
+ if $disabled{$what} && $longest2 < length($disabled{$what});
+ }
+ print "\nEnabled features:\n\n";
+ foreach my $what (@disablables) {
+ print " $what\n" unless $disabled{$what};
+ }
+ print "\nDisabled features:\n\n";
+ foreach my $what (@disablables) {
+ if ($disabled{$what}) {
+ print " $what", ' ' x ($longest - length($what) + 1),
+ "[$disabled{$what}]", ' ' x ($longest2 - length($disabled{$what}) + 1);
+ print $disabled_info{$what}->{macro}
+ if $disabled_info{$what}->{macro};
+ print ' (skip ',
+ join(', ', @{$disabled_info{$what}->{skipped}}),
+ ')'
+ if $disabled_info{$what}->{skipped};
+ print "\n";
+ }
+ }
+ }
+ if ($dump || $target) {
+ print "\nConfig target attributes:\n\n";
+ foreach (sort keys %target) {
+ next if $_ =~ m|^_| || $_ eq 'template';
+ my $quotify = sub {
+ map { (my $x = $_) =~ s|([\\\$\@"])|\\$1|g; "\"$x\""} @_;
+ };
+ print ' ', $_, ' => ';
+ if (ref($target{$_}) eq "ARRAY") {
+ print '[ ', join(', ', $quotify->(@{$target{$_}})), " ],\n";
+ } else {
+ print $quotify->($target{$_}), ",\n"
+ }
+ }
+ }
+ if ($dump || $envvars) {
+ print "\nRecorded environment:\n\n";
+ foreach (sort keys %{$config{perlenv}}) {
+ print ' ',$_,' = ',($config{perlenv}->{$_} || ''),"\n";
+ }
+ }
+ if ($dump || $makevars) {
+ print "\nMakevars:\n\n";
+ foreach my $var (@makevars) {
+ my $prefix = '';
+ $prefix = $config{CROSS_COMPILE}
+ if grep { $var eq $_ } @user_crossable;
+ $prefix //= '';
+ print ' ',$var,' ' x (16 - length $var),'= ',
+ (ref $config{$var} eq 'ARRAY'
+ ? join(' ', @{$config{$var}})
+ : $prefix.$config{$var}),
+ "\n"
+ if defined $config{$var};
+ }
+
+ my @buildfile = ($config{builddir}, $config{build_file});
+ unshift @buildfile, $here
+ unless file_name_is_absolute($config{builddir});
+ my $buildfile = canonpath(catdir(@buildfile));
+ print <<"_____";
+
+NOTE: These variables only represent the configuration view. The build file
+template may have processed these variables further, please have a look at the
+build file for more exact data:
+ $buildfile
+_____
+ }
+ if ($dump || $buildparams) {
+ my @buildfile = ($config{builddir}, $config{build_file});
+ unshift @buildfile, $here
+ unless file_name_is_absolute($config{builddir});
+ print "\nbuild file:\n\n";
+ print " ", canonpath(catfile(@buildfile)),"\n";
+
+ print "\nbuild file templates:\n\n";
+ foreach (@{$config{build_file_templates}}) {
+ my @tmpl = ($_);
+ unshift @tmpl, $here
+ unless file_name_is_absolute($config{sourcedir});
+ print ' ',canonpath(catfile(@tmpl)),"\n";
+ }
+ }
+ if ($reconf) {
+ if ($verbose) {
+ print 'Reconfiguring with: ', join(' ',@{$config{perlargv}}), "\n";
+ foreach (sort keys %{$config{perlenv}}) {
+ print ' ',$_,' = ',($config{perlenv}->{$_} || ""),"\n";
+ }
+ }
+
+ chdir $here;
+ exec $^X,catfile($config{sourcedir}, 'Configure'),'reconf';
+ }
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+configdata.pm - configuration data for OpenSSL builds
+
+=head1 SYNOPSIS
+
+Interactive:
+
+ perl configdata.pm [options]
+
+As data bank module:
+
+ use configdata;
-print "\n";
-print "PROCESSOR =$config{processor}\n" if $config{processor};
-print "PERL =$config{perl}\n";
-print "PERLVERSION =$Config{version} for $Config{archname}\n";
-print "HASHBANGPERL =$config{hashbangperl}\n";
-print "DEFINES =",join(" ", @{$config{defines}}),"\n"
- if defined $config{defines};
-print "INCLUDES =",join(" ", @{$config{includes}}),"\n"
- if defined $config{includes};
-print "CPPFLAGS =",join(" ", @{$config{cppflags}}),"\n"
- if defined $config{cppflags};
-print "CC =$config{cross_compile_prefix}$config{cc}\n";
-print "CFLAGS =",join(" ", @{$config{cflags}}),"\n"
- if defined $config{cflags};
-print "CXX =$config{cross_compile_prefix}$config{cxx}\n"
- if defined $config{cxx};
-print "CXXFLAGS =",join(" ", @{$config{cxxflags}}),"\n"
- if defined $config{cxxflags};
-print "LD =$config{cross_compile_prefix}$config{ld}\n"
- if defined $config{ld};
-print "LDFLAGS =",join(" ", @{$config{lflags}}),"\n"
- if defined $config{lflags};
-print "EX_LIBS =",join(" ", @{$config{ex_libs}}),"\n"
- if defined $config{ex_libs};
+=head1 DESCRIPTION
+
+This module can be used in two modes, interactively and as a module containing
+all the data recorded by OpenSSL's Configure script.
+
+When used interactively, simply run it as any perl script, with at least one
+option, and you will get the information you ask for. See L</OPTIONS> below.
+
+When loaded as a module, you get a few databanks with useful information to
+perform build related tasks. The databanks are:
+
+ %config Configured things.
+ %target The OpenSSL config target with all inheritances
+ resolved.
+ %disabled The features that are disabled.
+ @disablables The list of features that can be disabled.
+ %withargs All data given through --with-THING options.
+ %unified_info All information that was computed from the build.info
+ files.
+
+=head1 OPTIONS
+
+=over 4
+
+=item B<--help>
+
+Print a brief help message and exit.
+
+=item B<--man>
+
+Print the manual page and exit.
+
+=item B<--dump> | B<-d>
+
+Print all relevant configuration data. This is equivalent to B<--command-line>
+B<--options> B<--target> B<--environment> B<--make-variables>
+B<--build-parameters>.
+
+=item B<--command-line> | B<-c>
+
+Print the current configuration command line.
+
+=item B<--options> | B<-o>
+
+Print the features, both enabled and disabled, and display defined macro and
+skipped directories where applicable.
+
+=item B<--target> | B<-t>
+
+Print the config attributes for this config target.
+
+=item B<--environment> | B<-e>
+
+Print the environment variables and their values at the time of configuration.
+
+=item B<--make-variables> | B<-m>
+
+Print the main make variables generated in the current configuration
+
+=item B<--build-parameters> | B<-b>
+
+Print the build parameters, i.e. build file and build file templates.
+
+=item B<--reconfigure> | B<--reconf> | B<-r>
+
+Redo the configuration.
+
+=item B<--verbose> | B<-v>
+
+Verbose output.
+
+=back
+
+=cut
+
+EOF
+close(OUT);
+if ($builder_platform eq 'unix') {
+ my $mode = (0755 & ~umask);
+ chmod $mode, 'configdata.pm'
+ or warn sprintf("WARNING: Couldn't change mode for 'configdata.pm' to 0%03o: %s\n",$mode,$!);
+}
my %builders = (
unified => sub {
+ print 'Creating ',$target{build_file},"\n";
run_dofile(catfile($blddir, $target{build_file}),
@{$config{build_file_templates}});
},
configuration.
EOF
+print <<"EOF";
+
+**********************************************************************
+*** ***
+*** If you want to report a building issue, please include the ***
+*** output from this command: ***
+*** ***
+*** perl configdata.pm --dump ***
+*** ***
+**********************************************************************
+EOF
+
exit(0);
######################################################################
return () if $^O eq 'VMS';
- die 'compiler_predefines called without a default compiler'
+ die 'compiler_predefined called without a default compiler'
unless $default_compiler;
if (! $predefined{$default_compiler}) {
- my $cc = "$config{cross_compile_prefix}$default_compiler";
+ my $cc = "$config{CROSS_COMPILE}$default_compiler";
$predefined{$default_compiler} = {};
"ld",
"lflags",
"loutflag",
- "plib_lflags",
"ex_libs",
"bn_ops",
"apps_aux_src",