1999-06-07 22:48:50 +00:00
|
|
|
#!/usr/local/bin/perl -w
|
1998-12-21 10:52:47 +00:00
|
|
|
#
|
|
|
|
|
# generate a .def file
|
|
|
|
|
#
|
|
|
|
|
# It does this by parsing the header files and looking for the
|
1999-04-26 00:23:10 +00:00
|
|
|
# prototyped functions: it then prunes the output.
|
1998-12-21 10:52:47 +00:00
|
|
|
#
|
2000-09-07 08:43:08 +00:00
|
|
|
# Intermediary files are created, call libeay.num and ssleay.num,...
|
|
|
|
|
# Previously, they had the following format:
|
|
|
|
|
#
|
|
|
|
|
# routine-name nnnn
|
|
|
|
|
#
|
|
|
|
|
# But that isn't enough for a number of reasons, the first on being that
|
|
|
|
|
# this format is (needlessly) very Win32-centric, and even then...
|
|
|
|
|
# One of the biggest problems is that there's no information about what
|
|
|
|
|
# routines should actually be used, which varies with what crypto algorithms
|
|
|
|
|
# are disabled. Also, some operating systems (for example VMS with VAX C)
|
|
|
|
|
# need to keep track of the global variables as well as the functions.
|
|
|
|
|
#
|
|
|
|
|
# So, a remake of this script is done so as to include information on the
|
|
|
|
|
# kind of symbol it is (function or variable) and what algorithms they're
|
|
|
|
|
# part of. This will allow easy translating to .def files or the corresponding
|
|
|
|
|
# file in other operating systems (a .opt file for VMS, possibly with a .mar
|
|
|
|
|
# file).
|
|
|
|
|
#
|
|
|
|
|
# The format now becomes:
|
|
|
|
|
#
|
|
|
|
|
# routine-name nnnn info
|
|
|
|
|
#
|
|
|
|
|
# and the "info" part is actually a colon-separated string of fields with
|
|
|
|
|
# the following meaning:
|
|
|
|
|
#
|
|
|
|
|
# existence:platform:kind:algorithms
|
|
|
|
|
#
|
|
|
|
|
# - "existence" can be "EXIST" or "NOEXIST" depending on if the symbol is
|
|
|
|
|
# found somewhere in the source,
|
|
|
|
|
# - "platforms" is empty if it exists on all platforms, otherwise it contains
|
|
|
|
|
# comma-separated list of the platform, just as they are if the symbol exists
|
|
|
|
|
# for those platforms, or prepended with a "!" if not. This helps resolve
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
# symbol name variants for platforms where the names are too long for the
|
2000-09-07 08:43:08 +00:00
|
|
|
# compiler or linker, or if the systems is case insensitive and there is a
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
# clash, or the symbol is implemented differently (see
|
|
|
|
|
# EXPORT_VAR_AS_FUNCTION). This script assumes renaming of symbols is found
|
|
|
|
|
# in the file crypto/symhacks.h.
|
|
|
|
|
# The semantics for the platforms is that every item is checked against the
|
2002-07-10 17:34:54 +00:00
|
|
|
# environment. For the negative items ("!FOO"), if any of them is false
|
|
|
|
|
# (i.e. "FOO" is true) in the environment, the corresponding symbol can't be
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
# used. For the positive itms, if all of them are false in the environment,
|
|
|
|
|
# the corresponding symbol can't be used. Any combination of positive and
|
|
|
|
|
# negative items are possible, and of course leave room for some redundancy.
|
2000-09-07 08:43:08 +00:00
|
|
|
# - "kind" is "FUNCTION" or "VARIABLE". The meaning of that is obvious.
|
|
|
|
|
# - "algorithms" is a comma-separated list of algorithm names. This helps
|
|
|
|
|
# exclude symbols that are part of an algorithm that some user wants to
|
|
|
|
|
# exclude.
|
|
|
|
|
#
|
1998-12-21 10:52:47 +00:00
|
|
|
|
2001-02-21 14:12:03 +00:00
|
|
|
my $debug=0;
|
|
|
|
|
|
2000-09-07 08:43:08 +00:00
|
|
|
my $crypto_num= "util/libeay.num";
|
|
|
|
|
my $ssl_num= "util/ssleay.num";
|
2002-07-17 13:27:43 +00:00
|
|
|
my $libname;
|
1998-12-21 10:52:47 +00:00
|
|
|
|
1999-04-26 00:23:10 +00:00
|
|
|
my $do_update = 0;
|
2001-05-13 04:48:07 +00:00
|
|
|
my $do_rewrite = 1;
|
1999-04-26 00:23:10 +00:00
|
|
|
my $do_crypto = 0;
|
|
|
|
|
my $do_ssl = 0;
|
2000-01-07 03:17:47 +00:00
|
|
|
my $do_ctest = 0;
|
2000-08-17 21:26:22 +00:00
|
|
|
my $do_ctestall = 0;
|
2001-02-09 13:16:21 +00:00
|
|
|
my $do_checkexist = 0;
|
1999-04-26 00:23:10 +00:00
|
|
|
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
my $VMSVAX=0;
|
2009-05-15 16:01:42 +00:00
|
|
|
my $VMSNonVAX=0;
|
2000-09-07 08:43:08 +00:00
|
|
|
my $VMS=0;
|
|
|
|
|
my $W32=0;
|
|
|
|
|
my $W16=0;
|
2000-01-07 03:17:47 +00:00
|
|
|
my $NT=0;
|
2002-07-17 13:27:43 +00:00
|
|
|
my $OS2=0;
|
1999-04-14 23:44:41 +00:00
|
|
|
# Set this to make typesafe STACK definitions appear in DEF
|
2000-06-01 05:13:52 +00:00
|
|
|
my $safe_stack_def = 0;
|
1999-05-13 10:28:14 +00:00
|
|
|
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
my @known_platforms = ( "__FreeBSD__", "PERL5", "NeXT",
|
2011-06-06 15:46:25 +00:00
|
|
|
"EXPORT_VAR_AS_FUNCTION", "ZLIB", "OPENSSL_FIPS" );
|
2002-07-17 13:27:43 +00:00
|
|
|
my @known_ossl_platforms = ( "VMS", "WIN16", "WIN32", "WINNT", "OS2" );
|
2000-09-07 08:43:08 +00:00
|
|
|
my @known_algorithms = ( "RC2", "RC4", "RC5", "IDEA", "DES", "BF",
|
2000-12-29 00:05:14 +00:00
|
|
|
"CAST", "MD2", "MD4", "MD5", "SHA", "SHA0", "SHA1",
|
2004-05-19 17:03:59 +00:00
|
|
|
"SHA256", "SHA512", "RIPEMD",
|
2011-06-06 11:49:36 +00:00
|
|
|
"MDC2", "WHIRLPOOL", "RSA", "DSA", "DH", "EC", "ECDH", "ECDSA", "EC2M",
|
2007-04-23 23:48:59 +00:00
|
|
|
"HMAC", "AES", "CAMELLIA", "SEED", "GOST",
|
2011-10-19 08:58:35 +00:00
|
|
|
# EC_NISTP_64_GCC_128
|
|
|
|
|
"EC_NISTP_64_GCC_128",
|
2000-12-29 00:05:14 +00:00
|
|
|
# Envelope "algorithms"
|
|
|
|
|
"EVP", "X509", "ASN1_TYPEDEFS",
|
|
|
|
|
# Helper "algorithms"
|
|
|
|
|
"BIO", "COMP", "BUFFER", "LHASH", "STACK", "ERR",
|
|
|
|
|
"LOCKING",
|
|
|
|
|
# External "algorithms"
|
2005-04-26 18:21:25 +00:00
|
|
|
"FP_API", "STDIO", "SOCK", "KRB5", "DGRAM",
|
2002-10-24 19:09:03 +00:00
|
|
|
# Engines
|
2005-04-19 13:24:44 +00:00
|
|
|
"STATIC_ENGINE", "ENGINE", "HW", "GMP",
|
2006-11-30 13:39:34 +00:00
|
|
|
# RFC3779
|
|
|
|
|
"RFC3779",
|
2006-04-17 12:08:22 +00:00
|
|
|
# TLS
|
2011-12-31 23:49:45 +00:00
|
|
|
"TLSEXT", "PSK", "SRP", "HEARTBEATS",
|
2008-03-12 21:14:28 +00:00
|
|
|
# CMS
|
|
|
|
|
"CMS",
|
2008-06-01 11:07:34 +00:00
|
|
|
# CryptoAPI Engine
|
|
|
|
|
"CAPIENG",
|
2009-04-04 17:57:34 +00:00
|
|
|
# SSL v2
|
|
|
|
|
"SSL2",
|
2016-03-09 17:10:52 +00:00
|
|
|
# SSL v2 method
|
|
|
|
|
"SSL2_METHOD",
|
2014-10-29 12:51:31 +00:00
|
|
|
# SSL v3 method
|
|
|
|
|
"SSL3_METHOD",
|
2008-11-24 17:27:08 +00:00
|
|
|
# JPAKE
|
|
|
|
|
"JPAKE",
|
2011-11-21 22:35:35 +00:00
|
|
|
# NEXTPROTONEG
|
|
|
|
|
"NEXTPROTONEG",
|
2002-12-09 02:18:16 +00:00
|
|
|
# Deprecated functions
|
2011-05-12 13:12:49 +00:00
|
|
|
"DEPRECATED",
|
|
|
|
|
# Hide SSL internals
|
2011-12-25 14:47:46 +00:00
|
|
|
"SSL_INTERN",
|
|
|
|
|
# SCTP
|
2014-07-23 12:18:06 +00:00
|
|
|
"SCTP",
|
2014-10-15 00:23:07 +00:00
|
|
|
# SRTP
|
|
|
|
|
"SRTP",
|
2014-07-23 12:18:06 +00:00
|
|
|
# Unit testing
|
|
|
|
|
"UNIT_TEST");
|
2000-09-07 08:43:08 +00:00
|
|
|
|
2000-01-07 03:17:47 +00:00
|
|
|
my $options="";
|
2005-04-13 19:09:43 +00:00
|
|
|
open(IN,"<Makefile") || die "unable to open Makefile!\n";
|
1999-05-13 10:28:14 +00:00
|
|
|
while(<IN>) {
|
|
|
|
|
$options=$1 if (/^OPTIONS=(.*)$/);
|
|
|
|
|
}
|
1999-05-13 17:24:35 +00:00
|
|
|
close(IN);
|
1999-05-13 10:28:14 +00:00
|
|
|
|
2000-01-07 03:17:47 +00:00
|
|
|
# The following ciphers may be excluded (by Configure). This means functions
|
|
|
|
|
# defined with ifndef(NO_XXX) are not included in the .def file, and everything
|
|
|
|
|
# in directory xxx is ignored.
|
|
|
|
|
my $no_rc2; my $no_rc4; my $no_rc5; my $no_idea; my $no_des; my $no_bf;
|
2007-04-23 23:48:59 +00:00
|
|
|
my $no_cast; my $no_whirlpool; my $no_camellia; my $no_seed;
|
2000-08-14 14:05:53 +00:00
|
|
|
my $no_md2; my $no_md4; my $no_md5; my $no_sha; my $no_ripemd; my $no_mdc2;
|
2001-02-09 18:16:12 +00:00
|
|
|
my $no_rsa; my $no_dsa; my $no_dh; my $no_hmac=0; my $no_aes; my $no_krb5;
|
2003-01-30 20:03:45 +00:00
|
|
|
my $no_ec; my $no_ecdsa; my $no_ecdh; my $no_engine; my $no_hw;
|
2005-11-06 20:51:49 +00:00
|
|
|
my $no_fp_api; my $no_static_engine=1; my $no_gmp; my $no_deprecated;
|
2008-06-01 11:07:34 +00:00
|
|
|
my $no_rfc3779; my $no_psk; my $no_tlsext; my $no_cms; my $no_capieng;
|
2011-06-06 11:49:36 +00:00
|
|
|
my $no_jpake; my $no_srp; my $no_ssl2; my $no_ec2m; my $no_nistp_gcc;
|
2014-10-15 00:23:07 +00:00
|
|
|
my $no_nextprotoneg; my $no_sctp; my $no_srtp;
|
2016-03-09 17:10:52 +00:00
|
|
|
my $no_unit_test; my $no_ssl3_method; my $no_ssl2_method;
|
2008-03-12 21:14:28 +00:00
|
|
|
|
2011-06-06 15:46:25 +00:00
|
|
|
my $fips;
|
|
|
|
|
|
2008-03-12 21:14:28 +00:00
|
|
|
my $zlib;
|
2005-04-19 13:24:44 +00:00
|
|
|
|
2000-01-07 03:17:47 +00:00
|
|
|
|
1999-05-13 10:28:14 +00:00
|
|
|
foreach (@ARGV, split(/ /, $options))
|
1998-12-21 10:52:47 +00:00
|
|
|
{
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
$debug=1 if $_ eq "debug";
|
1999-03-03 02:01:26 +00:00
|
|
|
$W32=1 if $_ eq "32";
|
2000-09-07 08:43:08 +00:00
|
|
|
$W16=1 if $_ eq "16";
|
1999-03-03 02:01:26 +00:00
|
|
|
if($_ eq "NT") {
|
|
|
|
|
$W32 = 1;
|
|
|
|
|
$NT = 1;
|
|
|
|
|
}
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
if ($_ eq "VMS-VAX") {
|
|
|
|
|
$VMS=1;
|
|
|
|
|
$VMSVAX=1;
|
|
|
|
|
}
|
2009-05-15 16:01:42 +00:00
|
|
|
if ($_ eq "VMS-NonVAX") {
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
$VMS=1;
|
2009-05-15 16:01:42 +00:00
|
|
|
$VMSNonVAX=1;
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
}
|
2000-09-07 08:43:08 +00:00
|
|
|
$VMS=1 if $_ eq "VMS";
|
2002-07-17 13:27:43 +00:00
|
|
|
$OS2=1 if $_ eq "OS2";
|
2011-06-06 15:46:25 +00:00
|
|
|
$fips=1 if /^fips/;
|
2009-02-25 11:55:15 +00:00
|
|
|
if ($_ eq "zlib" || $_ eq "enable-zlib" || $_ eq "zlib-dynamic"
|
2008-03-12 21:14:28 +00:00
|
|
|
|| $_ eq "enable-zlib-dynamic") {
|
|
|
|
|
$zlib = 1;
|
|
|
|
|
}
|
|
|
|
|
|
1998-12-21 10:52:47 +00:00
|
|
|
$do_ssl=1 if $_ eq "ssleay";
|
2002-07-17 13:27:43 +00:00
|
|
|
if ($_ eq "ssl") {
|
|
|
|
|
$do_ssl=1;
|
|
|
|
|
$libname=$_
|
|
|
|
|
}
|
1998-12-21 10:52:47 +00:00
|
|
|
$do_crypto=1 if $_ eq "libeay";
|
2002-07-17 13:27:43 +00:00
|
|
|
if ($_ eq "crypto") {
|
|
|
|
|
$do_crypto=1;
|
|
|
|
|
$libname=$_;
|
|
|
|
|
}
|
2005-11-06 17:58:26 +00:00
|
|
|
$no_static_engine=1 if $_ eq "no-static-engine";
|
|
|
|
|
$no_static_engine=0 if $_ eq "enable-static-engine";
|
1999-02-11 01:39:30 +00:00
|
|
|
$do_update=1 if $_ eq "update";
|
2000-09-07 08:43:08 +00:00
|
|
|
$do_rewrite=1 if $_ eq "rewrite";
|
1999-12-24 17:26:33 +00:00
|
|
|
$do_ctest=1 if $_ eq "ctest";
|
2000-08-17 21:26:22 +00:00
|
|
|
$do_ctestall=1 if $_ eq "ctestall";
|
2001-02-09 13:16:21 +00:00
|
|
|
$do_checkexist=1 if $_ eq "exist";
|
2000-06-18 14:06:40 +00:00
|
|
|
#$safe_stack_def=1 if $_ eq "-DDEBUG_SAFESTACK";
|
1999-05-08 10:42:06 +00:00
|
|
|
|
|
|
|
|
if (/^no-rc2$/) { $no_rc2=1; }
|
|
|
|
|
elsif (/^no-rc4$/) { $no_rc4=1; }
|
|
|
|
|
elsif (/^no-rc5$/) { $no_rc5=1; }
|
|
|
|
|
elsif (/^no-idea$/) { $no_idea=1; }
|
2000-09-25 10:21:23 +00:00
|
|
|
elsif (/^no-des$/) { $no_des=1; $no_mdc2=1; }
|
1999-05-08 10:42:06 +00:00
|
|
|
elsif (/^no-bf$/) { $no_bf=1; }
|
|
|
|
|
elsif (/^no-cast$/) { $no_cast=1; }
|
2005-12-05 00:53:10 +00:00
|
|
|
elsif (/^no-whirlpool$/) { $no_whirlpool=1; }
|
1999-05-08 10:42:06 +00:00
|
|
|
elsif (/^no-md2$/) { $no_md2=1; }
|
2000-08-14 14:05:53 +00:00
|
|
|
elsif (/^no-md4$/) { $no_md4=1; }
|
1999-05-08 10:42:06 +00:00
|
|
|
elsif (/^no-md5$/) { $no_md5=1; }
|
|
|
|
|
elsif (/^no-sha$/) { $no_sha=1; }
|
|
|
|
|
elsif (/^no-ripemd$/) { $no_ripemd=1; }
|
|
|
|
|
elsif (/^no-mdc2$/) { $no_mdc2=1; }
|
|
|
|
|
elsif (/^no-rsa$/) { $no_rsa=1; }
|
|
|
|
|
elsif (/^no-dsa$/) { $no_dsa=1; }
|
|
|
|
|
elsif (/^no-dh$/) { $no_dh=1; }
|
2001-03-10 01:56:48 +00:00
|
|
|
elsif (/^no-ec$/) { $no_ec=1; }
|
2002-02-13 18:21:51 +00:00
|
|
|
elsif (/^no-ecdsa$/) { $no_ecdsa=1; }
|
2002-08-09 08:43:04 +00:00
|
|
|
elsif (/^no-ecdh$/) { $no_ecdh=1; }
|
1999-05-08 10:42:06 +00:00
|
|
|
elsif (/^no-hmac$/) { $no_hmac=1; }
|
2001-02-09 13:16:21 +00:00
|
|
|
elsif (/^no-aes$/) { $no_aes=1; }
|
2006-06-09 15:44:59 +00:00
|
|
|
elsif (/^no-camellia$/) { $no_camellia=1; }
|
2007-04-23 23:48:59 +00:00
|
|
|
elsif (/^no-seed$/) { $no_seed=1; }
|
2000-12-29 00:05:14 +00:00
|
|
|
elsif (/^no-evp$/) { $no_evp=1; }
|
|
|
|
|
elsif (/^no-lhash$/) { $no_lhash=1; }
|
|
|
|
|
elsif (/^no-stack$/) { $no_stack=1; }
|
|
|
|
|
elsif (/^no-err$/) { $no_err=1; }
|
|
|
|
|
elsif (/^no-buffer$/) { $no_buffer=1; }
|
|
|
|
|
elsif (/^no-bio$/) { $no_bio=1; }
|
|
|
|
|
#elsif (/^no-locking$/) { $no_locking=1; }
|
|
|
|
|
elsif (/^no-comp$/) { $no_comp=1; }
|
|
|
|
|
elsif (/^no-dso$/) { $no_dso=1; }
|
2001-02-09 18:16:12 +00:00
|
|
|
elsif (/^no-krb5$/) { $no_krb5=1; }
|
2003-01-30 17:39:26 +00:00
|
|
|
elsif (/^no-engine$/) { $no_engine=1; }
|
2003-01-30 20:03:45 +00:00
|
|
|
elsif (/^no-hw$/) { $no_hw=1; }
|
2005-04-19 13:24:44 +00:00
|
|
|
elsif (/^no-gmp$/) { $no_gmp=1; }
|
2006-11-30 13:39:34 +00:00
|
|
|
elsif (/^no-rfc3779$/) { $no_rfc3779=1; }
|
2007-08-12 23:59:05 +00:00
|
|
|
elsif (/^no-tlsext$/) { $no_tlsext=1; }
|
2008-03-12 21:14:28 +00:00
|
|
|
elsif (/^no-cms$/) { $no_cms=1; }
|
2011-06-06 11:49:36 +00:00
|
|
|
elsif (/^no-ec2m$/) { $no_ec2m=1; }
|
2011-10-21 12:53:07 +00:00
|
|
|
elsif (/^no-ec_nistp_64_gcc_128$/) { $no_nistp_gcc=1; }
|
2011-11-21 22:35:35 +00:00
|
|
|
elsif (/^no-nextprotoneg$/) { $no_nextprotoneg=1; }
|
2009-04-04 17:57:34 +00:00
|
|
|
elsif (/^no-ssl2$/) { $no_ssl2=1; }
|
2016-03-09 17:10:52 +00:00
|
|
|
elsif (/^no-ssl2-method$/) { $no_ssl2_method=1; }
|
2014-10-29 12:51:31 +00:00
|
|
|
elsif (/^no-ssl3-method$/) { $no_ssl3_method=1; }
|
2008-06-01 11:07:34 +00:00
|
|
|
elsif (/^no-capieng$/) { $no_capieng=1; }
|
2008-11-24 17:27:08 +00:00
|
|
|
elsif (/^no-jpake$/) { $no_jpake=1; }
|
2011-03-16 11:26:40 +00:00
|
|
|
elsif (/^no-srp$/) { $no_srp=1; }
|
2011-12-25 14:47:46 +00:00
|
|
|
elsif (/^no-sctp$/) { $no_sctp=1; }
|
2014-10-15 00:23:07 +00:00
|
|
|
elsif (/^no-srtp$/) { $no_srtp=1; }
|
2014-07-23 12:18:06 +00:00
|
|
|
elsif (/^no-unit-test$/){ $no_unit_test=1; }
|
1998-12-21 10:52:47 +00:00
|
|
|
}
|
|
|
|
|
|
1999-12-24 17:26:33 +00:00
|
|
|
|
2002-07-17 13:27:43 +00:00
|
|
|
if (!$libname) {
|
|
|
|
|
if ($do_ssl) {
|
|
|
|
|
$libname="SSLEAY";
|
|
|
|
|
}
|
|
|
|
|
if ($do_crypto) {
|
|
|
|
|
$libname="LIBEAY";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2000-09-07 08:43:08 +00:00
|
|
|
# If no platform is given, assume WIN32
|
2002-07-17 13:27:43 +00:00
|
|
|
if ($W32 + $W16 + $VMS + $OS2 == 0) {
|
2000-09-07 08:43:08 +00:00
|
|
|
$W32 = 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
# Add extra knowledge
|
|
|
|
|
if ($W16) {
|
|
|
|
|
$no_fp_api=1;
|
|
|
|
|
}
|
|
|
|
|
|
1998-12-21 10:52:47 +00:00
|
|
|
if (!$do_ssl && !$do_crypto)
|
|
|
|
|
{
|
2002-07-17 13:27:43 +00:00
|
|
|
print STDERR "usage: $0 ( ssl | crypto ) [ 16 | 32 | NT | OS2 ]\n";
|
1998-12-21 10:52:47 +00:00
|
|
|
exit(1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
%ssl_list=&load_numbers($ssl_num);
|
1999-02-11 01:39:30 +00:00
|
|
|
$max_ssl = $max_num;
|
1998-12-21 10:52:47 +00:00
|
|
|
%crypto_list=&load_numbers($crypto_num);
|
1999-02-11 01:39:30 +00:00
|
|
|
$max_crypto = $max_num;
|
1998-12-21 10:52:47 +00:00
|
|
|
|
2000-01-07 03:17:47 +00:00
|
|
|
my $ssl="ssl/ssl.h";
|
2000-12-29 00:05:14 +00:00
|
|
|
$ssl.=" ssl/kssl.h";
|
2006-04-17 12:08:22 +00:00
|
|
|
$ssl.=" ssl/tls1.h";
|
2011-11-21 22:55:12 +00:00
|
|
|
$ssl.=" ssl/srtp.h";
|
1998-12-21 10:52:47 +00:00
|
|
|
|
2000-01-07 03:17:47 +00:00
|
|
|
my $crypto ="crypto/crypto.h";
|
2011-11-22 14:44:42 +00:00
|
|
|
$crypto.=" crypto/cryptlib.h";
|
2004-07-12 11:24:55 +00:00
|
|
|
$crypto.=" crypto/o_dir.h";
|
2011-03-22 23:54:15 +00:00
|
|
|
$crypto.=" crypto/o_str.h";
|
|
|
|
|
$crypto.=" crypto/o_time.h";
|
2001-10-24 21:21:12 +00:00
|
|
|
$crypto.=" crypto/des/des.h crypto/des/des_old.h" ; # unless $no_des;
|
2001-04-26 12:01:12 +00:00
|
|
|
$crypto.=" crypto/idea/idea.h" ; # unless $no_idea;
|
|
|
|
|
$crypto.=" crypto/rc4/rc4.h" ; # unless $no_rc4;
|
|
|
|
|
$crypto.=" crypto/rc5/rc5.h" ; # unless $no_rc5;
|
|
|
|
|
$crypto.=" crypto/rc2/rc2.h" ; # unless $no_rc2;
|
|
|
|
|
$crypto.=" crypto/bf/blowfish.h" ; # unless $no_bf;
|
|
|
|
|
$crypto.=" crypto/cast/cast.h" ; # unless $no_cast;
|
2005-12-05 00:53:10 +00:00
|
|
|
$crypto.=" crypto/whrlpool/whrlpool.h" ;
|
2001-04-26 12:01:12 +00:00
|
|
|
$crypto.=" crypto/md2/md2.h" ; # unless $no_md2;
|
|
|
|
|
$crypto.=" crypto/md4/md4.h" ; # unless $no_md4;
|
|
|
|
|
$crypto.=" crypto/md5/md5.h" ; # unless $no_md5;
|
|
|
|
|
$crypto.=" crypto/mdc2/mdc2.h" ; # unless $no_mdc2;
|
|
|
|
|
$crypto.=" crypto/sha/sha.h" ; # unless $no_sha;
|
|
|
|
|
$crypto.=" crypto/ripemd/ripemd.h" ; # unless $no_ripemd;
|
2002-01-02 16:55:35 +00:00
|
|
|
$crypto.=" crypto/aes/aes.h" ; # unless $no_aes;
|
2006-06-09 15:44:59 +00:00
|
|
|
$crypto.=" crypto/camellia/camellia.h" ; # unless $no_camellia;
|
2007-04-23 23:48:59 +00:00
|
|
|
$crypto.=" crypto/seed/seed.h"; # unless $no_seed;
|
1998-12-21 10:52:47 +00:00
|
|
|
|
|
|
|
|
$crypto.=" crypto/bn/bn.h";
|
2001-04-26 12:01:12 +00:00
|
|
|
$crypto.=" crypto/rsa/rsa.h" ; # unless $no_rsa;
|
|
|
|
|
$crypto.=" crypto/dsa/dsa.h" ; # unless $no_dsa;
|
|
|
|
|
$crypto.=" crypto/dh/dh.h" ; # unless $no_dh;
|
|
|
|
|
$crypto.=" crypto/ec/ec.h" ; # unless $no_ec;
|
2002-02-13 18:21:51 +00:00
|
|
|
$crypto.=" crypto/ecdsa/ecdsa.h" ; # unless $no_ecdsa;
|
2002-08-09 08:43:04 +00:00
|
|
|
$crypto.=" crypto/ecdh/ecdh.h" ; # unless $no_ecdh;
|
2001-04-26 12:01:12 +00:00
|
|
|
$crypto.=" crypto/hmac/hmac.h" ; # unless $no_hmac;
|
2011-06-10 14:12:55 +00:00
|
|
|
$crypto.=" crypto/cmac/cmac.h" ; # unless $no_hmac;
|
1998-12-21 10:52:47 +00:00
|
|
|
|
2003-01-30 17:39:26 +00:00
|
|
|
$crypto.=" crypto/engine/engine.h"; # unless $no_engine;
|
2001-04-26 12:01:12 +00:00
|
|
|
$crypto.=" crypto/stack/stack.h" ; # unless $no_stack;
|
|
|
|
|
$crypto.=" crypto/buffer/buffer.h" ; # unless $no_buffer;
|
|
|
|
|
$crypto.=" crypto/bio/bio.h" ; # unless $no_bio;
|
|
|
|
|
$crypto.=" crypto/dso/dso.h" ; # unless $no_dso;
|
|
|
|
|
$crypto.=" crypto/lhash/lhash.h" ; # unless $no_lhash;
|
1998-12-21 10:52:47 +00:00
|
|
|
$crypto.=" crypto/conf/conf.h";
|
|
|
|
|
$crypto.=" crypto/txt_db/txt_db.h";
|
|
|
|
|
|
2001-04-26 12:01:12 +00:00
|
|
|
$crypto.=" crypto/evp/evp.h" ; # unless $no_evp;
|
1998-12-21 10:52:47 +00:00
|
|
|
$crypto.=" crypto/objects/objects.h";
|
|
|
|
|
$crypto.=" crypto/pem/pem.h";
|
|
|
|
|
#$crypto.=" crypto/meth/meth.h";
|
|
|
|
|
$crypto.=" crypto/asn1/asn1.h";
|
2000-12-16 01:19:24 +00:00
|
|
|
$crypto.=" crypto/asn1/asn1t.h";
|
1998-12-21 10:52:47 +00:00
|
|
|
$crypto.=" crypto/asn1/asn1_mac.h";
|
2001-04-26 12:01:12 +00:00
|
|
|
$crypto.=" crypto/err/err.h" ; # unless $no_err;
|
1998-12-21 10:52:47 +00:00
|
|
|
$crypto.=" crypto/pkcs7/pkcs7.h";
|
1999-03-29 17:50:26 +00:00
|
|
|
$crypto.=" crypto/pkcs12/pkcs12.h";
|
1998-12-21 10:52:47 +00:00
|
|
|
$crypto.=" crypto/x509/x509.h";
|
|
|
|
|
$crypto.=" crypto/x509/x509_vfy.h";
|
1999-01-30 17:35:01 +00:00
|
|
|
$crypto.=" crypto/x509v3/x509v3.h";
|
2006-02-12 23:11:56 +00:00
|
|
|
$crypto.=" crypto/ts/ts.h";
|
1998-12-21 10:52:47 +00:00
|
|
|
$crypto.=" crypto/rand/rand.h";
|
2001-04-26 12:01:12 +00:00
|
|
|
$crypto.=" crypto/comp/comp.h" ; # unless $no_comp;
|
2000-10-27 11:05:35 +00:00
|
|
|
$crypto.=" crypto/ocsp/ocsp.h";
|
2001-05-13 04:48:07 +00:00
|
|
|
$crypto.=" crypto/ui/ui.h crypto/ui/ui_compat.h";
|
2001-07-11 15:14:22 +00:00
|
|
|
$crypto.=" crypto/krb5/krb5_asn.h";
|
2008-06-04 11:45:15 +00:00
|
|
|
#$crypto.=" crypto/store/store.h";
|
2005-04-27 16:27:14 +00:00
|
|
|
$crypto.=" crypto/pqueue/pqueue.h";
|
2008-03-12 21:14:28 +00:00
|
|
|
$crypto.=" crypto/cms/cms.h";
|
2008-10-27 12:31:13 +00:00
|
|
|
$crypto.=" crypto/jpake/jpake.h";
|
2010-07-25 17:48:35 +00:00
|
|
|
$crypto.=" crypto/modes/modes.h";
|
2011-03-16 11:26:40 +00:00
|
|
|
$crypto.=" crypto/srp/srp.h";
|
1998-12-21 10:52:47 +00:00
|
|
|
|
2000-09-07 08:43:08 +00:00
|
|
|
my $symhacks="crypto/symhacks.h";
|
1999-02-11 01:39:30 +00:00
|
|
|
|
2000-09-07 08:43:08 +00:00
|
|
|
my @ssl_symbols = &do_defs("SSLEAY", $ssl, $symhacks);
|
|
|
|
|
my @crypto_symbols = &do_defs("LIBEAY", $crypto, $symhacks);
|
1999-04-26 00:23:10 +00:00
|
|
|
|
1999-02-11 01:39:30 +00:00
|
|
|
if ($do_update) {
|
|
|
|
|
|
|
|
|
|
if ($do_ssl == 1) {
|
2000-09-07 08:43:08 +00:00
|
|
|
|
|
|
|
|
&maybe_add_info("SSLEAY",*ssl_list,@ssl_symbols);
|
|
|
|
|
if ($do_rewrite == 1) {
|
|
|
|
|
open(OUT, ">$ssl_num");
|
|
|
|
|
&rewrite_numbers(*OUT,"SSLEAY",*ssl_list,@ssl_symbols);
|
|
|
|
|
} else {
|
|
|
|
|
open(OUT, ">>$ssl_num");
|
|
|
|
|
}
|
|
|
|
|
&update_numbers(*OUT,"SSLEAY",*ssl_list,$max_ssl,@ssl_symbols);
|
1999-02-11 01:39:30 +00:00
|
|
|
close OUT;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if($do_crypto == 1) {
|
2000-09-07 08:43:08 +00:00
|
|
|
|
|
|
|
|
&maybe_add_info("LIBEAY",*crypto_list,@crypto_symbols);
|
|
|
|
|
if ($do_rewrite == 1) {
|
|
|
|
|
open(OUT, ">$crypto_num");
|
|
|
|
|
&rewrite_numbers(*OUT,"LIBEAY",*crypto_list,@crypto_symbols);
|
|
|
|
|
} else {
|
|
|
|
|
open(OUT, ">>$crypto_num");
|
|
|
|
|
}
|
|
|
|
|
&update_numbers(*OUT,"LIBEAY",*crypto_list,$max_crypto,@crypto_symbols);
|
1999-02-11 01:39:30 +00:00
|
|
|
close OUT;
|
1999-12-24 17:26:33 +00:00
|
|
|
}
|
|
|
|
|
|
2001-02-09 13:16:21 +00:00
|
|
|
} elsif ($do_checkexist) {
|
|
|
|
|
&check_existing(*ssl_list, @ssl_symbols)
|
|
|
|
|
if $do_ssl == 1;
|
|
|
|
|
&check_existing(*crypto_list, @crypto_symbols)
|
|
|
|
|
if $do_crypto == 1;
|
2000-08-17 21:26:22 +00:00
|
|
|
} elsif ($do_ctest || $do_ctestall) {
|
1999-12-24 17:26:33 +00:00
|
|
|
|
|
|
|
|
print <<"EOF";
|
|
|
|
|
|
|
|
|
|
/* 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()
|
|
|
|
|
{
|
|
|
|
|
EOF
|
2000-09-07 08:43:08 +00:00
|
|
|
&print_test_file(*STDOUT,"SSLEAY",*ssl_list,$do_ctestall,@ssl_symbols)
|
1999-12-24 17:26:33 +00:00
|
|
|
if $do_ssl == 1;
|
|
|
|
|
|
2000-09-07 08:43:08 +00:00
|
|
|
&print_test_file(*STDOUT,"LIBEAY",*crypto_list,$do_ctestall,@crypto_symbols)
|
1999-12-24 17:26:33 +00:00
|
|
|
if $do_crypto == 1;
|
|
|
|
|
|
|
|
|
|
print "}\n";
|
1999-02-11 01:39:30 +00:00
|
|
|
|
|
|
|
|
} else {
|
1999-05-08 10:42:06 +00:00
|
|
|
|
2002-07-17 13:27:43 +00:00
|
|
|
&print_def_file(*STDOUT,$libname,*ssl_list,@ssl_symbols)
|
1999-02-11 01:39:30 +00:00
|
|
|
if $do_ssl == 1;
|
|
|
|
|
|
2002-07-17 13:27:43 +00:00
|
|
|
&print_def_file(*STDOUT,$libname,*crypto_list,@crypto_symbols)
|
1999-02-11 01:39:30 +00:00
|
|
|
if $do_crypto == 1;
|
1999-05-08 10:42:06 +00:00
|
|
|
|
1999-02-11 01:39:30 +00:00
|
|
|
}
|
1998-12-21 10:52:47 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
sub do_defs
|
1999-04-26 00:23:10 +00:00
|
|
|
{
|
2000-09-07 08:43:08 +00:00
|
|
|
my($name,$files,$symhacksfile)=@_;
|
2000-01-07 03:17:47 +00:00
|
|
|
my $file;
|
1999-04-26 00:23:10 +00:00
|
|
|
my @ret;
|
2000-09-07 08:43:08 +00:00
|
|
|
my %syms;
|
|
|
|
|
my %platform; # For anything undefined, we assume ""
|
|
|
|
|
my %kind; # For anything undefined, we assume "FUNCTION"
|
|
|
|
|
my %algorithm; # For anything undefined, we assume ""
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
my %variant;
|
|
|
|
|
my %variant_cnt; # To be able to allocate "name{n}" if "name"
|
|
|
|
|
# is the same name as the original.
|
2000-01-07 03:17:47 +00:00
|
|
|
my $cpp;
|
2000-12-29 00:05:14 +00:00
|
|
|
my %unknown_algorithms = ();
|
1998-12-21 10:52:47 +00:00
|
|
|
|
2000-09-07 08:43:08 +00:00
|
|
|
foreach $file (split(/\s+/,$symhacksfile." ".$files))
|
1998-12-21 10:52:47 +00:00
|
|
|
{
|
2001-09-26 15:06:45 +00:00
|
|
|
print STDERR "DEBUG: starting on $file:\n" if $debug;
|
1998-12-21 10:52:47 +00:00
|
|
|
open(IN,"<$file") || die "unable to open $file:$!\n";
|
2000-01-07 03:17:47 +00:00
|
|
|
my $line = "", my $def= "";
|
1999-04-26 00:23:10 +00:00
|
|
|
my %tag = (
|
2001-02-21 14:12:03 +00:00
|
|
|
(map { $_ => 0 } @known_platforms),
|
|
|
|
|
(map { "OPENSSL_SYS_".$_ => 0 } @known_ossl_platforms),
|
2001-02-19 16:06:34 +00:00
|
|
|
(map { "OPENSSL_NO_".$_ => 0 } @known_algorithms),
|
1999-04-26 00:23:10 +00:00
|
|
|
NOPROTO => 0,
|
|
|
|
|
PERL5 => 0,
|
|
|
|
|
_WINDLL => 0,
|
|
|
|
|
CONST_STRICT => 0,
|
|
|
|
|
TRUE => 1,
|
|
|
|
|
);
|
2000-09-07 08:43:08 +00:00
|
|
|
my $symhacking = $file eq $symhacksfile;
|
2001-02-19 13:33:04 +00:00
|
|
|
my @current_platforms = ();
|
|
|
|
|
my @current_algorithms = ();
|
|
|
|
|
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
# params: symbol, alias, platforms, kind
|
|
|
|
|
# The reason to put this subroutine in a variable is that
|
|
|
|
|
# it will otherwise create it's own, unshared, version of
|
|
|
|
|
# %tag and %variant...
|
|
|
|
|
my $make_variant = sub
|
|
|
|
|
{
|
|
|
|
|
my ($s, $a, $p, $k) = @_;
|
|
|
|
|
my ($a1, $a2);
|
|
|
|
|
|
|
|
|
|
print STDERR "DEBUG: make_variant: Entered with ",$s,", ",$a,", ",(defined($p)?$p:""),", ",(defined($k)?$k:""),"\n" if $debug;
|
|
|
|
|
if (defined($p))
|
|
|
|
|
{
|
|
|
|
|
$a1 = join(",",$p,
|
|
|
|
|
grep(!/^$/,
|
|
|
|
|
map { $tag{$_} == 1 ? $_ : "" }
|
|
|
|
|
@known_platforms));
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
$a1 = join(",",
|
|
|
|
|
grep(!/^$/,
|
|
|
|
|
map { $tag{$_} == 1 ? $_ : "" }
|
|
|
|
|
@known_platforms));
|
|
|
|
|
}
|
|
|
|
|
$a2 = join(",",
|
|
|
|
|
grep(!/^$/,
|
|
|
|
|
map { $tag{"OPENSSL_SYS_".$_} == 1 ? $_ : "" }
|
|
|
|
|
@known_ossl_platforms));
|
|
|
|
|
print STDERR "DEBUG: make_variant: a1 = $a1; a2 = $a2\n" if $debug;
|
|
|
|
|
if ($a1 eq "") { $a1 = $a2; }
|
|
|
|
|
elsif ($a1 ne "" && $a2 ne "") { $a1 .= ",".$a2; }
|
|
|
|
|
if ($a eq $s)
|
|
|
|
|
{
|
|
|
|
|
if (!defined($variant_cnt{$s}))
|
|
|
|
|
{
|
|
|
|
|
$variant_cnt{$s} = 0;
|
|
|
|
|
}
|
|
|
|
|
$variant_cnt{$s}++;
|
|
|
|
|
$a .= "{$variant_cnt{$s}}";
|
|
|
|
|
}
|
2001-03-02 12:14:54 +00:00
|
|
|
my $toadd = $a.":".$a1.(defined($k)?":".$k:"");
|
|
|
|
|
my $togrep = $s.'(\{[0-9]+\})?:'.$a1.(defined($k)?":".$k:"");
|
|
|
|
|
if (!grep(/^$togrep$/,
|
|
|
|
|
split(/;/, defined($variant{$s})?$variant{$s}:""))) {
|
|
|
|
|
if (defined($variant{$s})) { $variant{$s} .= ";"; }
|
|
|
|
|
$variant{$s} .= $toadd;
|
|
|
|
|
}
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
print STDERR "DEBUG: make_variant: Exit with variant of ",$s," = ",$variant{$s},"\n" if $debug;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
print STDERR "DEBUG: parsing ----------\n" if $debug;
|
1999-04-26 00:23:10 +00:00
|
|
|
while(<IN>) {
|
2005-04-19 18:57:17 +00:00
|
|
|
if (/\/\* Error codes for the \w+ functions\. \*\//)
|
|
|
|
|
{
|
|
|
|
|
undef @tag;
|
|
|
|
|
last;
|
|
|
|
|
}
|
1999-04-26 00:23:10 +00:00
|
|
|
if ($line ne '') {
|
|
|
|
|
$_ = $line . $_;
|
|
|
|
|
$line = '';
|
1998-12-21 10:52:47 +00:00
|
|
|
}
|
1999-04-26 00:23:10 +00:00
|
|
|
|
|
|
|
|
if (/\\$/) {
|
2001-02-21 14:12:03 +00:00
|
|
|
chomp; # remove eol
|
|
|
|
|
chop; # remove ending backslash
|
1999-04-26 00:23:10 +00:00
|
|
|
$line = $_;
|
|
|
|
|
next;
|
|
|
|
|
}
|
|
|
|
|
|
2006-01-02 12:13:07 +00:00
|
|
|
if(/\/\*/) {
|
|
|
|
|
if (not /\*\//) { # multiline comment...
|
|
|
|
|
$line = $_; # ... just accumulate
|
|
|
|
|
next;
|
|
|
|
|
} else {
|
|
|
|
|
s/\/\*.*?\*\///gs;# wipe it
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
1999-04-26 00:23:10 +00:00
|
|
|
if ($cpp) {
|
2006-01-02 12:13:07 +00:00
|
|
|
$cpp++ if /^#\s*if/;
|
|
|
|
|
$cpp-- if /^#\s*endif/;
|
1999-04-26 00:23:10 +00:00
|
|
|
next;
|
|
|
|
|
}
|
2006-01-02 12:13:07 +00:00
|
|
|
$cpp = 1 if /^#.*ifdef.*cplusplus/;
|
1999-04-26 00:23:10 +00:00
|
|
|
|
|
|
|
|
s/{[^{}]*}//gs; # ignore {} blocks
|
2002-10-24 19:09:03 +00:00
|
|
|
print STDERR "DEBUG: \$def=\"$def\"\n" if $debug && $def ne "";
|
2001-02-21 14:12:03 +00:00
|
|
|
print STDERR "DEBUG: \$_=\"$_\"\n" if $debug;
|
2000-12-29 00:05:14 +00:00
|
|
|
if (/^\#\s*ifndef\s+(.*)/) {
|
2001-02-21 14:12:03 +00:00
|
|
|
push(@tag,"-");
|
1998-12-21 10:52:47 +00:00
|
|
|
push(@tag,$1);
|
|
|
|
|
$tag{$1}=-1;
|
2001-02-21 14:12:03 +00:00
|
|
|
print STDERR "DEBUG: $file: found tag $1 = -1\n" if $debug;
|
2000-12-29 00:05:14 +00:00
|
|
|
} elsif (/^\#\s*if\s+!defined\(([^\)]+)\)/) {
|
2001-02-21 14:12:03 +00:00
|
|
|
push(@tag,"-");
|
|
|
|
|
if (/^\#\s*if\s+(!defined\(([^\)]+)\)(\s+\&\&\s+!defined\(([^\)]+)\))*)$/) {
|
|
|
|
|
my $tmp_1 = $1;
|
|
|
|
|
my $tmp_;
|
|
|
|
|
foreach $tmp_ (split '\&\&',$tmp_1) {
|
|
|
|
|
$tmp_ =~ /!defined\(([^\)]+)\)/;
|
|
|
|
|
print STDERR "DEBUG: $file: found tag $1 = -1\n" if $debug;
|
|
|
|
|
push(@tag,$1);
|
|
|
|
|
$tag{$1}=-1;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
print STDERR "Warning: $file: complicated expression: $_" if $debug; # because it is O...
|
|
|
|
|
print STDERR "DEBUG: $file: found tag $1 = -1\n" if $debug;
|
|
|
|
|
push(@tag,$1);
|
|
|
|
|
$tag{$1}=-1;
|
|
|
|
|
}
|
2005-02-05 17:22:14 +00:00
|
|
|
} elsif (/^\#\s*ifdef\s+(\S*)/) {
|
2001-02-21 14:12:03 +00:00
|
|
|
push(@tag,"-");
|
1998-12-21 10:52:47 +00:00
|
|
|
push(@tag,$1);
|
|
|
|
|
$tag{$1}=1;
|
2001-02-21 14:12:03 +00:00
|
|
|
print STDERR "DEBUG: $file: found tag $1 = 1\n" if $debug;
|
2000-12-29 00:05:14 +00:00
|
|
|
} elsif (/^\#\s*if\s+defined\(([^\)]+)\)/) {
|
2001-02-21 14:12:03 +00:00
|
|
|
push(@tag,"-");
|
|
|
|
|
if (/^\#\s*if\s+(defined\(([^\)]+)\)(\s+\|\|\s+defined\(([^\)]+)\))*)$/) {
|
|
|
|
|
my $tmp_1 = $1;
|
|
|
|
|
my $tmp_;
|
|
|
|
|
foreach $tmp_ (split '\|\|',$tmp_1) {
|
|
|
|
|
$tmp_ =~ /defined\(([^\)]+)\)/;
|
|
|
|
|
print STDERR "DEBUG: $file: found tag $1 = 1\n" if $debug;
|
|
|
|
|
push(@tag,$1);
|
|
|
|
|
$tag{$1}=1;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
print STDERR "Warning: $file: complicated expression: $_\n" if $debug; # because it is O...
|
|
|
|
|
print STDERR "DEBUG: $file: found tag $1 = 1\n" if $debug;
|
|
|
|
|
push(@tag,$1);
|
|
|
|
|
$tag{$1}=1;
|
|
|
|
|
}
|
2000-09-07 08:43:08 +00:00
|
|
|
} elsif (/^\#\s*error\s+(\w+) is disabled\./) {
|
2001-02-21 14:12:03 +00:00
|
|
|
my $tag_i = $#tag;
|
|
|
|
|
while($tag[$tag_i] ne "-") {
|
|
|
|
|
if ($tag[$tag_i] eq "OPENSSL_NO_".$1) {
|
|
|
|
|
$tag{$tag[$tag_i]}=2;
|
|
|
|
|
print STDERR "DEBUG: $file: chaged tag $1 = 2\n" if $debug;
|
|
|
|
|
}
|
|
|
|
|
$tag_i--;
|
2000-09-07 08:43:08 +00:00
|
|
|
}
|
1999-04-26 00:23:10 +00:00
|
|
|
} elsif (/^\#\s*endif/) {
|
2001-02-21 14:12:03 +00:00
|
|
|
my $tag_i = $#tag;
|
2004-05-19 17:03:59 +00:00
|
|
|
while($tag_i > 0 && $tag[$tag_i] ne "-") {
|
2001-02-21 14:12:03 +00:00
|
|
|
my $t=$tag[$tag_i];
|
|
|
|
|
print STDERR "DEBUG: \$t=\"$t\"\n" if $debug;
|
|
|
|
|
if ($tag{$t}==2) {
|
|
|
|
|
$tag{$t}=-1;
|
|
|
|
|
} else {
|
|
|
|
|
$tag{$t}=0;
|
|
|
|
|
}
|
|
|
|
|
print STDERR "DEBUG: $file: changed tag ",$t," = ",$tag{$t},"\n" if $debug;
|
|
|
|
|
pop(@tag);
|
|
|
|
|
if ($t =~ /^OPENSSL_NO_([A-Z0-9_]+)$/) {
|
|
|
|
|
$t=$1;
|
|
|
|
|
} else {
|
|
|
|
|
$t="";
|
|
|
|
|
}
|
|
|
|
|
if ($t ne ""
|
|
|
|
|
&& !grep(/^$t$/, @known_algorithms)) {
|
|
|
|
|
$unknown_algorithms{$t} = 1;
|
|
|
|
|
#print STDERR "DEBUG: Added as unknown algorithm: $t\n" if $debug;
|
|
|
|
|
}
|
|
|
|
|
$tag_i--;
|
2000-09-07 08:43:08 +00:00
|
|
|
}
|
1998-12-21 10:52:47 +00:00
|
|
|
pop(@tag);
|
1999-04-26 00:23:10 +00:00
|
|
|
} elsif (/^\#\s*else/) {
|
2001-02-21 14:12:03 +00:00
|
|
|
my $tag_i = $#tag;
|
|
|
|
|
while($tag[$tag_i] ne "-") {
|
|
|
|
|
my $t=$tag[$tag_i];
|
|
|
|
|
$tag{$t}= -$tag{$t};
|
|
|
|
|
print STDERR "DEBUG: $file: changed tag ",$t," = ",$tag{$t},"\n" if $debug;
|
|
|
|
|
$tag_i--;
|
|
|
|
|
}
|
1999-04-26 00:23:10 +00:00
|
|
|
} elsif (/^\#\s*if\s+1/) {
|
2001-02-21 14:12:03 +00:00
|
|
|
push(@tag,"-");
|
1999-04-26 00:23:10 +00:00
|
|
|
# Dummy tag
|
|
|
|
|
push(@tag,"TRUE");
|
|
|
|
|
$tag{"TRUE"}=1;
|
2001-02-21 14:12:03 +00:00
|
|
|
print STDERR "DEBUG: $file: found 1\n" if $debug;
|
1999-09-03 13:30:47 +00:00
|
|
|
} elsif (/^\#\s*if\s+0/) {
|
2001-02-21 14:12:03 +00:00
|
|
|
push(@tag,"-");
|
1999-09-03 13:30:47 +00:00
|
|
|
# Dummy tag
|
|
|
|
|
push(@tag,"TRUE");
|
|
|
|
|
$tag{"TRUE"}=-1;
|
2001-02-21 14:12:03 +00:00
|
|
|
print STDERR "DEBUG: $file: found 0\n" if $debug;
|
2000-09-07 08:43:08 +00:00
|
|
|
} elsif (/^\#\s*define\s+(\w+)\s+(\w+)/
|
2001-02-22 13:24:17 +00:00
|
|
|
&& $symhacking && $tag{'TRUE'} != -1) {
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
# This is for aliasing. When we find an alias,
|
|
|
|
|
# we have to invert
|
|
|
|
|
&$make_variant($1,$2);
|
|
|
|
|
print STDERR "DEBUG: $file: defined $1 = $2\n" if $debug;
|
2000-09-07 08:43:08 +00:00
|
|
|
}
|
|
|
|
|
if (/^\#/) {
|
2001-02-19 13:33:04 +00:00
|
|
|
@current_platforms =
|
|
|
|
|
grep(!/^$/,
|
2001-02-21 14:12:03 +00:00
|
|
|
map { $tag{$_} == 1 ? $_ :
|
|
|
|
|
$tag{$_} == -1 ? "!".$_ : "" }
|
2001-02-19 13:33:04 +00:00
|
|
|
@known_platforms);
|
2001-02-21 14:12:03 +00:00
|
|
|
push @current_platforms
|
|
|
|
|
, grep(!/^$/,
|
|
|
|
|
map { $tag{"OPENSSL_SYS_".$_} == 1 ? $_ :
|
|
|
|
|
$tag{"OPENSSL_SYS_".$_} == -1 ? "!".$_ : "" }
|
|
|
|
|
@known_ossl_platforms);
|
2001-02-19 13:33:04 +00:00
|
|
|
@current_algorithms =
|
|
|
|
|
grep(!/^$/,
|
2001-02-19 16:06:34 +00:00
|
|
|
map { $tag{"OPENSSL_NO_".$_} == -1 ? $_ : "" }
|
2001-02-19 13:33:04 +00:00
|
|
|
@known_algorithms);
|
|
|
|
|
$def .=
|
|
|
|
|
"#INFO:"
|
|
|
|
|
.join(',',@current_platforms).":"
|
|
|
|
|
.join(',',@current_algorithms).";";
|
1999-04-26 00:23:10 +00:00
|
|
|
next;
|
|
|
|
|
}
|
2001-02-22 13:24:17 +00:00
|
|
|
if ($tag{'TRUE'} != -1) {
|
|
|
|
|
if (/^\s*DECLARE_STACK_OF\s*\(\s*(\w*)\s*\)/) {
|
|
|
|
|
next;
|
|
|
|
|
} elsif (/^\s*DECLARE_ASN1_ENCODE_FUNCTIONS\s*\(\s*(\w*)\s*,\s*(\w*)\s*,\s*(\w*)\s*\)/) {
|
|
|
|
|
$def .= "int d2i_$3(void);";
|
|
|
|
|
$def .= "int i2d_$3(void);";
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
# Variant for platforms that do not
|
|
|
|
|
# have to access globale variables
|
|
|
|
|
# in shared libraries through functions
|
|
|
|
|
$def .=
|
|
|
|
|
"#INFO:"
|
|
|
|
|
.join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"
|
|
|
|
|
.join(',',@current_algorithms).";";
|
2001-02-22 13:24:17 +00:00
|
|
|
$def .= "OPENSSL_EXTERN int $2_it;";
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
$def .=
|
|
|
|
|
"#INFO:"
|
|
|
|
|
.join(',',@current_platforms).":"
|
|
|
|
|
.join(',',@current_algorithms).";";
|
|
|
|
|
# Variant for platforms that have to
|
|
|
|
|
# access globale variables in shared
|
|
|
|
|
# libraries through functions
|
|
|
|
|
&$make_variant("$2_it","$2_it",
|
|
|
|
|
"EXPORT_VAR_AS_FUNCTION",
|
|
|
|
|
"FUNCTION");
|
2001-02-22 13:24:17 +00:00
|
|
|
next;
|
|
|
|
|
} elsif (/^\s*DECLARE_ASN1_FUNCTIONS_fname\s*\(\s*(\w*)\s*,\s*(\w*)\s*,\s*(\w*)\s*\)/) {
|
|
|
|
|
$def .= "int d2i_$3(void);";
|
|
|
|
|
$def .= "int i2d_$3(void);";
|
|
|
|
|
$def .= "int $3_free(void);";
|
|
|
|
|
$def .= "int $3_new(void);";
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
# Variant for platforms that do not
|
|
|
|
|
# have to access globale variables
|
|
|
|
|
# in shared libraries through functions
|
|
|
|
|
$def .=
|
|
|
|
|
"#INFO:"
|
|
|
|
|
.join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"
|
|
|
|
|
.join(',',@current_algorithms).";";
|
2001-02-22 13:24:17 +00:00
|
|
|
$def .= "OPENSSL_EXTERN int $2_it;";
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
$def .=
|
|
|
|
|
"#INFO:"
|
|
|
|
|
.join(',',@current_platforms).":"
|
|
|
|
|
.join(',',@current_algorithms).";";
|
|
|
|
|
# Variant for platforms that have to
|
|
|
|
|
# access globale variables in shared
|
|
|
|
|
# libraries through functions
|
|
|
|
|
&$make_variant("$2_it","$2_it",
|
|
|
|
|
"EXPORT_VAR_AS_FUNCTION",
|
|
|
|
|
"FUNCTION");
|
|
|
|
|
next;
|
2001-02-22 13:24:17 +00:00
|
|
|
} elsif (/^\s*DECLARE_ASN1_FUNCTIONS\s*\(\s*(\w*)\s*\)/ ||
|
|
|
|
|
/^\s*DECLARE_ASN1_FUNCTIONS_const\s*\(\s*(\w*)\s*\)/) {
|
|
|
|
|
$def .= "int d2i_$1(void);";
|
|
|
|
|
$def .= "int i2d_$1(void);";
|
|
|
|
|
$def .= "int $1_free(void);";
|
|
|
|
|
$def .= "int $1_new(void);";
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
# Variant for platforms that do not
|
|
|
|
|
# have to access globale variables
|
|
|
|
|
# in shared libraries through functions
|
|
|
|
|
$def .=
|
|
|
|
|
"#INFO:"
|
|
|
|
|
.join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"
|
|
|
|
|
.join(',',@current_algorithms).";";
|
2001-02-22 13:24:17 +00:00
|
|
|
$def .= "OPENSSL_EXTERN int $1_it;";
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
$def .=
|
|
|
|
|
"#INFO:"
|
|
|
|
|
.join(',',@current_platforms).":"
|
|
|
|
|
.join(',',@current_algorithms).";";
|
|
|
|
|
# Variant for platforms that have to
|
|
|
|
|
# access globale variables in shared
|
|
|
|
|
# libraries through functions
|
|
|
|
|
&$make_variant("$1_it","$1_it",
|
|
|
|
|
"EXPORT_VAR_AS_FUNCTION",
|
|
|
|
|
"FUNCTION");
|
2001-02-22 13:24:17 +00:00
|
|
|
next;
|
|
|
|
|
} elsif (/^\s*DECLARE_ASN1_ENCODE_FUNCTIONS_const\s*\(\s*(\w*)\s*,\s*(\w*)\s*\)/) {
|
|
|
|
|
$def .= "int d2i_$2(void);";
|
|
|
|
|
$def .= "int i2d_$2(void);";
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
# Variant for platforms that do not
|
|
|
|
|
# have to access globale variables
|
|
|
|
|
# in shared libraries through functions
|
|
|
|
|
$def .=
|
|
|
|
|
"#INFO:"
|
|
|
|
|
.join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"
|
|
|
|
|
.join(',',@current_algorithms).";";
|
2001-02-22 13:24:17 +00:00
|
|
|
$def .= "OPENSSL_EXTERN int $2_it;";
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
$def .=
|
|
|
|
|
"#INFO:"
|
|
|
|
|
.join(',',@current_platforms).":"
|
|
|
|
|
.join(',',@current_algorithms).";";
|
|
|
|
|
# Variant for platforms that have to
|
|
|
|
|
# access globale variables in shared
|
|
|
|
|
# libraries through functions
|
|
|
|
|
&$make_variant("$2_it","$2_it",
|
|
|
|
|
"EXPORT_VAR_AS_FUNCTION",
|
|
|
|
|
"FUNCTION");
|
2001-02-22 13:24:17 +00:00
|
|
|
next;
|
2003-03-20 17:58:33 +00:00
|
|
|
} elsif (/^\s*DECLARE_ASN1_ALLOC_FUNCTIONS\s*\(\s*(\w*)\s*\)/) {
|
|
|
|
|
$def .= "int $1_free(void);";
|
|
|
|
|
$def .= "int $1_new(void);";
|
|
|
|
|
next;
|
2001-02-22 13:24:17 +00:00
|
|
|
} elsif (/^\s*DECLARE_ASN1_FUNCTIONS_name\s*\(\s*(\w*)\s*,\s*(\w*)\s*\)/) {
|
|
|
|
|
$def .= "int d2i_$2(void);";
|
|
|
|
|
$def .= "int i2d_$2(void);";
|
|
|
|
|
$def .= "int $2_free(void);";
|
|
|
|
|
$def .= "int $2_new(void);";
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
# Variant for platforms that do not
|
|
|
|
|
# have to access globale variables
|
|
|
|
|
# in shared libraries through functions
|
|
|
|
|
$def .=
|
|
|
|
|
"#INFO:"
|
|
|
|
|
.join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"
|
|
|
|
|
.join(',',@current_algorithms).";";
|
2001-02-22 13:24:17 +00:00
|
|
|
$def .= "OPENSSL_EXTERN int $2_it;";
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
$def .=
|
|
|
|
|
"#INFO:"
|
|
|
|
|
.join(',',@current_platforms).":"
|
|
|
|
|
.join(',',@current_algorithms).";";
|
|
|
|
|
# Variant for platforms that have to
|
|
|
|
|
# access globale variables in shared
|
|
|
|
|
# libraries through functions
|
|
|
|
|
&$make_variant("$2_it","$2_it",
|
|
|
|
|
"EXPORT_VAR_AS_FUNCTION",
|
|
|
|
|
"FUNCTION");
|
2001-02-22 13:24:17 +00:00
|
|
|
next;
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
} elsif (/^\s*DECLARE_ASN1_ITEM\s*\(\s*(\w*)\s*\)/) {
|
|
|
|
|
# Variant for platforms that do not
|
|
|
|
|
# have to access globale variables
|
|
|
|
|
# in shared libraries through functions
|
|
|
|
|
$def .=
|
|
|
|
|
"#INFO:"
|
|
|
|
|
.join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"
|
|
|
|
|
.join(',',@current_algorithms).";";
|
2001-02-22 13:24:17 +00:00
|
|
|
$def .= "OPENSSL_EXTERN int $1_it;";
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
$def .=
|
|
|
|
|
"#INFO:"
|
|
|
|
|
.join(',',@current_platforms).":"
|
|
|
|
|
.join(',',@current_algorithms).";";
|
|
|
|
|
# Variant for platforms that have to
|
|
|
|
|
# access globale variables in shared
|
|
|
|
|
# libraries through functions
|
|
|
|
|
&$make_variant("$1_it","$1_it",
|
|
|
|
|
"EXPORT_VAR_AS_FUNCTION",
|
|
|
|
|
"FUNCTION");
|
2001-02-22 13:24:17 +00:00
|
|
|
next;
|
2002-10-04 20:24:50 +00:00
|
|
|
} elsif (/^\s*DECLARE_ASN1_NDEF_FUNCTION\s*\(\s*(\w*)\s*\)/) {
|
2002-10-05 01:38:58 +00:00
|
|
|
$def .= "int i2d_$1_NDEF(void);";
|
2001-02-22 13:24:17 +00:00
|
|
|
} elsif (/^\s*DECLARE_ASN1_SET_OF\s*\(\s*(\w*)\s*\)/) {
|
|
|
|
|
next;
|
2005-11-06 20:33:33 +00:00
|
|
|
} elsif (/^\s*DECLARE_ASN1_PRINT_FUNCTION\s*\(\s*(\w*)\s*\)/) {
|
|
|
|
|
$def .= "int $1_print_ctx(void);";
|
|
|
|
|
next;
|
|
|
|
|
} elsif (/^\s*DECLARE_ASN1_PRINT_FUNCTION_name\s*\(\s*(\w*)\s*,\s*(\w*)\s*\)/) {
|
|
|
|
|
$def .= "int $2_print_ctx(void);";
|
|
|
|
|
next;
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
} elsif (/^\s*DECLARE_PKCS12_STACK_OF\s*\(\s*(\w*)\s*\)/) {
|
|
|
|
|
next;
|
2001-02-22 13:24:17 +00:00
|
|
|
} elsif (/^DECLARE_PEM_rw\s*\(\s*(\w*)\s*,/ ||
|
2005-07-24 21:45:45 +00:00
|
|
|
/^DECLARE_PEM_rw_cb\s*\(\s*(\w*)\s*,/ ||
|
|
|
|
|
/^DECLARE_PEM_rw_const\s*\(\s*(\w*)\s*,/ ) {
|
2001-02-22 13:24:17 +00:00
|
|
|
# Things not in Win16
|
|
|
|
|
$def .=
|
|
|
|
|
"#INFO:"
|
|
|
|
|
.join(',',"!WIN16",@current_platforms).":"
|
|
|
|
|
.join(',',@current_algorithms).";";
|
|
|
|
|
$def .= "int PEM_read_$1(void);";
|
|
|
|
|
$def .= "int PEM_write_$1(void);";
|
|
|
|
|
$def .=
|
|
|
|
|
"#INFO:"
|
|
|
|
|
.join(',',@current_platforms).":"
|
|
|
|
|
.join(',',@current_algorithms).";";
|
|
|
|
|
# Things that are everywhere
|
|
|
|
|
$def .= "int PEM_read_bio_$1(void);";
|
|
|
|
|
$def .= "int PEM_write_bio_$1(void);";
|
|
|
|
|
next;
|
|
|
|
|
} elsif (/^DECLARE_PEM_write\s*\(\s*(\w*)\s*,/ ||
|
|
|
|
|
/^DECLARE_PEM_write_cb\s*\(\s*(\w*)\s*,/ ) {
|
|
|
|
|
# Things not in Win16
|
|
|
|
|
$def .=
|
|
|
|
|
"#INFO:"
|
|
|
|
|
.join(',',"!WIN16",@current_platforms).":"
|
|
|
|
|
.join(',',@current_algorithms).";";
|
|
|
|
|
$def .= "int PEM_write_$1(void);";
|
|
|
|
|
$def .=
|
|
|
|
|
"#INFO:"
|
|
|
|
|
.join(',',@current_platforms).":"
|
|
|
|
|
.join(',',@current_algorithms).";";
|
|
|
|
|
# Things that are everywhere
|
|
|
|
|
$def .= "int PEM_write_bio_$1(void);";
|
|
|
|
|
next;
|
|
|
|
|
} elsif (/^DECLARE_PEM_read\s*\(\s*(\w*)\s*,/ ||
|
|
|
|
|
/^DECLARE_PEM_read_cb\s*\(\s*(\w*)\s*,/ ) {
|
|
|
|
|
# Things not in Win16
|
|
|
|
|
$def .=
|
|
|
|
|
"#INFO:"
|
|
|
|
|
.join(',',"!WIN16",@current_platforms).":"
|
|
|
|
|
.join(',',@current_algorithms).";";
|
|
|
|
|
$def .= "int PEM_read_$1(void);";
|
|
|
|
|
$def .=
|
|
|
|
|
"#INFO:"
|
|
|
|
|
.join(',',@current_platforms).":"
|
|
|
|
|
.join(',',@current_algorithms).";";
|
|
|
|
|
# Things that are everywhere
|
|
|
|
|
$def .= "int PEM_read_bio_$1(void);";
|
|
|
|
|
next;
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
} elsif (/^OPENSSL_DECLARE_GLOBAL\s*\(\s*(\w*)\s*,\s*(\w*)\s*\)/) {
|
|
|
|
|
# Variant for platforms that do not
|
|
|
|
|
# have to access globale variables
|
|
|
|
|
# in shared libraries through functions
|
|
|
|
|
$def .=
|
|
|
|
|
"#INFO:"
|
|
|
|
|
.join(',',"!EXPORT_VAR_AS_FUNCTION",@current_platforms).":"
|
|
|
|
|
.join(',',@current_algorithms).";";
|
|
|
|
|
$def .= "OPENSSL_EXTERN int _shadow_$2;";
|
|
|
|
|
$def .=
|
|
|
|
|
"#INFO:"
|
|
|
|
|
.join(',',@current_platforms).":"
|
|
|
|
|
.join(',',@current_algorithms).";";
|
|
|
|
|
# Variant for platforms that have to
|
|
|
|
|
# access globale variables in shared
|
|
|
|
|
# libraries through functions
|
|
|
|
|
&$make_variant("_shadow_$2","_shadow_$2",
|
|
|
|
|
"EXPORT_VAR_AS_FUNCTION",
|
|
|
|
|
"FUNCTION");
|
2001-02-22 13:24:17 +00:00
|
|
|
} elsif ($tag{'CONST_STRICT'} != 1) {
|
2000-09-07 08:43:08 +00:00
|
|
|
if (/\{|\/\*|\([^\)]*$/) {
|
1999-04-26 00:23:10 +00:00
|
|
|
$line = $_;
|
|
|
|
|
} else {
|
|
|
|
|
$def .= $_;
|
|
|
|
|
}
|
1998-12-21 10:52:47 +00:00
|
|
|
}
|
|
|
|
|
}
|
2001-02-22 13:24:17 +00:00
|
|
|
}
|
1998-12-21 10:52:47 +00:00
|
|
|
close(IN);
|
1999-04-26 00:23:10 +00:00
|
|
|
|
2000-09-07 08:43:08 +00:00
|
|
|
my $algs;
|
|
|
|
|
my $plays;
|
|
|
|
|
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
print STDERR "DEBUG: postprocessing ----------\n" if $debug;
|
1999-04-26 00:23:10 +00:00
|
|
|
foreach (split /;/, $def) {
|
2000-09-07 08:43:08 +00:00
|
|
|
my $s; my $k = "FUNCTION"; my $p; my $a;
|
1999-04-26 00:23:10 +00:00
|
|
|
s/^[\n\s]*//g;
|
|
|
|
|
s/[\n\s]*$//g;
|
2000-09-07 08:43:08 +00:00
|
|
|
next if(/\#undef/);
|
1999-04-26 00:23:10 +00:00
|
|
|
next if(/typedef\W/);
|
2000-09-07 08:43:08 +00:00
|
|
|
next if(/\#define/);
|
|
|
|
|
|
2006-01-02 12:13:07 +00:00
|
|
|
# Reduce argument lists to empty ()
|
|
|
|
|
# fold round brackets recursively: (t(*v)(t),t) -> (t{}{},t) -> {}
|
|
|
|
|
while(/\(.*\)/s) {
|
|
|
|
|
s/\([^\(\)]+\)/\{\}/gs;
|
|
|
|
|
s/\(\s*\*\s*(\w+)\s*\{\}\s*\)/$1/gs; #(*f{}) -> f
|
|
|
|
|
}
|
|
|
|
|
# pretend as we didn't use curly braces: {} -> ()
|
|
|
|
|
s/\{\}/\(\)/gs;
|
|
|
|
|
|
|
|
|
|
s/STACK_OF\(\)/void/gs;
|
2008-05-31 21:20:53 +00:00
|
|
|
s/LHASH_OF\(\)/void/gs;
|
2006-01-02 12:13:07 +00:00
|
|
|
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
print STDERR "DEBUG: \$_ = \"$_\"\n" if $debug;
|
2000-09-07 08:43:08 +00:00
|
|
|
if (/^\#INFO:([^:]*):(.*)$/) {
|
|
|
|
|
$plats = $1;
|
|
|
|
|
$algs = $2;
|
2001-09-26 15:06:45 +00:00
|
|
|
print STDERR "DEBUG: found info on platforms ($plats) and algorithms ($algs)\n" if $debug;
|
2000-09-07 08:43:08 +00:00
|
|
|
next;
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
} elsif (/^\s*OPENSSL_EXTERN\s.*?(\w+(\{[0-9]+\})?)(\[[0-9]*\])*\s*$/) {
|
2000-09-07 08:43:08 +00:00
|
|
|
$s = $1;
|
|
|
|
|
$k = "VARIABLE";
|
2001-09-26 15:06:45 +00:00
|
|
|
print STDERR "DEBUG: found external variable $s\n" if $debug;
|
2006-01-02 12:13:07 +00:00
|
|
|
} elsif (/TYPEDEF_\w+_OF/s) {
|
1999-04-26 00:23:10 +00:00
|
|
|
next;
|
2006-01-02 12:13:07 +00:00
|
|
|
} elsif (/(\w+)\s*\(\).*/s) { # first token prior [first] () is
|
|
|
|
|
$s = $1; # a function name!
|
2001-09-26 15:06:45 +00:00
|
|
|
print STDERR "DEBUG: found function $s\n" if $debug;
|
1999-04-26 00:23:10 +00:00
|
|
|
} elsif (/\(/ and not (/=/)) {
|
|
|
|
|
print STDERR "File $file: cannot parse: $_;\n";
|
2000-09-07 08:43:08 +00:00
|
|
|
next;
|
|
|
|
|
} else {
|
|
|
|
|
next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$syms{$s} = 1;
|
|
|
|
|
$kind{$s} = $k;
|
|
|
|
|
|
|
|
|
|
$p = $plats;
|
|
|
|
|
$a = $algs;
|
|
|
|
|
$a .= ",BF" if($s =~ /EVP_bf/);
|
|
|
|
|
$a .= ",CAST" if($s =~ /EVP_cast/);
|
|
|
|
|
$a .= ",DES" if($s =~ /EVP_des/);
|
|
|
|
|
$a .= ",DSA" if($s =~ /EVP_dss/);
|
|
|
|
|
$a .= ",IDEA" if($s =~ /EVP_idea/);
|
|
|
|
|
$a .= ",MD2" if($s =~ /EVP_md2/);
|
|
|
|
|
$a .= ",MD4" if($s =~ /EVP_md4/);
|
|
|
|
|
$a .= ",MD5" if($s =~ /EVP_md5/);
|
|
|
|
|
$a .= ",RC2" if($s =~ /EVP_rc2/);
|
|
|
|
|
$a .= ",RC4" if($s =~ /EVP_rc4/);
|
|
|
|
|
$a .= ",RC5" if($s =~ /EVP_rc5/);
|
|
|
|
|
$a .= ",RIPEMD" if($s =~ /EVP_ripemd/);
|
|
|
|
|
$a .= ",SHA" if($s =~ /EVP_sha/);
|
|
|
|
|
$a .= ",RSA" if($s =~ /EVP_(Open|Seal)(Final|Init)/);
|
|
|
|
|
$a .= ",RSA" if($s =~ /PEM_Seal(Final|Init|Update)/);
|
|
|
|
|
$a .= ",RSA" if($s =~ /RSAPrivateKey/);
|
|
|
|
|
$a .= ",RSA" if($s =~ /SSLv23?_((client|server)_)?method/);
|
|
|
|
|
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
$platform{$s} =
|
|
|
|
|
&reduce_platforms((defined($platform{$s})?$platform{$s}.',':"").$p);
|
2000-09-07 08:43:08 +00:00
|
|
|
$algorithm{$s} .= ','.$a;
|
|
|
|
|
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
if (defined($variant{$s})) {
|
2001-03-02 12:14:54 +00:00
|
|
|
foreach $v (split /;/,$variant{$s}) {
|
|
|
|
|
(my $r, my $p, my $k) = split(/:/,$v);
|
|
|
|
|
my $ip = join ',',map({ /^!(.*)$/ ? $1 : "!".$_ } split /,/, $p);
|
|
|
|
|
$syms{$r} = 1;
|
|
|
|
|
if (!defined($k)) { $k = $kind{$s}; }
|
|
|
|
|
$kind{$r} = $k."(".$s.")";
|
|
|
|
|
$algorithm{$r} = $algorithm{$s};
|
|
|
|
|
$platform{$r} = &reduce_platforms($platform{$s}.",".$p.",".$p);
|
|
|
|
|
$platform{$s} = &reduce_platforms($platform{$s}.','.$ip.','.$ip);
|
|
|
|
|
print STDERR "DEBUG: \$variant{\"$s\"} = ",$v,"; \$r = $r; \$p = ",$platform{$r},"; \$a = ",$algorithm{$r},"; \$kind = ",$kind{$r},"\n" if $debug;
|
|
|
|
|
}
|
1999-04-26 00:23:10 +00:00
|
|
|
}
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
print STDERR "DEBUG: \$s = $s; \$p = ",$platform{$s},"; \$a = ",$algorithm{$s},"; \$kind = ",$kind{$s},"\n" if $debug;
|
1998-12-21 10:52:47 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2000-09-07 08:43:08 +00:00
|
|
|
# Prune the returned symbols
|
1999-04-26 00:23:10 +00:00
|
|
|
|
2000-09-07 08:43:08 +00:00
|
|
|
delete $syms{"bn_dump1"};
|
|
|
|
|
$platform{"BIO_s_log"} .= ",!WIN32,!WIN16,!macintosh";
|
|
|
|
|
|
2001-02-22 13:24:17 +00:00
|
|
|
$platform{"PEM_read_NS_CERT_SEQ"} = "VMS";
|
|
|
|
|
$platform{"PEM_write_NS_CERT_SEQ"} = "VMS";
|
|
|
|
|
$platform{"PEM_read_P8_PRIV_KEY_INFO"} = "VMS";
|
|
|
|
|
$platform{"PEM_write_P8_PRIV_KEY_INFO"} = "VMS";
|
2009-05-15 16:01:42 +00:00
|
|
|
$platform{"EVP_sha384"} = "!VMSVAX";
|
|
|
|
|
$platform{"EVP_sha512"} = "!VMSVAX";
|
|
|
|
|
$platform{"SHA384_Init"} = "!VMSVAX";
|
|
|
|
|
$platform{"SHA384_Transform"} = "!VMSVAX";
|
|
|
|
|
$platform{"SHA384_Update"} = "!VMSVAX";
|
|
|
|
|
$platform{"SHA384_Final"} = "!VMSVAX";
|
|
|
|
|
$platform{"SHA384"} = "!VMSVAX";
|
|
|
|
|
$platform{"SHA512_Init"} = "!VMSVAX";
|
|
|
|
|
$platform{"SHA512_Transform"} = "!VMSVAX";
|
|
|
|
|
$platform{"SHA512_Update"} = "!VMSVAX";
|
|
|
|
|
$platform{"SHA512_Final"} = "!VMSVAX";
|
|
|
|
|
$platform{"SHA512"} = "!VMSVAX";
|
2010-04-13 14:39:08 +00:00
|
|
|
$platform{"WHIRLPOOL_Init"} = "!VMSVAX";
|
|
|
|
|
$platform{"WHIRLPOOL"} = "!VMSVAX";
|
|
|
|
|
$platform{"WHIRLPOOL_BitUpdate"} = "!VMSVAX";
|
|
|
|
|
$platform{"EVP_whirlpool"} = "!VMSVAX";
|
|
|
|
|
$platform{"WHIRLPOOL_Final"} = "!VMSVAX";
|
|
|
|
|
$platform{"WHIRLPOOL_Update"} = "!VMSVAX";
|
2009-05-15 16:01:42 +00:00
|
|
|
|
2001-02-22 13:24:17 +00:00
|
|
|
|
2000-09-07 08:43:08 +00:00
|
|
|
# Info we know about
|
|
|
|
|
|
|
|
|
|
push @ret, map { $_."\\".&info_string($_,"EXIST",
|
|
|
|
|
$platform{$_},
|
|
|
|
|
$kind{$_},
|
|
|
|
|
$algorithm{$_}) } keys %syms;
|
|
|
|
|
|
2000-12-29 00:05:14 +00:00
|
|
|
if (keys %unknown_algorithms) {
|
|
|
|
|
print STDERR "WARNING: mkdef.pl doesn't know the following algorithms:\n";
|
|
|
|
|
print STDERR "\t",join("\n\t",keys %unknown_algorithms),"\n";
|
|
|
|
|
}
|
2000-09-07 08:43:08 +00:00
|
|
|
return(@ret);
|
|
|
|
|
}
|
|
|
|
|
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
# Param: string of comma-separated platform-specs.
|
|
|
|
|
sub reduce_platforms
|
|
|
|
|
{
|
|
|
|
|
my ($platforms) = @_;
|
2000-09-07 08:43:08 +00:00
|
|
|
my $pl = defined($platforms) ? $platforms : "";
|
|
|
|
|
my %p = map { $_ => 0 } split /,/, $pl;
|
|
|
|
|
my $ret;
|
|
|
|
|
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
print STDERR "DEBUG: Entered reduce_platforms with \"$platforms\"\n"
|
|
|
|
|
if $debug;
|
2000-09-07 08:43:08 +00:00
|
|
|
# We do this, because if there's code like the following, it really
|
|
|
|
|
# means the function exists in all cases and should therefore be
|
|
|
|
|
# everywhere. By increasing and decreasing, we may attain 0:
|
|
|
|
|
#
|
|
|
|
|
# ifndef WIN16
|
|
|
|
|
# int foo();
|
|
|
|
|
# else
|
|
|
|
|
# int _fat foo();
|
|
|
|
|
# endif
|
|
|
|
|
foreach $platform (split /,/, $pl) {
|
|
|
|
|
if ($platform =~ /^!(.*)$/) {
|
|
|
|
|
$p{$1}--;
|
|
|
|
|
} else {
|
|
|
|
|
$p{$platform}++;
|
1998-12-21 10:52:47 +00:00
|
|
|
}
|
1999-04-26 00:23:10 +00:00
|
|
|
}
|
2000-09-07 08:43:08 +00:00
|
|
|
foreach $platform (keys %p) {
|
|
|
|
|
if ($p{$platform} == 0) { delete $p{$platform}; }
|
1998-12-21 10:52:47 +00:00
|
|
|
}
|
|
|
|
|
|
2000-09-07 08:43:08 +00:00
|
|
|
delete $p{""};
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
|
2001-03-02 12:14:54 +00:00
|
|
|
$ret = join(',',sort(map { $p{$_} < 0 ? "!".$_ : $_ } keys %p));
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
print STDERR "DEBUG: Exiting reduce_platforms with \"$ret\"\n"
|
|
|
|
|
if $debug;
|
|
|
|
|
return $ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sub info_string {
|
|
|
|
|
(my $symbol, my $exist, my $platforms, my $kind, my $algorithms) = @_;
|
|
|
|
|
|
|
|
|
|
my %a = defined($algorithms) ?
|
|
|
|
|
map { $_ => 1 } split /,/, $algorithms : ();
|
|
|
|
|
my $k = defined($kind) ? $kind : "FUNCTION";
|
|
|
|
|
my $ret;
|
|
|
|
|
my $p = &reduce_platforms($platforms);
|
|
|
|
|
|
2000-09-07 08:43:08 +00:00
|
|
|
delete $a{""};
|
1998-12-21 10:52:47 +00:00
|
|
|
|
2000-09-07 08:43:08 +00:00
|
|
|
$ret = $exist;
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
$ret .= ":".$p;
|
2000-09-07 08:43:08 +00:00
|
|
|
$ret .= ":".$k;
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
$ret .= ":".join(',',sort keys %a);
|
2000-09-07 08:43:08 +00:00
|
|
|
return $ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sub maybe_add_info {
|
|
|
|
|
(my $name, *nums, my @symbols) = @_;
|
|
|
|
|
my $sym;
|
|
|
|
|
my $new_info = 0;
|
2000-11-14 13:20:10 +00:00
|
|
|
my %syms=();
|
2000-09-07 08:43:08 +00:00
|
|
|
|
|
|
|
|
print STDERR "Updating $name info\n";
|
|
|
|
|
foreach $sym (@symbols) {
|
|
|
|
|
(my $s, my $i) = split /\\/, $sym;
|
|
|
|
|
if (defined($nums{$s})) {
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
$i =~ s/^(.*?:.*?:\w+)(\(\w+\))?/$1/;
|
2000-09-07 08:43:08 +00:00
|
|
|
(my $n, my $dummy) = split /\\/, $nums{$s};
|
|
|
|
|
if (!defined($dummy) || $i ne $dummy) {
|
|
|
|
|
$nums{$s} = $n."\\".$i;
|
|
|
|
|
$new_info++;
|
2001-02-21 14:12:03 +00:00
|
|
|
print STDERR "DEBUG: maybe_add_info for $s: \"$dummy\" => \"$i\"\n" if $debug;
|
2000-09-07 08:43:08 +00:00
|
|
|
}
|
|
|
|
|
}
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
$syms{$s} = 1;
|
2000-11-14 13:20:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
my @s=sort { &parse_number($nums{$a},"n") <=> &parse_number($nums{$b},"n") } keys %nums;
|
|
|
|
|
foreach $sym (@s) {
|
|
|
|
|
(my $n, my $i) = split /\\/, $nums{$sym};
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
if (!defined($syms{$sym}) && $i !~ /^NOEXIST:/) {
|
2000-11-14 13:20:10 +00:00
|
|
|
$new_info++;
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
print STDERR "DEBUG: maybe_add_info for $sym: -> undefined\n" if $debug;
|
2000-11-14 13:20:10 +00:00
|
|
|
}
|
2000-09-07 08:43:08 +00:00
|
|
|
}
|
|
|
|
|
if ($new_info) {
|
|
|
|
|
print STDERR "$new_info old symbols got an info update\n";
|
2000-09-17 15:41:24 +00:00
|
|
|
if (!$do_rewrite) {
|
|
|
|
|
print STDERR "You should do a rewrite to fix this.\n";
|
|
|
|
|
}
|
2000-09-07 08:43:08 +00:00
|
|
|
} else {
|
|
|
|
|
print STDERR "No old symbols needed info update\n";
|
|
|
|
|
}
|
1999-04-26 00:23:10 +00:00
|
|
|
}
|
1998-12-21 10:52:47 +00:00
|
|
|
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
# Param: string of comma-separated keywords, each possibly prefixed with a "!"
|
|
|
|
|
sub is_valid
|
|
|
|
|
{
|
|
|
|
|
my ($keywords_txt,$platforms) = @_;
|
|
|
|
|
my (@keywords) = split /,/,$keywords_txt;
|
2005-04-19 23:54:44 +00:00
|
|
|
my ($falsesum, $truesum) = (0, 1);
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
|
|
|
|
|
# Param: one keyword
|
|
|
|
|
sub recognise
|
|
|
|
|
{
|
|
|
|
|
my ($keyword,$platforms) = @_;
|
|
|
|
|
|
|
|
|
|
if ($platforms) {
|
|
|
|
|
# platforms
|
2009-05-15 16:01:42 +00:00
|
|
|
if ($keyword eq "VMSVAX" && $VMSVAX) { return 1; }
|
|
|
|
|
if ($keyword eq "VMSNonVAX" && $VMSNonVAX) { return 1; }
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
if ($keyword eq "VMS" && $VMS) { return 1; }
|
|
|
|
|
if ($keyword eq "WIN32" && $W32) { return 1; }
|
|
|
|
|
if ($keyword eq "WIN16" && $W16) { return 1; }
|
|
|
|
|
if ($keyword eq "WINNT" && $NT) { return 1; }
|
2002-07-17 13:27:43 +00:00
|
|
|
if ($keyword eq "OS2" && $OS2) { return 1; }
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
# Special platforms:
|
|
|
|
|
# EXPORT_VAR_AS_FUNCTION means that global variables
|
|
|
|
|
# will be represented as functions. This currently
|
|
|
|
|
# only happens on VMS-VAX.
|
2001-05-13 05:01:58 +00:00
|
|
|
if ($keyword eq "EXPORT_VAR_AS_FUNCTION" && ($VMSVAX || $W32 || $W16)) {
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
return 1;
|
|
|
|
|
}
|
2011-06-06 15:46:25 +00:00
|
|
|
if ($keyword eq "OPENSSL_FIPS" && $fips) {
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
2008-03-12 21:14:28 +00:00
|
|
|
if ($keyword eq "ZLIB" && $zlib) { return 1; }
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
return 0;
|
|
|
|
|
} else {
|
|
|
|
|
# algorithms
|
|
|
|
|
if ($keyword eq "RC2" && $no_rc2) { return 0; }
|
|
|
|
|
if ($keyword eq "RC4" && $no_rc4) { return 0; }
|
|
|
|
|
if ($keyword eq "RC5" && $no_rc5) { return 0; }
|
|
|
|
|
if ($keyword eq "IDEA" && $no_idea) { return 0; }
|
|
|
|
|
if ($keyword eq "DES" && $no_des) { return 0; }
|
|
|
|
|
if ($keyword eq "BF" && $no_bf) { return 0; }
|
|
|
|
|
if ($keyword eq "CAST" && $no_cast) { return 0; }
|
|
|
|
|
if ($keyword eq "MD2" && $no_md2) { return 0; }
|
|
|
|
|
if ($keyword eq "MD4" && $no_md4) { return 0; }
|
|
|
|
|
if ($keyword eq "MD5" && $no_md5) { return 0; }
|
|
|
|
|
if ($keyword eq "SHA" && $no_sha) { return 0; }
|
|
|
|
|
if ($keyword eq "RIPEMD" && $no_ripemd) { return 0; }
|
|
|
|
|
if ($keyword eq "MDC2" && $no_mdc2) { return 0; }
|
2005-12-05 00:53:10 +00:00
|
|
|
if ($keyword eq "WHIRLPOOL" && $no_whirlpool) { return 0; }
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
if ($keyword eq "RSA" && $no_rsa) { return 0; }
|
|
|
|
|
if ($keyword eq "DSA" && $no_dsa) { return 0; }
|
|
|
|
|
if ($keyword eq "DH" && $no_dh) { return 0; }
|
2001-04-26 21:02:57 +00:00
|
|
|
if ($keyword eq "EC" && $no_ec) { return 0; }
|
2002-02-13 18:21:51 +00:00
|
|
|
if ($keyword eq "ECDSA" && $no_ecdsa) { return 0; }
|
2002-08-09 08:43:04 +00:00
|
|
|
if ($keyword eq "ECDH" && $no_ecdh) { return 0; }
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
if ($keyword eq "HMAC" && $no_hmac) { return 0; }
|
|
|
|
|
if ($keyword eq "AES" && $no_aes) { return 0; }
|
2006-06-09 15:44:59 +00:00
|
|
|
if ($keyword eq "CAMELLIA" && $no_camellia) { return 0; }
|
2007-04-23 23:48:59 +00:00
|
|
|
if ($keyword eq "SEED" && $no_seed) { return 0; }
|
2001-04-26 21:02:57 +00:00
|
|
|
if ($keyword eq "EVP" && $no_evp) { return 0; }
|
|
|
|
|
if ($keyword eq "LHASH" && $no_lhash) { return 0; }
|
|
|
|
|
if ($keyword eq "STACK" && $no_stack) { return 0; }
|
|
|
|
|
if ($keyword eq "ERR" && $no_err) { return 0; }
|
|
|
|
|
if ($keyword eq "BUFFER" && $no_buffer) { return 0; }
|
|
|
|
|
if ($keyword eq "BIO" && $no_bio) { return 0; }
|
|
|
|
|
if ($keyword eq "COMP" && $no_comp) { return 0; }
|
|
|
|
|
if ($keyword eq "DSO" && $no_dso) { return 0; }
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
if ($keyword eq "KRB5" && $no_krb5) { return 0; }
|
2003-01-30 17:39:26 +00:00
|
|
|
if ($keyword eq "ENGINE" && $no_engine) { return 0; }
|
2003-01-30 20:03:45 +00:00
|
|
|
if ($keyword eq "HW" && $no_hw) { return 0; }
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
if ($keyword eq "FP_API" && $no_fp_api) { return 0; }
|
2002-10-24 19:09:03 +00:00
|
|
|
if ($keyword eq "STATIC_ENGINE" && $no_static_engine) { return 0; }
|
2005-04-19 13:24:44 +00:00
|
|
|
if ($keyword eq "GMP" && $no_gmp) { return 0; }
|
2006-11-30 13:39:34 +00:00
|
|
|
if ($keyword eq "RFC3779" && $no_rfc3779) { return 0; }
|
2006-04-17 12:08:22 +00:00
|
|
|
if ($keyword eq "TLSEXT" && $no_tlsext) { return 0; }
|
|
|
|
|
if ($keyword eq "PSK" && $no_psk) { return 0; }
|
2008-03-12 21:14:28 +00:00
|
|
|
if ($keyword eq "CMS" && $no_cms) { return 0; }
|
2011-06-06 11:49:36 +00:00
|
|
|
if ($keyword eq "EC2M" && $no_ec2m) { return 0; }
|
2011-11-21 22:35:35 +00:00
|
|
|
if ($keyword eq "NEXTPROTONEG" && $no_nextprotoneg) { return 0; }
|
2011-10-19 08:58:35 +00:00
|
|
|
if ($keyword eq "EC_NISTP_64_GCC_128" && $no_nistp_gcc)
|
2011-05-13 12:38:02 +00:00
|
|
|
{ return 0; }
|
2009-04-04 17:57:34 +00:00
|
|
|
if ($keyword eq "SSL2" && $no_ssl2) { return 0; }
|
2016-03-09 17:10:52 +00:00
|
|
|
if ($keyword eq "SSL2_METHOD" && $no_ssl2_method) { return 0; }
|
2014-10-29 12:51:31 +00:00
|
|
|
if ($keyword eq "SSL3_METHOD" && $no_ssl3_method) { return 0; }
|
2008-06-01 11:07:34 +00:00
|
|
|
if ($keyword eq "CAPIENG" && $no_capieng) { return 0; }
|
2008-11-24 17:27:08 +00:00
|
|
|
if ($keyword eq "JPAKE" && $no_jpake) { return 0; }
|
2011-03-16 11:26:40 +00:00
|
|
|
if ($keyword eq "SRP" && $no_srp) { return 0; }
|
2011-12-25 14:47:46 +00:00
|
|
|
if ($keyword eq "SCTP" && $no_sctp) { return 0; }
|
2014-10-15 00:23:07 +00:00
|
|
|
if ($keyword eq "SRTP" && $no_srtp) { return 0; }
|
2014-07-23 12:18:06 +00:00
|
|
|
if ($keyword eq "UNIT_TEST" && $no_unit_test) { return 0; }
|
2002-12-09 02:18:16 +00:00
|
|
|
if ($keyword eq "DEPRECATED" && $no_deprecated) { return 0; }
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
|
|
|
|
|
# Nothing recognise as true
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
foreach $k (@keywords) {
|
|
|
|
|
if ($k =~ /^!(.*)$/) {
|
|
|
|
|
$falsesum += &recognise($1,$platforms);
|
|
|
|
|
} else {
|
2005-04-19 23:54:44 +00:00
|
|
|
$truesum *= &recognise($k,$platforms);
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
print STDERR "DEBUG: [",$#keywords,",",$#keywords < 0,"] is_valid($keywords_txt) => (\!$falsesum) && $truesum = ",(!$falsesum) && $truesum,"\n" if $debug;
|
|
|
|
|
return (!$falsesum) && $truesum;
|
|
|
|
|
}
|
|
|
|
|
|
1999-12-24 17:26:33 +00:00
|
|
|
sub print_test_file
|
|
|
|
|
{
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
(*OUT,my $name,*nums,my $testall,my @symbols)=@_;
|
2000-01-07 03:17:47 +00:00
|
|
|
my $n = 1; my @e; my @r;
|
2000-09-07 08:43:08 +00:00
|
|
|
my $sym; my $prev = ""; my $prefSSLeay;
|
|
|
|
|
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
(@e)=grep(/^SSLeay(\{[0-9]+\})?\\.*?:.*?:.*/,@symbols);
|
|
|
|
|
(@r)=grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:.*/ && !/^SSLeay(\{[0-9]+\})?\\.*?:.*?:.*/,@symbols);
|
2000-09-07 08:43:08 +00:00
|
|
|
@symbols=((sort @e),(sort @r));
|
|
|
|
|
|
|
|
|
|
foreach $sym (@symbols) {
|
|
|
|
|
(my $s, my $i) = $sym =~ /^(.*?)\\(.*)$/;
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
my $v = 0;
|
|
|
|
|
$v = 1 if $i=~ /^.*?:.*?:VARIABLE/;
|
|
|
|
|
my $p = ($i =~ /^[^:]*:([^:]*):/,$1);
|
|
|
|
|
my $a = ($i =~ /^[^:]*:[^:]*:[^:]*:([^:]*)/,$1);
|
|
|
|
|
if (!defined($nums{$s})) {
|
|
|
|
|
print STDERR "Warning: $s does not have a number assigned\n"
|
|
|
|
|
if(!$do_update);
|
|
|
|
|
} elsif (is_valid($p,1) && is_valid($a,0)) {
|
|
|
|
|
my $s2 = ($s =~ /^(.*?)(\{[0-9]+\})?$/, $1);
|
|
|
|
|
if ($prev eq $s2) {
|
|
|
|
|
print OUT "\t/* The following has already appeared previously */\n";
|
|
|
|
|
print STDERR "Warning: Symbol '",$s2,"' redefined. old=",($nums{$prev} =~ /^(.*?)\\/,$1),", new=",($nums{$s2} =~ /^(.*?)\\/,$1),"\n";
|
|
|
|
|
}
|
|
|
|
|
$prev = $s2; # To warn about duplicates...
|
|
|
|
|
|
|
|
|
|
($nn,$ni)=($nums{$s2} =~ /^(.*?)\\(.*)$/);
|
|
|
|
|
if ($v) {
|
|
|
|
|
print OUT "\textern int $s2; /* type unknown */ /* $nn $ni */\n";
|
2000-08-17 21:26:22 +00:00
|
|
|
} else {
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
print OUT "\textern int $s2(); /* type unknown */ /* $nn $ni */\n";
|
2000-08-17 21:26:22 +00:00
|
|
|
}
|
1999-12-24 17:26:33 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2003-11-28 14:51:30 +00:00
|
|
|
sub get_version {
|
|
|
|
|
local *MF;
|
|
|
|
|
my $v = '?';
|
2005-04-13 19:09:43 +00:00
|
|
|
open MF, 'Makefile' or return $v;
|
2003-11-28 14:51:30 +00:00
|
|
|
while (<MF>) {
|
|
|
|
|
$v = $1, last if /^VERSION=(.*?)\s*$/;
|
|
|
|
|
}
|
|
|
|
|
close MF;
|
|
|
|
|
return $v;
|
|
|
|
|
}
|
|
|
|
|
|
1998-12-21 10:52:47 +00:00
|
|
|
sub print_def_file
|
1999-04-26 00:23:10 +00:00
|
|
|
{
|
2000-09-07 08:43:08 +00:00
|
|
|
(*OUT,my $name,*nums,my @symbols)=@_;
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
my $n = 1; my @e; my @r; my @v; my $prev="";
|
2002-07-17 13:27:43 +00:00
|
|
|
my $liboptions="";
|
2003-11-28 14:51:30 +00:00
|
|
|
my $libname = $name;
|
|
|
|
|
my $http_vendor = 'www.openssl.org/';
|
|
|
|
|
my $version = get_version();
|
|
|
|
|
my $what = "OpenSSL: implementation of Secure Socket Layer";
|
|
|
|
|
my $description = "$what $version, $name - http://$http_vendor";
|
1998-12-21 10:52:47 +00:00
|
|
|
|
1999-03-03 02:01:26 +00:00
|
|
|
if ($W32)
|
2003-11-28 14:51:30 +00:00
|
|
|
{ $libname.="32"; }
|
2002-07-17 13:27:43 +00:00
|
|
|
elsif ($W16)
|
2003-11-28 14:51:30 +00:00
|
|
|
{ $libname.="16"; }
|
2002-07-17 13:27:43 +00:00
|
|
|
elsif ($OS2)
|
2003-11-28 14:51:30 +00:00
|
|
|
{ # DLL names should not clash on the whole system.
|
|
|
|
|
# However, they should not have any particular relationship
|
|
|
|
|
# to the name of the static library. Chose descriptive names
|
|
|
|
|
# (must be at most 8 chars).
|
|
|
|
|
my %translate = (ssl => 'open_ssl', crypto => 'cryptssl');
|
|
|
|
|
$libname = $translate{$name} || $name;
|
|
|
|
|
$liboptions = <<EOO;
|
|
|
|
|
INITINSTANCE
|
|
|
|
|
DATA MULTIPLE NONSHARED
|
|
|
|
|
EOO
|
|
|
|
|
# Vendor field can't contain colon, drat; so we omit http://
|
|
|
|
|
$description = "\@#$http_vendor:$version#\@$what; DLL for library $name. Build for EMX -Zmtd";
|
|
|
|
|
}
|
1998-12-21 10:52:47 +00:00
|
|
|
|
|
|
|
|
print OUT <<"EOF";
|
|
|
|
|
;
|
1999-01-31 17:30:18 +00:00
|
|
|
; Definition file for the DLL version of the $name library from OpenSSL
|
1998-12-21 10:52:47 +00:00
|
|
|
;
|
|
|
|
|
|
2003-11-28 14:51:30 +00:00
|
|
|
LIBRARY $libname $liboptions
|
1998-12-21 10:52:47 +00:00
|
|
|
|
|
|
|
|
EOF
|
|
|
|
|
|
2002-07-17 13:27:43 +00:00
|
|
|
if ($W16) {
|
1998-12-21 10:52:47 +00:00
|
|
|
print <<"EOF";
|
|
|
|
|
CODE PRELOAD MOVEABLE
|
|
|
|
|
DATA PRELOAD MOVEABLE SINGLE
|
|
|
|
|
|
|
|
|
|
EXETYPE WINDOWS
|
|
|
|
|
|
|
|
|
|
HEAPSIZE 4096
|
|
|
|
|
STACKSIZE 8192
|
|
|
|
|
|
|
|
|
|
EOF
|
1999-04-26 00:23:10 +00:00
|
|
|
}
|
1998-12-21 10:52:47 +00:00
|
|
|
|
|
|
|
|
print "EXPORTS\n";
|
|
|
|
|
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
(@e)=grep(/^SSLeay(\{[0-9]+\})?\\.*?:.*?:FUNCTION/,@symbols);
|
|
|
|
|
(@r)=grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:FUNCTION/ && !/^SSLeay(\{[0-9]+\})?\\.*?:.*?:FUNCTION/,@symbols);
|
|
|
|
|
(@v)=grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:VARIABLE/,@symbols);
|
2000-12-16 01:19:24 +00:00
|
|
|
@symbols=((sort @e),(sort @r), (sort @v));
|
1998-12-21 10:52:47 +00:00
|
|
|
|
|
|
|
|
|
2000-09-07 08:43:08 +00:00
|
|
|
foreach $sym (@symbols) {
|
|
|
|
|
(my $s, my $i) = $sym =~ /^(.*?)\\(.*)$/;
|
2000-12-16 01:19:24 +00:00
|
|
|
my $v = 0;
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
$v = 1 if $i =~ /^.*?:.*?:VARIABLE/;
|
2000-09-07 08:43:08 +00:00
|
|
|
if (!defined($nums{$s})) {
|
|
|
|
|
printf STDERR "Warning: $s does not have a number assigned\n"
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
if(!$do_update);
|
1999-04-26 00:23:10 +00:00
|
|
|
} else {
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
(my $n, my $dummy) = split /\\/, $nums{$s};
|
2000-09-11 20:04:58 +00:00
|
|
|
my %pf = ();
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
my $p = ($i =~ /^[^:]*:([^:]*):/,$1);
|
|
|
|
|
my $a = ($i =~ /^[^:]*:[^:]*:[^:]*:([^:]*)/,$1);
|
|
|
|
|
if (is_valid($p,1) && is_valid($a,0)) {
|
|
|
|
|
my $s2 = ($s =~ /^(.*?)(\{[0-9]+\})?$/, $1);
|
|
|
|
|
if ($prev eq $s2) {
|
|
|
|
|
print STDERR "Warning: Symbol '",$s2,"' redefined. old=",($nums{$prev} =~ /^(.*?)\\/,$1),", new=",($nums{$s2} =~ /^(.*?)\\/,$1),"\n";
|
|
|
|
|
}
|
|
|
|
|
$prev = $s2; # To warn about duplicates...
|
2002-07-17 13:27:43 +00:00
|
|
|
if($v && !$OS2) {
|
2001-03-10 01:56:48 +00:00
|
|
|
printf OUT " %s%-39s @%-8d DATA\n",($W32)?"":"_",$s2,$n;
|
2000-12-16 01:19:24 +00:00
|
|
|
} else {
|
2002-07-17 13:27:43 +00:00
|
|
|
printf OUT " %s%-39s @%d\n",($W32||$OS2)?"":"_",$s2,$n;
|
2000-12-16 01:19:24 +00:00
|
|
|
}
|
2000-09-11 17:31:05 +00:00
|
|
|
}
|
1998-12-21 10:52:47 +00:00
|
|
|
}
|
|
|
|
|
}
|
1999-04-26 00:23:10 +00:00
|
|
|
printf OUT "\n";
|
|
|
|
|
}
|
1998-12-21 10:52:47 +00:00
|
|
|
|
|
|
|
|
sub load_numbers
|
1999-04-26 00:23:10 +00:00
|
|
|
{
|
|
|
|
|
my($name)=@_;
|
|
|
|
|
my(@a,%ret);
|
1998-12-21 10:52:47 +00:00
|
|
|
|
1999-02-11 01:39:30 +00:00
|
|
|
$max_num = 0;
|
2000-09-07 08:43:08 +00:00
|
|
|
$num_noinfo = 0;
|
|
|
|
|
$prev = "";
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
$prev_cnt = 0;
|
1999-02-11 01:39:30 +00:00
|
|
|
|
1998-12-21 10:52:47 +00:00
|
|
|
open(IN,"<$name") || die "unable to open $name:$!\n";
|
1999-04-26 00:23:10 +00:00
|
|
|
while (<IN>) {
|
1998-12-21 10:52:47 +00:00
|
|
|
chop;
|
|
|
|
|
s/#.*$//;
|
|
|
|
|
next if /^\s*$/;
|
|
|
|
|
@a=split;
|
2000-09-07 08:43:08 +00:00
|
|
|
if (defined $ret{$a[0]}) {
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
# This is actually perfectly OK
|
|
|
|
|
#print STDERR "Warning: Symbol '",$a[0],"' redefined. old=",$ret{$a[0]},", new=",$a[1],"\n";
|
2000-09-07 08:43:08 +00:00
|
|
|
}
|
|
|
|
|
if ($max_num > $a[1]) {
|
|
|
|
|
print STDERR "Warning: Number decreased from ",$max_num," to ",$a[1],"\n";
|
|
|
|
|
}
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
elsif ($max_num == $a[1]) {
|
2000-09-07 08:43:08 +00:00
|
|
|
# This is actually perfectly OK
|
|
|
|
|
#print STDERR "Warning: Symbol ",$a[0]," has same number as previous ",$prev,": ",$a[1],"\n";
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
if ($a[0] eq $prev) {
|
|
|
|
|
$prev_cnt++;
|
|
|
|
|
$a[0] .= "{$prev_cnt}";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
$prev_cnt = 0;
|
2000-09-07 08:43:08 +00:00
|
|
|
}
|
|
|
|
|
if ($#a < 2) {
|
|
|
|
|
# Existence will be proven later, in do_defs
|
|
|
|
|
$ret{$a[0]}=$a[1];
|
|
|
|
|
$num_noinfo++;
|
|
|
|
|
} else {
|
|
|
|
|
$ret{$a[0]}=$a[1]."\\".$a[2]; # \\ is a special marker
|
|
|
|
|
}
|
1999-02-11 01:39:30 +00:00
|
|
|
$max_num = $a[1] if $a[1] > $max_num;
|
2000-09-07 08:43:08 +00:00
|
|
|
$prev=$a[0];
|
|
|
|
|
}
|
|
|
|
|
if ($num_noinfo) {
|
|
|
|
|
print STDERR "Warning: $num_noinfo symbols were without info.";
|
|
|
|
|
if ($do_rewrite) {
|
|
|
|
|
printf STDERR " The rewrite will fix this.\n";
|
|
|
|
|
} else {
|
|
|
|
|
printf STDERR " You should do a rewrite to fix this.\n";
|
|
|
|
|
}
|
1999-04-26 00:23:10 +00:00
|
|
|
}
|
1998-12-21 10:52:47 +00:00
|
|
|
close(IN);
|
|
|
|
|
return(%ret);
|
1999-04-26 00:23:10 +00:00
|
|
|
}
|
1999-02-11 01:39:30 +00:00
|
|
|
|
2000-09-07 08:43:08 +00:00
|
|
|
sub parse_number
|
|
|
|
|
{
|
|
|
|
|
(my $str, my $what) = @_;
|
|
|
|
|
(my $n, my $i) = split(/\\/,$str);
|
|
|
|
|
if ($what eq "n") {
|
|
|
|
|
return $n;
|
|
|
|
|
} else {
|
|
|
|
|
return $i;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sub rewrite_numbers
|
|
|
|
|
{
|
|
|
|
|
(*OUT,$name,*nums,@symbols)=@_;
|
|
|
|
|
my $thing;
|
|
|
|
|
|
|
|
|
|
print STDERR "Rewriting $name\n";
|
|
|
|
|
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
my @r = grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:\w+\(\w+\)/,@symbols);
|
2000-09-07 08:43:08 +00:00
|
|
|
my $r; my %r; my %rsyms;
|
|
|
|
|
foreach $r (@r) {
|
|
|
|
|
(my $s, my $i) = split /\\/, $r;
|
|
|
|
|
my $a = $1 if $i =~ /^.*?:.*?:\w+\((\w+)\)/;
|
|
|
|
|
$i =~ s/^(.*?:.*?:\w+)\(\w+\)/$1/;
|
|
|
|
|
$r{$a} = $s."\\".$i;
|
|
|
|
|
$rsyms{$s} = 1;
|
|
|
|
|
}
|
|
|
|
|
|
2000-11-14 13:20:10 +00:00
|
|
|
my %syms = ();
|
|
|
|
|
foreach $_ (@symbols) {
|
|
|
|
|
(my $n, my $i) = split /\\/;
|
|
|
|
|
$syms{$n} = 1;
|
|
|
|
|
}
|
|
|
|
|
|
2001-09-26 15:06:45 +00:00
|
|
|
my @s=sort {
|
|
|
|
|
&parse_number($nums{$a},"n") <=> &parse_number($nums{$b},"n")
|
|
|
|
|
|| $a cmp $b
|
|
|
|
|
} keys %nums;
|
2000-09-07 08:43:08 +00:00
|
|
|
foreach $sym (@s) {
|
|
|
|
|
(my $n, my $i) = split /\\/, $nums{$sym};
|
|
|
|
|
next if defined($i) && $i =~ /^.*?:.*?:\w+\(\w+\)/;
|
|
|
|
|
next if defined($rsyms{$sym});
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
print STDERR "DEBUG: rewrite_numbers for sym = ",$sym,": i = ",$i,", n = ",$n,", rsym{sym} = ",$rsyms{$sym},"syms{sym} = ",$syms{$sym},"\n" if $debug;
|
2000-11-14 13:20:10 +00:00
|
|
|
$i="NOEXIST::FUNCTION:"
|
|
|
|
|
if !defined($i) || $i eq "" || !defined($syms{$sym});
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
my $s2 = $sym;
|
|
|
|
|
$s2 =~ s/\{[0-9]+\}$//;
|
2001-03-10 01:56:48 +00:00
|
|
|
printf OUT "%s%-39s %d\t%s\n","",$s2,$n,$i;
|
2000-09-07 08:43:08 +00:00
|
|
|
if (exists $r{$sym}) {
|
|
|
|
|
(my $s, $i) = split /\\/,$r{$sym};
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
my $s2 = $s;
|
|
|
|
|
$s2 =~ s/\{[0-9]+\}$//;
|
2001-03-10 01:56:48 +00:00
|
|
|
printf OUT "%s%-39s %d\t%s\n","",$s2,$n,$i;
|
2000-09-07 08:43:08 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
1999-02-11 01:39:30 +00:00
|
|
|
sub update_numbers
|
1999-04-26 00:23:10 +00:00
|
|
|
{
|
2000-09-07 08:43:08 +00:00
|
|
|
(*OUT,$name,*nums,my $start_num, my @symbols)=@_;
|
|
|
|
|
my $new_syms = 0;
|
|
|
|
|
|
|
|
|
|
print STDERR "Updating $name numbers\n";
|
|
|
|
|
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
my @r = grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:\w+\(\w+\)/,@symbols);
|
2000-09-07 08:43:08 +00:00
|
|
|
my $r; my %r; my %rsyms;
|
|
|
|
|
foreach $r (@r) {
|
|
|
|
|
(my $s, my $i) = split /\\/, $r;
|
|
|
|
|
my $a = $1 if $i =~ /^.*?:.*?:\w+\((\w+)\)/;
|
|
|
|
|
$i =~ s/^(.*?:.*?:\w+)\(\w+\)/$1/;
|
|
|
|
|
$r{$a} = $s."\\".$i;
|
|
|
|
|
$rsyms{$s} = 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
foreach $sym (@symbols) {
|
|
|
|
|
(my $s, my $i) = $sym =~ /^(.*?)\\(.*)$/;
|
|
|
|
|
next if $i =~ /^.*?:.*?:\w+\(\w+\)/;
|
|
|
|
|
next if defined($rsyms{$sym});
|
|
|
|
|
die "ERROR: Symbol $sym had no info attached to it."
|
|
|
|
|
if $i eq "";
|
|
|
|
|
if (!exists $nums{$s}) {
|
|
|
|
|
$new_syms++;
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
my $s2 = $s;
|
|
|
|
|
$s2 =~ s/\{[0-9]+\}$//;
|
2001-03-10 01:56:48 +00:00
|
|
|
printf OUT "%s%-39s %d\t%s\n","",$s2, ++$start_num,$i;
|
2000-09-07 08:43:08 +00:00
|
|
|
if (exists $r{$s}) {
|
2000-09-20 14:47:04 +00:00
|
|
|
($s, $i) = split /\\/,$r{$s};
|
Introduce the possibility to access global variables through
functions on platform were that's the best way to handle exporting
global variables in shared libraries. To enable this functionality,
one must configure with "EXPORT_VAR_AS_FN" or defined the C macro
"OPENSSL_EXPORT_VAR_AS_FUNCTION" in crypto/opensslconf.h (the latter
is normally done by Configure or something similar).
To implement a global variable, use the macro OPENSSL_IMPLEMENT_GLOBAL
in the source file (foo.c) like this:
OPENSSL_IMPLEMENT_GLOBAL(int,foo)=1;
OPENSSL_IMPLEMENT_GLOBAL(double,bar);
To declare a global variable, use the macros OPENSSL_DECLARE_GLOBAL
and OPENSSL_GLOBAL_REF in the header file (foo.h) like this:
OPENSSL_DECLARE_GLOBAL(int,foo);
#define foo OPENSSL_GLOBAL_REF(foo)
OPENSSL_DECLARE_GLOBAL(double,bar);
#define bar OPENSSL_GLOBAL_REF(bar)
The #defines are very important, and therefore so is including the
header file everywere where the defined globals are used.
The macro OPENSSL_EXPORT_VAR_AS_FUNCTION also affects the definition
of ASN.1 items, but that structure is a bt different.
The largest change is in util/mkdef.pl which has been enhanced with
better and easier to understand logic to choose which symbols should
go into the Windows .def files as well as a number of fixes and code
cleanup (among others, algorithm keywords are now sorted
lexicographically to avoid constant rewrites).
2001-03-02 10:38:19 +00:00
|
|
|
$s =~ s/\{[0-9]+\}$//;
|
2001-03-10 01:56:48 +00:00
|
|
|
printf OUT "%s%-39s %d\t%s\n","",$s, $start_num,$i;
|
2000-09-07 08:43:08 +00:00
|
|
|
}
|
1999-02-11 01:39:30 +00:00
|
|
|
}
|
1999-04-26 00:23:10 +00:00
|
|
|
}
|
2000-09-07 08:43:08 +00:00
|
|
|
if($new_syms) {
|
|
|
|
|
print STDERR "$new_syms New symbols added\n";
|
1999-02-11 01:39:30 +00:00
|
|
|
} else {
|
2000-09-07 08:43:08 +00:00
|
|
|
print STDERR "No New symbols Added\n";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sub check_existing
|
|
|
|
|
{
|
|
|
|
|
(*nums, my @symbols)=@_;
|
|
|
|
|
my %existing; my @remaining;
|
|
|
|
|
@remaining=();
|
|
|
|
|
foreach $sym (@symbols) {
|
|
|
|
|
(my $s, my $i) = $sym =~ /^(.*?)\\(.*)$/;
|
|
|
|
|
$existing{$s}=1;
|
|
|
|
|
}
|
|
|
|
|
foreach $sym (keys %nums) {
|
|
|
|
|
if (!exists $existing{$sym}) {
|
|
|
|
|
push @remaining, $sym;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if(@remaining) {
|
|
|
|
|
print STDERR "The following symbols do not seem to exist:\n";
|
|
|
|
|
foreach $sym (@remaining) {
|
|
|
|
|
print STDERR "\t",$sym,"\n";
|
|
|
|
|
}
|
1999-02-11 01:39:30 +00:00
|
|
|
}
|
1999-04-26 00:23:10 +00:00
|
|
|
}
|
2000-09-07 08:43:08 +00:00
|
|
|
|