openssl/util/mkdef.pl

418 lines
11 KiB
Perl
Raw Normal View History

#! /usr/bin/env perl
# Copyright 2018 The OpenSSL Project Authors. All Rights Reserved.
#
# Licensed under the Apache License 2.0 (the "License"). You may not use
# this file except in compliance with the License. You can obtain a copy
# in the file LICENSE in the source distribution or at
# https://www.openssl.org/source/license.html
# Generate a linker version script suitable for the given platform
# from a given ordinals file.
use strict;
use warnings;
use Getopt::Long;
use FindBin;
use lib "$FindBin::Bin/perl";
use OpenSSL::Ordinals;
use lib '.';
use configdata;
my $name = undef; # internal library/module name
my $ordinals_file = undef; # the ordinals file to use
my $version = undef; # the version to use for the library
my $OS = undef; # the operating system family
my $verbose = 0;
my $ctest = 0;
# For VMS, some modules may have case insensitive names
my $case_insensitive = 0;
GetOptions('name=s' => \$name,
'ordinals=s' => \$ordinals_file,
'version=s' => \$version,
'OS=s' => \$OS,
'ctest' => \$ctest,
'verbose' => \$verbose,
# For VMS
'case-insensitive' => \$case_insensitive)
or die "Error in command line arguments\n";
die "Please supply arguments\n"
unless $name && $ordinals_file && $OS;
# When building a "variant" shared library, with a custom SONAME, also customize
# all the symbol versions. This produces a shared object that can coexist
# without conflict in the same address space as a default build, or an object
# with a different variant tag.
#
# For example, with a target definition that includes:
#
# shlib_variant => "-opt",
#
# we build the following objects:
#
# $ perl -le '
# for (@ARGV) {
# if ($l = readlink) {
# printf "%s -> %s\n", $_, $l
# } else {
# print
# }
# }' *.so*
# libcrypto-opt.so.1.1
# libcrypto.so -> libcrypto-opt.so.1.1
# libssl-opt.so.1.1
# libssl.so -> libssl-opt.so.1.1
#
# whose SONAMEs and dependencies are:
#
# $ for l in *.so; do
# echo $l
# readelf -d $l | egrep 'SONAME|NEEDED.*(ssl|crypto)'
# done
# libcrypto.so
# 0x000000000000000e (SONAME) Library soname: [libcrypto-opt.so.1.1]
# libssl.so
# 0x0000000000000001 (NEEDED) Shared library: [libcrypto-opt.so.1.1]
# 0x000000000000000e (SONAME) Library soname: [libssl-opt.so.1.1]
#
# We case-fold the variant tag to upper case and replace all non-alnum
# characters with "_". This yields the following symbol versions:
#
# $ nm libcrypto.so | grep -w A
# 0000000000000000 A OPENSSL_OPT_1_1_0
# 0000000000000000 A OPENSSL_OPT_1_1_0a
# 0000000000000000 A OPENSSL_OPT_1_1_0c
# 0000000000000000 A OPENSSL_OPT_1_1_0d
# 0000000000000000 A OPENSSL_OPT_1_1_0f
# 0000000000000000 A OPENSSL_OPT_1_1_0g
# $ nm libssl.so | grep -w A
# 0000000000000000 A OPENSSL_OPT_1_1_0
# 0000000000000000 A OPENSSL_OPT_1_1_0d
#
(my $SO_VARIANT = uc($target{"shlib_variant"} // '')) =~ s/\W/_/g;
my $apiv = undef;
$apiv = sprintf "%x%02x%02x", split(/\./, $config{api})
if $config{api};
my $libname = $unified_info{sharednames}->{$name} // $name;
my %OS_data = (
solaris => { writer => \&writer_linux,
sort => sorter_linux(),
platforms => { UNIX => 1,
EXPORT_VAR_AS_FUNCTION => 0 } },
linux => 'solaris', # alias
"bsd-gcc" => 'solaris', # alias
aix => { writer => \&writer_aix,
sort => sorter_unix(),
platforms => { UNIX => 1,
EXPORT_VAR_AS_FUNCTION => 0 } },
VMS => { writer => \&writer_VMS,
sort => OpenSSL::Ordinals::by_number(),
platforms => { VMS => 1,
EXPORT_VAR_AS_FUNCTION => 0 } },
vms => 'VMS', # alias
WINDOWS => { writer => \&writer_windows,
sort => OpenSSL::Ordinals::by_name(),
platforms => { WIN32 => 1,
_WIN32 => 1,
EXPORT_VAR_AS_FUNCTION => 1 } },
windows => 'WINDOWS', # alias
WIN32 => 'WINDOWS', # alias
win32 => 'WIN32', # alias
32 => 'WIN32', # alias
NT => 'WIN32', # alias
nt => 'WIN32', # alias
mingw => 'WINDOWS', # alias
);
do {
die "Unknown operating system family $OS\n"
unless exists $OS_data{$OS};
$OS = $OS_data{$OS};
} while(ref($OS) eq '');
my %disabled_uc = map { my $x = uc $_; $x =~ s|-|_|g; $x => 1 } keys %disabled;
my %ordinal_opts = ();
$ordinal_opts{sort} = $OS->{sort} if $OS->{sort};
$ordinal_opts{filter} =
sub {
my $item = shift;
return
$item->exists()
&& platform_filter($item)
&& feature_filter($item);
};
my $ordinals = OpenSSL::Ordinals->new(from => $ordinals_file);
my $writer = $OS->{writer};
$writer = \&writer_ctest if $ctest;
$writer->($ordinals->items(%ordinal_opts));
exit 0;
sub platform_filter {
my $item = shift;
my %platforms = ( $item->platforms() );
# True if no platforms are defined
return 1 if scalar keys %platforms == 0;
# For any item platform tag, return the equivalence with the
# current platform settings if it exists there, return 0 otherwise
# if the item platform tag is true
for (keys %platforms) {
if (exists $OS->{platforms}->{$_}) {
return $platforms{$_} == $OS->{platforms}->{$_};
}
if ($platforms{$_}) {
return 0;
}
}
# Found no match? Then it's a go
return 1;
}
sub feature_filter {
my $item = shift;
my @features = ( $item->features() );
# True if no features are defined
return 1 if scalar @features == 0;
my $verdict = ! grep { $disabled_uc{$_} } @features;
if ($apiv) {
foreach (@features) {
next unless /^DEPRECATEDIN_(\d+)(?:_(\d+)_(\d+))?$/;
my $symdep = sprintf "%x%02x%02x", $1, ($2 // 0), ($3 // 0);
$verdict = 0 if $apiv ge $symdep;
}
}
return $verdict;
}
sub sorter_unix {
my $by_name = OpenSSL::Ordinals::by_name();
my %weight = (
'FUNCTION' => 1,
'VARIABLE' => 2
);
return sub {
my $item1 = shift;
my $item2 = shift;
my $verdict = $weight{$item1->type()} <=> $weight{$item2->type()};
if ($verdict == 0) {
$verdict = $by_name->($item1, $item2);
}
return $verdict;
};
}
sub sorter_linux {
my $by_version = OpenSSL::Ordinals::by_version();
my $by_unix = sorter_unix();
return sub {
my $item1 = shift;
my $item2 = shift;
my $verdict = $by_version->($item1, $item2);
if ($verdict == 0) {
$verdict = $by_unix->($item1, $item2);
}
return $verdict;
};
}
sub writer_linux {
my $thisversion = '';
my $currversion_s = '';
my $prevversion_s = '';
my $indent = 0;
for (@_) {
if ($thisversion && $_->version() ne $thisversion) {
die "$ordinals_file: It doesn't make sense to have both versioned ",
"and unversioned symbols"
if $thisversion eq '*';
print <<"_____";
}${prevversion_s};
_____
$prevversion_s = " OPENSSL${SO_VARIANT}_$thisversion";
$thisversion = ''; # Trigger start of next section
}
unless ($thisversion) {
$indent = 0;
$thisversion = $_->version();
$currversion_s = '';
$currversion_s = "OPENSSL${SO_VARIANT}_$thisversion "
if $thisversion ne '*';
print <<"_____";
${currversion_s}{
global:
_____
}
print ' ', $_->name(), ";\n";
}
print <<"_____";
local: *;
}${prevversion_s};
_____
1999-12-24 17:26:33 +00:00
}
sub writer_aix {
for (@_) {
print $_->name(),"\n";
}
Make a number of changes to the OS/2 build. Submitter's comment below. PR: 732 Submitted by: Ilya Zakharevich <nospam-abuse@ilyaz.org> Submitter's comment: This patch: a) Introduces a new file os2/backwardify.pl. b) Introduces a new mk1mf.pl variable $preamble. As you can see, it may be used also to move some OS-specific code to VC-CE too (the the first chunk of the patch); c) The DESCRIPTION specifier of the .def file is made more informative: now it contains the version number too. On OS/2 it is made conformant to OS/2 conventions; in particular, when one runs the standard command BLDLEVEL this.DLL one can see: Vendor: www.openssl.org/ Revision: 0.9.7c Description: OpenSSL: implementation of Secure Socket Layer; DLL for library crypto. Build for EMX -Zmtd [I did not make Win32 descriptions as informative as this - I'm afraid to break something. Be welcome to fix this.] d) On OS/2 the generated DLL was hardly usable (it had a shared initialized data segment). e) On OS/2 the generated DLLs had names like ssl.dll. However, DLL names on OS/2 are "global data". It is hard to have several DLLs with the same name on the system. Thus this precluded coexistence of OpenSSL with DLLs for other SLL implementations - or other name clashes. I transparently changed the names of the DLLs to open_ssl.dll and cryptssl.dll. f) The file added in (a) is used to create "forwarder" DLLs, so the applications expecting the "old" DLL names may use the new DLLs transparently. (A presence of these DLLs on the system nullifies (e), but makes old applications work. This is a stopgap measure until the old applications are relinked. Systems with no old applications do not need these DLLs, so may enjoy all the benefits of (e).) The new DLLs are placed in os2/ and os2/noname subdirectories. g) The makefiles created with os2/OS2-EMX.cmd did not work (some mysterious meaningless failures). The change to util/pl/OS2-EMX.pl uses the variable introduced in (b) to switch the Makefiles to SHELL=sh syntax. All these backslashes are removed, and the generated Makefiles started to work. h) Running os2/OS2-EMX.cmd now prints out what to do next.
2003-11-28 14:51:30 +00:00
}
sub writer_windows {
print <<"_____";
;
; Definition file for the DLL version of the $libname library from OpenSSL
;
LIBRARY $libname
EXPORTS
_____
for (@_) {
print " ",$_->name(),"\n";
}
}
sub collect_VMS_mixedcase {
return [ 'SPARE', 'SPARE' ] unless @_;
my $s = shift;
my $s_uc = uc($s);
my $type = shift;
return [ "$s=$type", 'SPARE' ] if $s_uc eq $s;
return [ "$s_uc/$s=$type", "$s=$type" ];
}
sub collect_VMS_uppercase {
return [ 'SPARE' ] unless @_;
my $s = shift;
my $s_uc = uc($s);
my $type = shift;
return [ "$s_uc=$type" ];
}
sub writer_VMS {
my @slot_collection = ();
my $collector =
$case_insensitive ? \&collect_VMS_uppercase : \&collect_VMS_mixedcase;
my $last_num = 0;
foreach (@_) {
while (++$last_num < $_->number()) {
push @slot_collection, $collector->(); # Just occupy a slot
}
my $type = {
FUNCTION => 'PROCEDURE',
VARIABLE => 'DATA'
} -> {$_->type()};
push @slot_collection, $collector->($_->name(), $type);
}
print <<"_____" if defined $version;
IDENTIFICATION=$version
_____
print <<"_____" unless $case_insensitive;
CASE_SENSITIVE=YES
_____
print <<"_____";
SYMBOL_VECTOR=(-
_____
# It's uncertain how long aggregated lines the linker can handle,
# but it has been observed that at least 1024 characters is ok.
# Either way, this means that we need to keep track of the total
# line length of each "SYMBOL_VECTOR" statement. Fortunately, we
# can have more than one of those...
my $symvtextcount = 16; # The length of "SYMBOL_VECTOR=("
while (@slot_collection) {
my $set = shift @slot_collection;
my $settextlength = 0;
foreach (@$set) {
$settextlength +=
+ 3 # two space indentation and comma
+ length($_)
+ 1 # postdent
;
}
$settextlength--; # only one space indentation on the first one
my $firstcomma = ',';
if ($symvtextcount + $settextlength > 1024) {
print <<"_____";
)
SYMBOL_VECTOR=(-
_____
$symvtextcount = 16; # The length of "SYMBOL_VECTOR=("
}
if ($symvtextcount == 16) {
$firstcomma = '';
}
my $indent = ' '.$firstcomma;
foreach (@$set) {
print <<"_____";
$indent$_ -
_____
$symvtextcount += length($indent) + length($_) + 1;
$indent = ' ,';
}
}
print <<"_____";
)
_____
if (defined $version) {
Switch to MAJOR.MINOR.PATCH versioning and version 3.0.0-dev We're strictly use version numbers of the form MAJOR.MINOR.PATCH. Letter releases are things of days past. The most central change is that we now express the version number with three macros, one for each part of the version number: OPENSSL_VERSION_MAJOR OPENSSL_VERSION_MINOR OPENSSL_VERSION_PATCH We also provide two additional macros to express pre-release and build metadata information (also specified in semantic versioning): OPENSSL_VERSION_PRE_RELEASE OPENSSL_VERSION_BUILD_METADATA To get the library's idea of all those values, we introduce the following functions: unsigned int OPENSSL_version_major(void); unsigned int OPENSSL_version_minor(void); unsigned int OPENSSL_version_patch(void); const char *OPENSSL_version_pre_release(void); const char *OPENSSL_version_build_metadata(void); Additionally, for shared library versioning (which is out of scope in semantic versioning, but that we still need): OPENSSL_SHLIB_VERSION We also provide a macro that contains the release date. This is not part of the version number, but is extra information that we want to be able to display: OPENSSL_RELEASE_DATE Finally, also provide the following convenience functions: const char *OPENSSL_version_text(void); const char *OPENSSL_version_text_full(void); The following macros and functions are deprecated, and while currently existing for backward compatibility, they are expected to disappear: OPENSSL_VERSION_NUMBER OPENSSL_VERSION_TEXT OPENSSL_VERSION OpenSSL_version_num() OpenSSL_version() Also, this function is introduced to replace OpenSSL_version() for all indexes except for OPENSSL_VERSION: OPENSSL_info() For configuration, the option 'newversion-only' is added to disable all the macros and functions that are mentioned as deprecated above. Reviewed-by: Tim Hudson <tjh@openssl.org> Reviewed-by: Matthias St. Pierre <Matthias.St.Pierre@ncp-e.com> Reviewed-by: Matt Caswell <matt@openssl.org> (Merged from https://github.com/openssl/openssl/pull/7724)
2018-09-27 13:56:35 +00:00
my ($libvmajor, $libvminor) = $version =~ /^(\d+)_(\d+)$/;
print <<"_____";
Switch to MAJOR.MINOR.PATCH versioning and version 3.0.0-dev We're strictly use version numbers of the form MAJOR.MINOR.PATCH. Letter releases are things of days past. The most central change is that we now express the version number with three macros, one for each part of the version number: OPENSSL_VERSION_MAJOR OPENSSL_VERSION_MINOR OPENSSL_VERSION_PATCH We also provide two additional macros to express pre-release and build metadata information (also specified in semantic versioning): OPENSSL_VERSION_PRE_RELEASE OPENSSL_VERSION_BUILD_METADATA To get the library's idea of all those values, we introduce the following functions: unsigned int OPENSSL_version_major(void); unsigned int OPENSSL_version_minor(void); unsigned int OPENSSL_version_patch(void); const char *OPENSSL_version_pre_release(void); const char *OPENSSL_version_build_metadata(void); Additionally, for shared library versioning (which is out of scope in semantic versioning, but that we still need): OPENSSL_SHLIB_VERSION We also provide a macro that contains the release date. This is not part of the version number, but is extra information that we want to be able to display: OPENSSL_RELEASE_DATE Finally, also provide the following convenience functions: const char *OPENSSL_version_text(void); const char *OPENSSL_version_text_full(void); The following macros and functions are deprecated, and while currently existing for backward compatibility, they are expected to disappear: OPENSSL_VERSION_NUMBER OPENSSL_VERSION_TEXT OPENSSL_VERSION OpenSSL_version_num() OpenSSL_version() Also, this function is introduced to replace OpenSSL_version() for all indexes except for OPENSSL_VERSION: OPENSSL_info() For configuration, the option 'newversion-only' is added to disable all the macros and functions that are mentioned as deprecated above. Reviewed-by: Tim Hudson <tjh@openssl.org> Reviewed-by: Matthias St. Pierre <Matthias.St.Pierre@ncp-e.com> Reviewed-by: Matt Caswell <matt@openssl.org> (Merged from https://github.com/openssl/openssl/pull/7724)
2018-09-27 13:56:35 +00:00
GSMATCH=LEQUAL,$libvmajor,$libvminor;
_____
}
}
sub writer_ctest {
print <<'_____';
/*
* Test file to check all DEF file symbols are present by trying
* to link to all of them. This is *not* intended to be run!
*/
int main()
{
_____
for (@_) {
if ($_->type() eq 'VARIABLE') {
print "\textern int ", $_->name(), '; /* type unknown */ /* ', $_->number(), ' ', $_->version(), " */\n";
} else {
print "\textern int ", $_->name(), '(); /* type unknown */ /* ', $_->number(), ' ', $_->version(), " */\n";
}
}
print <<'_____';
}
_____
}