X-Git-Url: https://git.openssl.org/gitweb/?p=openssl.git;a=blobdiff_plain;f=util%2Fmkdef.pl;h=fd36a0d7da79a58f29598533f46e3904b75e6257;hp=3eac54426292430f98e7d47f800581d924fea9fe;hb=0c1badc8af7b92170fbb23be8119072facfdad07;hpb=ec645d90174b354854cacb69907c429fef7e610b diff --git a/util/mkdef.pl b/util/mkdef.pl index 3eac544262..fd36a0d7da 100755 --- a/util/mkdef.pl +++ b/util/mkdef.pl @@ -5,30 +5,14 @@ # It does this by parsing the header files and looking for the # prototyped functions: it then prunes the output. # -# Intermediary files are created, call libeay.num and ssleay.num,... -# Previously, they had the following format: +# Intermediary files are created, call libeay.num and ssleay.num, +# The format of these files is: # -# routine-name nnnn +# routine-name nnnn vers info # -# 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: +# The "nnnn" and "vers" fields are the numeric id and version for the symbol +# respectively. The "info" part is actually a colon-separated string of fields +# with the following meaning: # # existence:platform:kind:algorithms # @@ -69,34 +53,67 @@ my $do_ctestall = 0; my $do_checkexist = 0; my $VMSVAX=0; -my $VMSAlpha=0; +my $VMSNonVAX=0; my $VMS=0; my $W32=0; -my $W16=0; my $NT=0; my $OS2=0; +my $linux=0; # Set this to make typesafe STACK definitions appear in DEF my $safe_stack_def = 0; -my @known_platforms = ( "__FreeBSD__", "PERL5", "NeXT", - "EXPORT_VAR_AS_FUNCTION" ); -my @known_ossl_platforms = ( "VMS", "WIN16", "WIN32", "WINNT", "OS2" ); +my @known_platforms = ( "__FreeBSD__", "PERL5", + "EXPORT_VAR_AS_FUNCTION", "ZLIB" + ); +my @known_ossl_platforms = ( "VMS", "WIN32", "WINNT", "OS2" ); my @known_algorithms = ( "RC2", "RC4", "RC5", "IDEA", "DES", "BF", "CAST", "MD2", "MD4", "MD5", "SHA", "SHA0", "SHA1", - "SHA256", "SHA512", "RIPEMD", - "MDC2", "RSA", "DSA", "DH", "EC", "ECDH", "ECDSA", - "HMAC", "AES", "WHIRLPOOL", + "SHA256", "SHA512", "RMD160", + "MDC2", "WHIRLPOOL", "RSA", "DSA", "DH", "EC", "EC2M", + "HMAC", "AES", "CAMELLIA", "SEED", "GOST", + "SCRYPT", "CHACHA", "POLY1305", + # EC_NISTP_64_GCC_128 + "EC_NISTP_64_GCC_128", # Envelope "algorithms" "EVP", "X509", "ASN1_TYPEDEFS", # Helper "algorithms" "BIO", "COMP", "BUFFER", "LHASH", "STACK", "ERR", "LOCKING", # External "algorithms" - "FP_API", "STDIO", "SOCK", "KRB5", "DGRAM", + "FP_API", "STDIO", "SOCK", "DGRAM", # Engines - "STATIC_ENGINE", "ENGINE", "HW", "GMP", + "STATIC_ENGINE", "ENGINE", "HW", "GMP", + # X.509v3 Signed Certificate Timestamps + "SCT", + # RFC3779 + "RFC3779", + # TLS + "PSK", "SRP", "HEARTBEATS", + # CMS + "CMS", + # CryptoAPI Engine + "CAPIENG", + # SSL v3 method + "SSL3_METHOD", + # JPAKE + "JPAKE", + # NEXTPROTONEG + "NEXTPROTONEG", # Deprecated functions - "DEPRECATED" ); + "DEPRECATED", + # SCTP + "SCTP", + # SRTP + "SRTP", + # SSL TRACE + "SSL_TRACE", + # Unit testing + "UNIT_TEST", + # OCB mode + "OCB", + # APPLINK (win build feature?) + "APPLINK" + ); my $options=""; open(IN," 1); if (!$do_ssl && !$do_crypto) { - print STDERR "usage: $0 ( ssl | crypto ) [ 16 | 32 | NT | OS2 ]\n"; + print STDERR "usage: $0 ( ssl | crypto ) [ 16 | 32 | NT | OS2 | linux | VMS ]\n"; exit(1); } @@ -223,67 +267,77 @@ $max_ssl = $max_num; %crypto_list=&load_numbers($crypto_num); $max_crypto = $max_num; -my $ssl="ssl/ssl.h"; -$ssl.=" ssl/kssl.h"; - -my $crypto ="crypto/crypto.h"; -$crypto.=" crypto/o_dir.h"; -$crypto.=" crypto/des/des.h crypto/des/des_old.h" ; # unless $no_des; -$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; -$crypto.=" crypto/whrlpool/whrlpool.h" ; -$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; -$crypto.=" crypto/aes/aes.h" ; # unless $no_aes; - -$crypto.=" crypto/bn/bn.h"; -$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; -$crypto.=" crypto/ecdsa/ecdsa.h" ; # unless $no_ecdsa; -$crypto.=" crypto/ecdh/ecdh.h" ; # unless $no_ecdh; -$crypto.=" crypto/hmac/hmac.h" ; # unless $no_hmac; - -$crypto.=" crypto/engine/engine.h"; # unless $no_engine; -$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; -$crypto.=" crypto/conf/conf.h"; -$crypto.=" crypto/txt_db/txt_db.h"; - -$crypto.=" crypto/evp/evp.h" ; # unless $no_evp; -$crypto.=" crypto/objects/objects.h"; -$crypto.=" crypto/pem/pem.h"; -#$crypto.=" crypto/meth/meth.h"; -$crypto.=" crypto/asn1/asn1.h"; -$crypto.=" crypto/asn1/asn1t.h"; -$crypto.=" crypto/asn1/asn1_mac.h"; -$crypto.=" crypto/err/err.h" ; # unless $no_err; -$crypto.=" crypto/pkcs7/pkcs7.h"; -$crypto.=" crypto/pkcs12/pkcs12.h"; -$crypto.=" crypto/x509/x509.h"; -$crypto.=" crypto/x509/x509_vfy.h"; -$crypto.=" crypto/x509v3/x509v3.h"; -$crypto.=" crypto/rand/rand.h"; -$crypto.=" crypto/comp/comp.h" ; # unless $no_comp; -$crypto.=" crypto/ocsp/ocsp.h"; -$crypto.=" crypto/ui/ui.h crypto/ui/ui_compat.h"; -$crypto.=" crypto/krb5/krb5_asn.h"; -$crypto.=" crypto/store/store.h"; -$crypto.=" crypto/pqueue/pqueue.h"; - -my $symhacks="crypto/symhacks.h"; +my $ssl="include/openssl/ssl.h"; +$ssl.=" include/openssl/tls1.h"; +$ssl.=" include/openssl/srtp.h"; + +my $crypto ="include/openssl/crypto.h"; +$crypto.=" crypto/include/internal/cryptlib.h"; +$crypto.=" crypto/include/internal/chacha.h"; # unless $no_chacha; +$crypto.=" crypto/include/internal/poly1305.h"; # unless $no_poly1305; +$crypto.=" include/internal/o_dir.h"; +$crypto.=" include/internal/o_str.h"; +$crypto.=" include/openssl/des.h" ; # unless $no_des; +$crypto.=" include/openssl/idea.h" ; # unless $no_idea; +$crypto.=" include/openssl/rc4.h" ; # unless $no_rc4; +$crypto.=" include/openssl/rc5.h" ; # unless $no_rc5; +$crypto.=" include/openssl/rc2.h" ; # unless $no_rc2; +$crypto.=" include/openssl/blowfish.h" ; # unless $no_bf; +$crypto.=" include/openssl/cast.h" ; # unless $no_cast; +$crypto.=" include/openssl/whrlpool.h" ; +$crypto.=" include/openssl/md2.h" ; # unless $no_md2; +$crypto.=" include/openssl/md4.h" ; # unless $no_md4; +$crypto.=" include/openssl/md5.h" ; # unless $no_md5; +$crypto.=" include/openssl/mdc2.h" ; # unless $no_mdc2; +$crypto.=" include/openssl/sha.h" ; # unless $no_sha; +$crypto.=" include/openssl/ripemd.h" ; # unless $no_ripemd; +$crypto.=" include/openssl/aes.h" ; # unless $no_aes; +$crypto.=" include/openssl/camellia.h" ; # unless $no_camellia; +$crypto.=" include/openssl/seed.h"; # unless $no_seed; + +$crypto.=" include/openssl/bn.h"; +$crypto.=" include/openssl/rsa.h" ; # unless $no_rsa; +$crypto.=" include/openssl/dsa.h" ; # unless $no_dsa; +$crypto.=" include/openssl/dh.h" ; # unless $no_dh; +$crypto.=" include/openssl/ec.h" ; # unless $no_ec; +$crypto.=" include/openssl/hmac.h" ; # unless $no_hmac; +$crypto.=" include/openssl/cmac.h" ; + +$crypto.=" include/openssl/engine.h"; # unless $no_engine; +$crypto.=" include/openssl/stack.h" ; # unless $no_stack; +$crypto.=" include/openssl/buffer.h" ; # unless $no_buffer; +$crypto.=" include/openssl/bio.h" ; # unless $no_bio; +$crypto.=" include/openssl/dso.h" ; # unless $no_dso; +$crypto.=" include/openssl/lhash.h" ; # unless $no_lhash; +$crypto.=" include/openssl/conf.h"; +$crypto.=" include/openssl/txt_db.h"; + +$crypto.=" include/openssl/evp.h" ; # unless $no_evp; +$crypto.=" include/openssl/objects.h"; +$crypto.=" include/openssl/pem.h"; +#$crypto.=" include/openssl/meth.h"; +$crypto.=" include/openssl/asn1.h"; +$crypto.=" include/openssl/asn1t.h"; +$crypto.=" include/openssl/err.h" ; # unless $no_err; +$crypto.=" include/openssl/pkcs7.h"; +$crypto.=" include/openssl/pkcs12.h"; +$crypto.=" include/openssl/x509.h"; +$crypto.=" include/openssl/x509_vfy.h"; +$crypto.=" include/openssl/x509v3.h"; +$crypto.=" include/openssl/ts.h"; +$crypto.=" include/openssl/rand.h"; +$crypto.=" include/openssl/comp.h" ; # unless $no_comp; +$crypto.=" include/openssl/ocsp.h"; +$crypto.=" include/openssl/ui.h"; +#$crypto.=" include/openssl/store.h"; +$crypto.=" include/openssl/pqueue.h"; +$crypto.=" include/openssl/cms.h"; +$crypto.=" include/openssl/jpake.h"; +$crypto.=" include/openssl/srp.h"; +$crypto.=" include/openssl/modes.h"; +$crypto.=" include/openssl/async.h"; + +my $symhacks="include/openssl/symhacks.h"; my @ssl_symbols = &do_defs("SSLEAY", $ssl, $symhacks); my @crypto_symbols = &do_defs("LIBEAY", $crypto, $symhacks); @@ -365,6 +419,7 @@ sub do_defs # is the same name as the original. my $cpp; my %unknown_algorithms = (); + my $parens = 0; foreach $file (split(/\s+/,$symhacksfile." ".$files)) { @@ -375,6 +430,7 @@ sub do_defs (map { $_ => 0 } @known_platforms), (map { "OPENSSL_SYS_".$_ => 0 } @known_ossl_platforms), (map { "OPENSSL_NO_".$_ => 0 } @known_algorithms), + (map { "OPENSSL_USE_".$_ => 0 } @known_algorithms), NOPROTO => 0, PERL5 => 0, _WINDLL => 0, @@ -437,6 +493,18 @@ sub do_defs print STDERR "DEBUG: parsing ----------\n" if $debug; while() { + if($parens > 0) { + #Inside a DECLARE_DEPRECATED + $stored_multiline .= $_; + chomp $stored_multiline; + print STDERR "DEBUG: Continuing multiline DEPRECATED: $stored_multiline\n" if $debug; + $parens = count_parens($stored_multiline); + if ($parens == 0) { + $stored_multiline =~ /^\s*DECLARE_DEPRECATED\s*\(\s*(\w*(\s|\*|\w)*)/; + $def .= "$1(void);"; + } + next; + } if (/\/\* Error codes for the \w+ functions\. \*\//) { undef @tag; @@ -454,17 +522,22 @@ sub do_defs next; } - $cpp = 1 if /^\#.*ifdef.*cplusplus/; + if(/\/\*/) { + if (not /\*\//) { # multiline comment... + $line = $_; # ... just accumulate + next; + } else { + s/\/\*.*?\*\///gs;# wipe it + } + } + if ($cpp) { - $cpp = 0 if /^\#.*endif/; + $cpp++ if /^#\s*if/; + $cpp-- if /^#\s*endif/; next; } + $cpp = 1 if /^#.*ifdef.*cplusplus/; - s/\/\*.*?\*\///gs; # ignore comments - if (/\/\*/) { # if we have part - $line = $_; # of a comment, - next; # continue reading - } s/{[^{}]*}//gs; # ignore {} blocks print STDERR "DEBUG: \$def=\"$def\"\n" if $debug && $def ne ""; print STDERR "DEBUG: \$_=\"$_\"\n" if $debug; @@ -535,6 +608,8 @@ sub do_defs pop(@tag); if ($t =~ /^OPENSSL_NO_([A-Z0-9_]+)$/) { $t=$1; + } elsif($t =~ /^OPENSSL_USE_([A-Z0-9_]+)$/) { + $t=$1; } else { $t=""; } @@ -584,10 +659,15 @@ sub do_defs map { $tag{"OPENSSL_SYS_".$_} == 1 ? $_ : $tag{"OPENSSL_SYS_".$_} == -1 ? "!".$_ : "" } @known_ossl_platforms); + @current_algorithms = (); @current_algorithms = grep(!/^$/, map { $tag{"OPENSSL_NO_".$_} == -1 ? $_ : "" } @known_algorithms); + push @current_algorithms + , grep(!/^$/, + map { $tag{"OPENSSL_USE_".$_} == 1 ? $_ : "" } + @known_algorithms); $def .= "#INFO:" .join(',',@current_platforms).":" @@ -753,10 +833,9 @@ sub do_defs } elsif (/^DECLARE_PEM_rw\s*\(\s*(\w*)\s*,/ || /^DECLARE_PEM_rw_cb\s*\(\s*(\w*)\s*,/ || /^DECLARE_PEM_rw_const\s*\(\s*(\w*)\s*,/ ) { - # Things not in Win16 $def .= "#INFO:" - .join(',',"!WIN16",@current_platforms).":" + .join(',',@current_platforms).":" .join(',',@current_algorithms).";"; $def .= "int PEM_read_$1(void);"; $def .= "int PEM_write_$1(void);"; @@ -769,11 +848,11 @@ sub do_defs $def .= "int PEM_write_bio_$1(void);"; next; } elsif (/^DECLARE_PEM_write\s*\(\s*(\w*)\s*,/ || + /^DECLARE_PEM_write_const\s*\(\s*(\w*)\s*,/ || /^DECLARE_PEM_write_cb\s*\(\s*(\w*)\s*,/ ) { - # Things not in Win16 $def .= "#INFO:" - .join(',',"!WIN16",@current_platforms).":" + .join(',',@current_platforms).":" .join(',',@current_algorithms).";"; $def .= "int PEM_write_$1(void);"; $def .= @@ -785,10 +864,9 @@ sub do_defs 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_platforms).":" .join(',',@current_algorithms).";"; $def .= "int PEM_read_$1(void);"; $def .= @@ -817,6 +895,16 @@ sub do_defs &$make_variant("_shadow_$2","_shadow_$2", "EXPORT_VAR_AS_FUNCTION", "FUNCTION"); + } elsif (/^\s*DECLARE_DEPRECATED\s*\(\s*(\w*(\s|\*|\w)*)/) { + $parens = count_parens($_); + if ($parens == 0) { + $def .= "$1(void);"; + } else { + $stored_multiline = $_; + chomp $stored_multiline; + print STDERR "DEBUG: Found multiline DEPRECATED starting with: $stored_multiline\n" if $debug; + next; + } } elsif ($tag{'CONST_STRICT'} != 1) { if (/\{|\/\*|\([^\)]*$/) { $line = $_; @@ -840,6 +928,18 @@ sub do_defs next if(/typedef\W/); next if(/\#define/); + # 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; + s/LHASH_OF\(\)/void/gs; + print STDERR "DEBUG: \$_ = \"$_\"\n" if $debug; if (/^\#INFO:([^:]*):(.*)$/) { $plats = $1; @@ -850,25 +950,11 @@ sub do_defs $s = $1; $k = "VARIABLE"; print STDERR "DEBUG: found external variable $s\n" if $debug; - } elsif (/\(\*(\w*(\{[0-9]+\})?)\([^\)]+/) { - $s = $1; - print STDERR "DEBUG: found ANSI C function $s\n" if $debug; - } elsif (/\w+\W+(\w+)\W*\(\s*\)(\s*__attribute__\(.*\)\s*)?$/s) { - # K&R C - print STDERR "DEBUG: found K&R C function $s\n" if $debug; + } elsif (/TYPEDEF_\w+_OF/s) { next; - } elsif (/\w+\W+\w+(\{[0-9]+\})?\W*\(.*\)(\s*__attribute__\(.*\)\s*)?$/s) { - while (not /\(\)(\s*__attribute__\(.*\)\s*)?$/s) { - s/[^\(\)]*\)(\s*__attribute__\(.*\)\s*)?$/\)/s; - s/\([^\(\)]*\)\)(\s*__attribute__\(.*\)\s*)?$/\)/s; - } - s/\(void\)//; - /(\w+(\{[0-9]+\})?)\W*\(\)/s; - $s = $1; + } elsif (/(\w+)\s*\(\).*/s) { # first token prior [first] () is + $s = $1; # a function name! print STDERR "DEBUG: found function $s\n" if $debug; - - } elsif (/TYPEDEF_\w+_OF/) { - next; } elsif (/\(/ and not (/=/)) { print STDERR "File $file: cannot parse: $_;\n"; next; @@ -892,10 +978,8 @@ sub do_defs $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 .= ",RMD160" if($s =~ /EVP_ripemd/); $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/); @@ -923,12 +1007,25 @@ sub do_defs # Prune the returned symbols delete $syms{"bn_dump1"}; - $platform{"BIO_s_log"} .= ",!WIN32,!WIN16,!macintosh"; + $platform{"BIO_s_log"} .= ",!WIN32,!macintosh"; $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"; + $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"; + # Info we know about @@ -1011,9 +1108,9 @@ sub maybe_add_info { (my $s, my $i) = split /\\/, $sym; if (defined($nums{$s})) { $i =~ s/^(.*?:.*?:\w+)(\(\w+\))?/$1/; - (my $n, my $dummy) = split /\\/, $nums{$s}; + (my $n, my $vers, my $dummy) = split /\\/, $nums{$s}; if (!defined($dummy) || $i ne $dummy) { - $nums{$s} = $n."\\".$i; + $nums{$s} = $n."\\".$vers."\\".$i; $new_info++; print STDERR "DEBUG: maybe_add_info for $s: \"$dummy\" => \"$i\"\n" if $debug; } @@ -1023,7 +1120,7 @@ sub maybe_add_info { 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}; + (my $n, my $vers, my $i) = split /\\/, $nums{$sym}; if (!defined($syms{$sym}) && $i !~ /^NOEXIST:/) { $new_info++; print STDERR "DEBUG: maybe_add_info for $sym: -> undefined\n" if $debug; @@ -1053,18 +1150,20 @@ sub is_valid if ($platforms) { # platforms + if ($keyword eq "VMSVAX" && $VMSVAX) { return 1; } + if ($keyword eq "VMSNonVAX" && $VMSNonVAX) { return 1; } 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; } if ($keyword eq "OS2" && $OS2) { return 1; } # Special platforms: # EXPORT_VAR_AS_FUNCTION means that global variables # will be represented as functions. This currently # only happens on VMS-VAX. - if ($keyword eq "EXPORT_VAR_AS_FUNCTION" && ($VMSVAX || $W32 || $W16)) { + if ($keyword eq "EXPORT_VAR_AS_FUNCTION" && ($VMSVAX || $W32)) { return 1; } + if ($keyword eq "ZLIB" && $zlib) { return 1; } return 0; } else { # algorithms @@ -1079,17 +1178,19 @@ sub is_valid 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 "RMD160" && $no_ripemd) { return 0; } if ($keyword eq "MDC2" && $no_mdc2) { return 0; } if ($keyword eq "WHIRLPOOL" && $no_whirlpool) { return 0; } if ($keyword eq "RSA" && $no_rsa) { return 0; } if ($keyword eq "DSA" && $no_dsa) { return 0; } if ($keyword eq "DH" && $no_dh) { return 0; } if ($keyword eq "EC" && $no_ec) { return 0; } - if ($keyword eq "ECDSA" && $no_ecdsa) { return 0; } - if ($keyword eq "ECDH" && $no_ecdh) { return 0; } - if ($keyword eq "HMAC" && $no_hmac) { return 0; } if ($keyword eq "AES" && $no_aes) { return 0; } + if ($keyword eq "CAMELLIA" && $no_camellia) { return 0; } + if ($keyword eq "SEED" && $no_seed) { return 0; } + if ($keyword eq "SCRYPT" && $no_scrypt) { return 0; } + if ($keyword eq "CHACHA" && $no_chacha) { return 0; } + if ($keyword eq "POLY1305" && $no_poly1305) { return 0; } if ($keyword eq "EVP" && $no_evp) { return 0; } if ($keyword eq "LHASH" && $no_lhash) { return 0; } if ($keyword eq "STACK" && $no_stack) { return 0; } @@ -1098,13 +1199,28 @@ sub is_valid if ($keyword eq "BIO" && $no_bio) { return 0; } if ($keyword eq "COMP" && $no_comp) { return 0; } if ($keyword eq "DSO" && $no_dso) { return 0; } - if ($keyword eq "KRB5" && $no_krb5) { return 0; } if ($keyword eq "ENGINE" && $no_engine) { return 0; } if ($keyword eq "HW" && $no_hw) { return 0; } if ($keyword eq "FP_API" && $no_fp_api) { return 0; } if ($keyword eq "STATIC_ENGINE" && $no_static_engine) { return 0; } - if ($keyword eq "GMP" && $no_gmp) { return 0; } + if ($keyword eq "SCT" && $no_sct) { return 0; } + if ($keyword eq "RFC3779" && $no_rfc3779) { return 0; } + if ($keyword eq "PSK" && $no_psk) { return 0; } + if ($keyword eq "CMS" && $no_cms) { return 0; } + if ($keyword eq "EC_NISTP_64_GCC_128" && $no_nistp_gcc) + { return 0; } + if ($keyword eq "EC2M" && $no_ec2m) { return 0; } + if ($keyword eq "NEXTPROTONEG" && $no_nextprotoneg) { return 0; } + if ($keyword eq "SSL3_METHOD" && $no_ssl3_method) { return 0; } + if ($keyword eq "SSL_TRACE" && $no_ssl_trace) { return 0; } + if ($keyword eq "CAPIENG" && $no_capieng) { return 0; } + if ($keyword eq "JPAKE" && $no_jpake) { return 0; } + if ($keyword eq "SRP" && $no_srp) { return 0; } + if ($keyword eq "SCTP" && $no_sctp) { return 0; } + if ($keyword eq "SRTP" && $no_srtp) { return 0; } + if ($keyword eq "UNIT_TEST" && $no_unit_test) { return 0; } if ($keyword eq "DEPRECATED" && $no_deprecated) { return 0; } + if ($keyword eq "OCB" && $no_ocb) { return 0; } # Nothing recognise as true return 1; @@ -1149,7 +1265,7 @@ sub print_test_file } $prev = $s2; # To warn about duplicates... - ($nn,$ni)=($nums{$s2} =~ /^(.*?)\\(.*)$/); + (my $nn, my $vers, my $ni) = split /\\/, $nums{$s2}; if ($v) { print OUT "\textern int $s2; /* type unknown */ /* $nn $ni */\n"; } else { @@ -1180,11 +1296,13 @@ sub print_def_file my $version = get_version(); my $what = "OpenSSL: implementation of Secure Socket Layer"; my $description = "$what $version, $name - http://$http_vendor"; + my $prevsymversion = "", $prevprevsymversion = ""; + # For VMS + my $prevnum = 0; + my $symbolcount = 0; if ($W32) { $libname.="32"; } - elsif ($W16) - { $libname.="16"; } elsif ($OS2) { # DLL names should not clash on the whole system. # However, they should not have any particular relationship @@ -1200,64 +1318,135 @@ EOO $description = "\@#$http_vendor:$version#\@$what; DLL for library $name. Build for EMX -Zmtd"; } - print OUT <<"EOF"; + if ($W32 || $OS2) + { + print OUT <<"EOF"; ; ; Definition file for the DLL version of the $name library from OpenSSL ; LIBRARY $libname $liboptions -DESCRIPTION '$description' - EOF - if ($W16) { - print <<"EOF"; -CODE PRELOAD MOVEABLE -DATA PRELOAD MOVEABLE SINGLE - -EXETYPE WINDOWS - -HEAPSIZE 4096 -STACKSIZE 8192 - + print "EXPORTS\n"; + } + elsif ($VMS) + { + my $libref = $name eq "ssl" ? "LIBCRYPTO.EXE /SHARE" : ""; + print OUT <<"EOF"; +IDENTIFICATION="LIB$libname V$version" +LIB$libname.OLB /LIBRARY +$libref +SYMBOL_VECTOR=(- EOF - } - - print "EXPORTS\n"; + } - (@e)=grep(/^SSLeay(\{[0-9]+\})?\\.*?:.*?:FUNCTION/,@symbols); - (@r)=grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:FUNCTION/ && !/^SSLeay(\{[0-9]+\})?\\.*?:.*?:FUNCTION/,@symbols); + (@r)=grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:FUNCTION/,@symbols); (@v)=grep(/^\w+(\{[0-9]+\})?\\.*?:.*?:VARIABLE/,@symbols); - @symbols=((sort @e),(sort @r), (sort @v)); - - - foreach $sym (@symbols) { - (my $s, my $i) = $sym =~ /^(.*?)\\(.*)$/; - my $v = 0; - $v = 1 if $i =~ /^.*?:.*?:VARIABLE/; - if (!defined($nums{$s})) { - printf STDERR "Warning: $s does not have a number assigned\n" - if(!$do_update); + if ($VMS) { + # VMS needs to have the symbols on slot number order + @symbols=(map { $_->[1] } + sort { $a->[0] <=> $b->[0] } + map { (my $s, my $i) = $_ =~ /^(.*?)\\(.*)$/; + die "Error: $s doesn't have a number assigned\n" + if !defined($nums{$s}); + (my $n, my @rest) = split /\\/, $nums{$s}; + [ $n, $_ ] } (@e, @r, @v)); + } else { + @symbols=((sort @e),(sort @r), (sort @v)); + } + + my ($baseversion, $currversion) = get_openssl_version(); + my $thisversion; + do { + if (!defined($thisversion)) { + $thisversion = $baseversion; } else { - (my $n, my $dummy) = split /\\/, $nums{$s}; - my %pf = (); - 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... - if($v && !$OS2) { - printf OUT " %s%-39s @%-8d DATA\n",($W32)?"":"_",$s2,$n; - } else { - printf OUT " %s%-39s @%d\n",($W32||$OS2)?"":"_",$s2,$n; + $thisversion = get_next_version($thisversion); + } + foreach $sym (@symbols) { + (my $s, my $i) = $sym =~ /^(.*?)\\(.*)$/; + my $v = 0; + $v = 1 if $i =~ /^.*?:.*?:VARIABLE/; + if (!defined($nums{$s})) { + die "Error: $s does not have a number assigned\n" + if(!$do_update); + } else { + (my $n, my $symversion, my $dummy) = split /\\/, $nums{$s}; + next if $symversion ne $thisversion; + my %pf = (); + 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... + if($linux) { + if ($symversion ne $prevsymversion) { + if ($prevsymversion ne "") { + if ($prevprevsymversion ne "") { + print OUT "} OPENSSL_" + ."$prevprevsymversion;\n\n"; + } else { + print OUT "};\n\n"; + } + } + print OUT "OPENSSL_$symversion {\n global:\n"; + $prevprevsymversion = $prevsymversion; + $prevsymversion = $symversion; + } + print OUT " $s2;\n"; + } elsif ($VMS) { + while(++$prevnum < $n) { + if ($symbolcount > 1023) { + print OUT ")\nSYMBOL_VECTOR=(-\n"; + $symbolcount = 0; + } + print OUT $symbolcount + ? " ," : " "; + print OUT "dummy$prevnum=PRIVATE_PROCEDURE -\n"; + $symbolcount++; + } + (my $s_uc = $s) =~ tr/a-z/A-Z/; + if ($symbolcount > 1023) { + print OUT ")\nSYMBOL_VECTOR=(-\n"; + $symbolcount = 0; + } + print OUT $symbolcount + ? " ," : " "; + print OUT "$s_uc/$s=" + , ($v ? "DATA" : "PROCEDURE"), " -\n"; + $symbolcount++; + } elsif($v && !$OS2) { + printf OUT " %s%-39s @%-8d DATA\n", + ($W32)?"":"_",$s2,$n; + } else { + printf OUT " %s%-39s @%d\n", + ($W32||$OS2)?"":"_",$s2,$n; + } } } } - } + } while ($thisversion ne $currversion); + if ($linux) { + if ($prevprevsymversion ne "") { + print OUT " local: *;\n} OPENSSL_$prevprevsymversion;\n\n"; + } else { + print OUT " local: *;\n};\n\n"; + } + } elsif ($VMS) { + print OUT ")\n"; + (my $libvmaj, my $libvmin, my $libvedit) = + $currversion =~ /^(\d+)_(\d+)_(\d+)$/; + # The reason to multiply the edit number with 100 is to make space + # for the possibility that we want to encode the patch letters + print OUT "GSMATCH=LEQUAL,",($libvmaj * 100 + $libvmin),",",($libvedit * 100),"\n"; + } printf OUT "\n"; } @@ -1265,12 +1454,15 @@ sub load_numbers { my($name)=@_; my(@a,%ret); + my $prevversion; $max_num = 0; $num_noinfo = 0; $prev = ""; $prev_cnt = 0; + my ($baseversion, $currversion) = get_openssl_version(); + open(IN,"<$name") || die "unable to open $name:$!\n"; while () { chop; @@ -1300,7 +1492,13 @@ sub load_numbers $ret{$a[0]}=$a[1]; $num_noinfo++; } else { - $ret{$a[0]}=$a[1]."\\".$a[2]; # \\ is a special marker + #Sanity check the version number + if (defined $prevversion) { + check_version_lte($prevversion, $a[2]); + } + check_version_lte($a[2], $currversion); + $prevversion = $a[2]; + $ret{$a[0]}=$a[1]."\\".$a[2]."\\".$a[3]; # \\ is a special marker } $max_num = $a[1] if $a[1] > $max_num; $prev=$a[0]; @@ -1320,7 +1518,7 @@ sub load_numbers sub parse_number { (my $str, my $what) = @_; - (my $n, my $i) = split(/\\/,$str); + (my $n, my $v, my $i) = split(/\\/,$str); if ($what eq "n") { return $n; } else { @@ -1356,7 +1554,7 @@ sub rewrite_numbers || $a cmp $b } keys %nums; foreach $sym (@s) { - (my $n, my $i) = split /\\/, $nums{$sym}; + (my $n, my $vers, my $i) = split /\\/, $nums{$sym}; next if defined($i) && $i =~ /^.*?:.*?:\w+\(\w+\)/; next if defined($rsyms{$sym}); print STDERR "DEBUG: rewrite_numbers for sym = ",$sym,": i = ",$i,", n = ",$n,", rsym{sym} = ",$rsyms{$sym},"syms{sym} = ",$syms{$sym},"\n" if $debug; @@ -1364,12 +1562,12 @@ sub rewrite_numbers if !defined($i) || $i eq "" || !defined($syms{$sym}); my $s2 = $sym; $s2 =~ s/\{[0-9]+\}$//; - printf OUT "%s%-39s %d\t%s\n","",$s2,$n,$i; + printf OUT "%s%-39s %d\t%s\t%s\n","",$s2,$n,$vers,$i; if (exists $r{$sym}) { (my $s, $i) = split /\\/,$r{$sym}; my $s2 = $s; $s2 =~ s/\{[0-9]+\}$//; - printf OUT "%s%-39s %d\t%s\n","",$s2,$n,$i; + printf OUT "%s%-39s %d\t%s\t%s\n","",$s2,$n,$vers,$i; } } } @@ -1378,6 +1576,10 @@ sub update_numbers { (*OUT,$name,*nums,my $start_num, my @symbols)=@_; my $new_syms = 0; + my $basevers; + my $vers; + + ($basevers, $vers) = get_openssl_version(); print STDERR "Updating $name numbers\n"; @@ -1401,11 +1603,11 @@ sub update_numbers $new_syms++; my $s2 = $s; $s2 =~ s/\{[0-9]+\}$//; - printf OUT "%s%-39s %d\t%s\n","",$s2, ++$start_num,$i; + printf OUT "%s%-39s %d\t%s\t%s\n","",$s2, ++$start_num,$vers,$i; if (exists $r{$s}) { ($s, $i) = split /\\/,$r{$s}; $s =~ s/\{[0-9]+\}$//; - printf OUT "%s%-39s %d\t%s\n","",$s, $start_num,$i; + printf OUT "%s%-39s %d\t%s\t%s\n","",$s, $start_num,$vers,$i; } } } @@ -1438,3 +1640,143 @@ sub check_existing } } +sub count_parens +{ + my $line = shift(@_); + + my $open = $line =~ tr/\(//; + my $close = $line =~ tr/\)//; + + return $open - $close; +} + +#Parse opensslv.h to get the current version number. Also work out the base +#version, i.e. the lowest version number that is binary compatible with this +#version +sub get_openssl_version() +{ + open (IN, "include/openssl/opensslv.h") || die "Can't open opensslv.h"; + + while() { + if (/OPENSSL_VERSION_TEXT\s+"OpenSSL (\d\.\d\.)(\d[a-z]*)(-| )/) { + my $suffix = $2; + my $baseversion = $1 =~ s/\./_/gr; + close IN; + return ($baseversion."0", $baseversion.$suffix); + } + } + die "Can't find OpenSSL version number\n"; +} + +#Given an OpenSSL version number, calculate the next version number. If the +#version number gets to a.b.czz then we go to a.b.(c+1) +sub get_next_version() +{ + my $thisversion = shift; + + my ($base, $letter) = $thisversion =~ /^(\d_\d_\d)([a-z]{0,2})$/; + + if ($letter eq "zz") { + my $lastnum = substr($base, -1); + return substr($base, 0, length($base)-1).(++$lastnum); + } + return $base.get_next_letter($letter); +} + +#Given the letters off the end of an OpenSSL version string, calculate what +#the letters for the next release would be. +sub get_next_letter() +{ + my $thisletter = shift; + my $baseletter = ""; + my $endletter; + + if ($thisletter eq "") { + return "a"; + } + if ((length $thisletter) > 1) { + ($baseletter, $endletter) = $thisletter =~ /([a-z]+)([a-z])/; + } else { + $endletter = $thisletter; + } + + if ($endletter eq "z") { + return $thisletter."a"; + } else { + return $baseletter.(++$endletter); + } +} + +#Check if a version is less than or equal to the current version. Its a fatal +#error if not. They must also only differ in letters, or the last number (i.e. +#the first two numbers must be the same) +sub check_version_lte() +{ + my ($testversion, $currversion) = @_; + my $lentv; + my $lencv; + my $cvbase; + + my ($cvnums) = $currversion =~ /^(\d_\d_\d)[a-z]*$/; + my ($tvnums) = $testversion =~ /^(\d_\d_\d)[a-z]*$/; + + #Die if we can't parse the version numbers or they don't look sane + die "Invalid version number: $testversion and $currversion\n" + if (!defined($cvnums) || !defined($tvnums) + || length($cvnums) != 5 + || length($tvnums) != 5); + + #If the base versions (without letters) don't match check they only differ + #in the last number + if ($cvnums ne $tvnums) { + die "Invalid version number: $testversion " + ."for current version $currversion\n" + if (substr($cvnums, -1) < substr($tvnums, -1) + || substr($cvnums, 0, 4) ne substr($tvnums, 0, 4)); + return; + } + #If we get here then the base version (i.e. the numbers) are the same - they + #only differ in the letters + + $lentv = length $testversion; + $lencv = length $currversion; + + #If the testversion has more letters than the current version then it must + #be later (or malformed) + if ($lentv > $lencv) { + die "Invalid version number: $testversion " + ."is greater than $currversion\n"; + } + + #Get the last letter from the current version + my ($cvletter) = $currversion =~ /([a-z])$/; + if (defined $cvletter) { + ($cvbase) = $currversion =~ /(\d_\d_\d[a-z]*)$cvletter$/; + } else { + $cvbase = $currversion; + } + die "Unable to parse version number $currversion" if (!defined $cvbase); + my $tvbase; + my ($tvletter) = $testversion =~ /([a-z])$/; + if (defined $tvletter) { + ($tvbase) = $testversion =~ /(\d_\d_\d[a-z]*)$tvletter$/; + } else { + $tvbase = $testversion; + } + die "Unable to parse version number $testversion" if (!defined $tvbase); + + if ($lencv > $lentv) { + #If current version has more letters than testversion then testversion + #minus the final letter must be a substring of the current version + die "Invalid version number $testversion " + ."is greater than $currversion or is invalid\n" + if (index($cvbase, $tvbase) != 0); + } else { + #If both versions have the same number of letters then they must be + #equal up to the last letter, and the last letter in testversion must + #be less than or equal to the last letter in current version. + die "Invalid version number $testversion " + ."is greater than $currversion\n" + if (($cvbase ne $tvbase) && ($tvletter gt $cvletter)); + } +}