mkdef.pl 25.8 KB
Newer Older
1
#!/usr/local/bin/perl -w
2 3 4 5
#
# generate a .def file
#
# It does this by parsing the header files and looking for the
6
# prototyped functions: it then prunes the output.
7
#
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42
# 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
#   symbol name replacements for platforms where the names are too long for the
#   compiler or linker, or if the systems is case insensitive and there is a
#   clash.  This script assumes those redefinitions are place in the file
43 44 45 46 47 48 49 50
#   crypto/symhacks.h.
#   The semantics for the platforms list is a bit complicated.  The rule of
#   thumb is that the list is exclusive, but it seems to mean different things.
#   So, if the list is all negatives (like "!VMS,!WIN16"), the symbol exists
#   on all platforms except those listed.  If the list is all positives (like
#   "VMS,WIN16"), the symbol exists only on those platforms and nowhere else.
#   The combination of positives and negatives will act as if the positives
#   weren't there.
51 52 53 54 55
# - "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.
#
56

57 58
my $crypto_num= "util/libeay.num";
my $ssl_num=    "util/ssleay.num";
59

60
my $do_update = 0;
61
my $do_rewrite = 0;
62 63
my $do_crypto = 0;
my $do_ssl = 0;
64
my $do_ctest = 0;
65
my $do_ctestall = 0;
66
my $rsaref = 0;
67

68 69 70
my $VMS=0;
my $W32=0;
my $W16=0;
71
my $NT=0;
72
# Set this to make typesafe STACK definitions appear in DEF
73
my $safe_stack_def = 0;
74

75 76 77 78
my @known_platforms = ( "__FreeBSD__", "VMS", "WIN16", "WIN32",
			"WINNT", "PERL5", "NeXT" );
my @known_algorithms = ( "RC2", "RC4", "RC5", "IDEA", "DES", "BF",
			 "CAST", "MD2", "MD4", "MD5", "SHA", "RIPEMD",
79 80
			 "MDC2", "RSA", "DSA", "DH", "HMAC", "FP_API",
			 "RIJNDAEL" );
81

82
my $options="";
83 84 85 86
open(IN,"<Makefile.ssl") || die "unable to open Makefile.ssl!\n";
while(<IN>) {
    $options=$1 if (/^OPTIONS=(.*)$/);
}
U
Ulf Möller 已提交
87
close(IN);
88

89 90 91 92
# 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;
93 94
my $no_cast;
my $no_md2; my $no_md4; my $no_md5; my $no_sha; my $no_ripemd; my $no_mdc2;
95
my $no_rsa; my $no_dsa; my $no_dh; my $no_hmac=0; my $no_rijndael;
96
my $no_fp_api;
97

98
foreach (@ARGV, split(/ /, $options))
99
	{
100
	$W32=1 if $_ eq "32";
101
	$W16=1 if $_ eq "16";
102 103 104 105
	if($_ eq "NT") {
		$W32 = 1;
		$NT = 1;
	}
106
	$VMS=1 if $_ eq "VMS";
107
	#$rsaref=1 if $_ eq "rsaref";
108

109
	$do_ssl=1 if $_ eq "ssleay";
110
	$do_ssl=1 if $_ eq "ssl";
111
	$do_crypto=1 if $_ eq "libeay";
112 113
	$do_crypto=1 if $_ eq "crypto";
	$do_update=1 if $_ eq "update";
114
	$do_rewrite=1 if $_ eq "rewrite";
D
Dr. Stephen Henson 已提交
115
	$do_ctest=1 if $_ eq "ctest";
116
	$do_ctestall=1 if $_ eq "ctestall";
117
	#$safe_stack_def=1 if $_ eq "-DDEBUG_SAFESTACK";
U
Ulf Möller 已提交
118 119 120 121 122

	if    (/^no-rc2$/)      { $no_rc2=1; }
	elsif (/^no-rc4$/)      { $no_rc4=1; }
	elsif (/^no-rc5$/)      { $no_rc5=1; }
	elsif (/^no-idea$/)     { $no_idea=1; }
123
	elsif (/^no-des$/)      { $no_des=1; $no_mdc2=1; }
U
Ulf Möller 已提交
124 125 126
	elsif (/^no-bf$/)       { $no_bf=1; }
	elsif (/^no-cast$/)     { $no_cast=1; }
	elsif (/^no-md2$/)      { $no_md2=1; }
127
	elsif (/^no-md4$/)      { $no_md4=1; }
U
Ulf Möller 已提交
128 129 130 131 132 133 134 135
	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; }
	elsif (/^no-hmac$/)	{ $no_hmac=1; }
136
	elsif (/^no-rijndael$/)	{ $no_rijndael=1; }
137 138
	}

D
Dr. Stephen Henson 已提交
139

140 141 142 143 144 145 146 147 148 149
# If no platform is given, assume WIN32
if ($W32 + $W16 + $VMS == 0) {
	$W32 = 1;
}

# Add extra knowledge
if ($W16) {
	$no_fp_api=1;
}

150 151
if (!$do_ssl && !$do_crypto)
	{
152
	print STDERR "usage: $0 ( ssl | crypto ) [ 16 | 32 | NT ]\n";
153 154 155 156
	exit(1);
	}

%ssl_list=&load_numbers($ssl_num);
157
$max_ssl = $max_num;
158
%crypto_list=&load_numbers($crypto_num);
159
$max_crypto = $max_num;
160

161
my $ssl="ssl/ssl.h";
162

163
my $crypto ="crypto/crypto.h";
U
Ulf Möller 已提交
164 165 166 167 168 169 170 171
$crypto.=" crypto/des/des.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/md2/md2.h" unless $no_md2;
172
$crypto.=" crypto/md4/md4.h" unless $no_md4;
U
Ulf Möller 已提交
173 174 175 176
$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;
177
$crypto.=" crypto/rijndael/rijndael.h" unless $no_rijndael;
178
$crypto.=" crypto/rijndael/rd_fst.h" unless $no_rijndael;
179 180

$crypto.=" crypto/bn/bn.h";
U
Ulf Möller 已提交
181 182 183 184
$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/hmac/hmac.h" unless $no_hmac;
185

186
$crypto.=" crypto/engine/engine.h";
187 188 189
$crypto.=" crypto/stack/stack.h";
$crypto.=" crypto/buffer/buffer.h";
$crypto.=" crypto/bio/bio.h";
190
$crypto.=" crypto/dso/dso.h";
191 192 193 194 195 196 197 198 199 200 201 202
$crypto.=" crypto/lhash/lhash.h";
$crypto.=" crypto/conf/conf.h";
$crypto.=" crypto/txt_db/txt_db.h";

$crypto.=" crypto/evp/evp.h";
$crypto.=" crypto/objects/objects.h";
$crypto.=" crypto/pem/pem.h";
#$crypto.=" crypto/meth/meth.h";
$crypto.=" crypto/asn1/asn1.h";
$crypto.=" crypto/asn1/asn1_mac.h";
$crypto.=" crypto/err/err.h";
$crypto.=" crypto/pkcs7/pkcs7.h";
203
$crypto.=" crypto/pkcs12/pkcs12.h";
204 205
$crypto.=" crypto/x509/x509.h";
$crypto.=" crypto/x509/x509_vfy.h";
206
$crypto.=" crypto/x509v3/x509v3.h";
207
$crypto.=" crypto/rand/rand.h";
208
$crypto.=" crypto/comp/comp.h";
209
$crypto.=" crypto/ocsp/ocsp.h";
210
$crypto.=" crypto/tmdiff.h";
211

212
my $symhacks="crypto/symhacks.h";
213

214 215
my @ssl_symbols = &do_defs("SSLEAY", $ssl, $symhacks);
my @crypto_symbols = &do_defs("LIBEAY", $crypto, $symhacks);
216

217 218 219
if ($do_update) {

if ($do_ssl == 1) {
220 221 222 223 224 225 226 227 228 229

	&maybe_add_info("SSLEAY",*ssl_list,@ssl_symbols);
	if ($do_rewrite == 1) {
		open(OUT, ">$ssl_num");
		&rewrite_numbers(*OUT,"SSLEAY",*ssl_list,@ssl_symbols);
		close OUT;
	} else {
		open(OUT, ">>$ssl_num");
	}
	&update_numbers(*OUT,"SSLEAY",*ssl_list,$max_ssl,@ssl_symbols);
230 231 232 233
	close OUT;
}

if($do_crypto == 1) {
234 235 236 237 238 239 240 241 242

	&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);
243
	close OUT;
D
Dr. Stephen Henson 已提交
244 245
} 

246
} elsif ($do_ctest || $do_ctestall) {
D
Dr. Stephen Henson 已提交
247 248 249 250 251 252 253 254 255 256

	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
257
	&print_test_file(*STDOUT,"SSLEAY",*ssl_list,$do_ctestall,@ssl_symbols)
D
Dr. Stephen Henson 已提交
258 259
		if $do_ssl == 1;

260
	&print_test_file(*STDOUT,"LIBEAY",*crypto_list,$do_ctestall,@crypto_symbols)
D
Dr. Stephen Henson 已提交
261 262 263
		if $do_crypto == 1;

	print "}\n";
264 265

} else {
U
Ulf Möller 已提交
266

267
	&print_def_file(*STDOUT,"SSLEAY",*ssl_list,@ssl_symbols)
268 269
		if $do_ssl == 1;

270
	&print_def_file(*STDOUT,"LIBEAY",*crypto_list,@crypto_symbols)
271
		if $do_crypto == 1;
U
Ulf Möller 已提交
272

273
}
274 275 276


sub do_defs
277
{
278
	my($name,$files,$symhacksfile)=@_;
279
	my $file;
280
	my @ret;
281 282 283 284 285
	my %syms;
	my %platform;		# For anything undefined, we assume ""
	my %kind;		# For anything undefined, we assume "FUNCTION"
	my %algorithm;		# For anything undefined, we assume ""
	my %rename;
286
	my $cpp;
287

288
	foreach $file (split(/\s+/,$symhacksfile." ".$files))
289 290
		{
		open(IN,"<$file") || die "unable to open $file:$!\n";
291
		my $line = "", my $def= "";
292
		my %tag = (
293 294
			(map { $_ => 0 } @known_platforms),
			(map { "NO_".$_ => 0 } @known_algorithms),
295 296 297 298 299 300
			NOPROTO		=> 0,
			PERL5		=> 0,
			_WINDLL		=> 0,
			CONST_STRICT	=> 0,
			TRUE		=> 1,
		);
301
		my $symhacking = $file eq $symhacksfile;
302 303 304 305 306
		while(<IN>) {
			last if (/BEGIN ERROR CODES/);
			if ($line ne '') {
				$_ = $line . $_;
				$line = '';
307
			}
308 309 310 311 312 313

			if (/\\$/) {
				$line = $_;
				next;
			}

314
	    		$cpp = 1 if /^\#.*ifdef.*cplusplus/;
315
			if ($cpp) {
316
				$cpp = 0 if /^\#.*endif/;
317 318 319 320 321 322
				next;
	    		}

			s/\/\*.*?\*\///gs;                   # ignore comments
			s/{[^{}]*}//gs;                      # ignore {} blocks
			if (/^\#\s*ifndef (.*)/) {
323 324
				push(@tag,$1);
				$tag{$1}=-1;
325
			} elsif (/^\#\s*if !defined\(([^\)]+)\)/) {
326 327
				push(@tag,$1);
				$tag{$1}=-1;
328
			} elsif (/^\#\s*ifdef (.*)/) {
329 330
				push(@tag,$1);
				$tag{$1}=1;
331
			} elsif (/^\#\s*if defined\(([^\)]+)\)/) {
332 333
				push(@tag,$1);
				$tag{$1}=1;
334 335 336 337
			} elsif (/^\#\s*error\s+(\w+) is disabled\./) {
				if ($tag[$#tag] eq "NO_".$1) {
					$tag{$tag[$#tag]}=2;
				}
338
			} elsif (/^\#\s*endif/) {
339 340 341 342 343
				if ($tag{$tag[$#tag]}==2) {
					$tag{$tag[$#tag]}=-1;
				} else {
					$tag{$tag[$#tag]}=0;
				}
344
				pop(@tag);
345 346
			} elsif (/^\#\s*else/) {
				my $t=$tag[$#tag];
347
				$tag{$t}= -$tag{$t};
348 349 350 351
			} elsif (/^\#\s*if\s+1/) {
				# Dummy tag
				push(@tag,"TRUE");
				$tag{"TRUE"}=1;
B
Bodo Möller 已提交
352 353 354 355
			} elsif (/^\#\s*if\s+0/) {
				# Dummy tag
				push(@tag,"TRUE");
				$tag{"TRUE"}=-1;
356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374
			} elsif (/^\#\s*define\s+(\w+)\s+(\w+)/
				 && $symhacking) {
				my $s = $1;
				my $a =
				    $2.":".join(",", grep(!/^$/,
							  map { $tag{$_} == 1 ?
								    $_ : "" }
							  @known_platforms));
				$rename{$s} = $a;
			}
			if (/^\#/) {
				my @p = grep(!/^$/,
					     map { $tag{$_} == 1 ? $_ :
						       $tag{$_} == -1 ? "!".$_  : "" }
					     @known_platforms);
				my @a = grep(!/^$/,
					     map { $tag{"NO_".$_} == -1 ? $_ : "" }
					     @known_algorithms);
				$def .= "#INFO:".join(',',@p).":".join(',',@a).";";
375 376
				next;
			}
D
 
Dr. Stephen Henson 已提交
377
			if (/^\s*DECLARE_STACK_OF\s*\(\s*(\w*)\s*\)/) {
378
				next;
379 380
			} elsif (/^\s*DECLARE_PKCS12_STACK_OF\s*\(\s*(\w*)\s*\)/) {
				next;
D
 
Dr. Stephen Henson 已提交
381
			} elsif (/^\s*DECLARE_ASN1_SET_OF\s*\(\s*(\w*)\s*\)/) {
382
				next;
383
			} elsif (/^DECLARE_PEM_rw\s*\(\s*(\w*)\s*,/ ||
384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413
				 /^DECLARE_PEM_rw_cb\s*\(\s*(\w*)\s*,/ ) {
				# Things not in Win16
				$syms{"PEM_read_${1}"} = 1;
				$platform{"PEM_read_${1}"} = "!WIN16";
				$syms{"PEM_write_${1}"} = 1;
				$platform{"PEM_write_${1}"} = "!WIN16";
				# Things that are everywhere
				$syms{"PEM_read_bio_${1}"} = 1;
				$syms{"PEM_write_bio_${1}"} = 1;
				if ($1 eq "RSAPrivateKey" ||
				    $1 eq "RSAPublicKey" ||
				    $1 eq "RSA_PUBKEY") {
					$algorithm{"PEM_read_${1}"} = "RSA";
					$algorithm{"PEM_write_${1}"} = "RSA";
					$algorithm{"PEM_read_bio_${1}"} = "RSA";
					$algorithm{"PEM_write_bio_${1}"} = "RSA";
				}
				elsif ($1 eq "DSAPrivateKey" ||
				       $1 eq "DSAparams" ||
				       $1 eq "RSA_PUBKEY") {
					$algorithm{"PEM_read_${1}"} = "DSA";
					$algorithm{"PEM_write_${1}"} = "DSA";
					$algorithm{"PEM_read_bio_${1}"} = "DSA";
					$algorithm{"PEM_write_bio_${1}"} = "DSA";
				}
				elsif ($1 eq "DHparams") {
					$algorithm{"PEM_read_${1}"} = "DH";
					$algorithm{"PEM_write_${1}"} = "DH";
					$algorithm{"PEM_read_bio_${1}"} = "DH";
					$algorithm{"PEM_write_bio_${1}"} = "DH";
414
				}
415 416
			} elsif (/^DECLARE_PEM_write\s*\(\s*(\w*)\s*,/ ||
				     /^DECLARE_PEM_write_cb\s*\(\s*(\w*)\s*,/ ) {
417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436
				# Things not in Win16
				$syms{"PEM_write_${1}"} = 1;
				$platform{"PEM_write_${1}"} .= ",!WIN16";
				# Things that are everywhere
				$syms{"PEM_write_bio_${1}"} = 1;
				if ($1 eq "RSAPrivateKey" ||
				    $1 eq "RSAPublicKey" ||
				    $1 eq "RSA_PUBKEY") {
					$algorithm{"PEM_write_${1}"} = "RSA";
					$algorithm{"PEM_write_bio_${1}"} = "RSA";
				}
				elsif ($1 eq "DSAPrivateKey" ||
				       $1 eq "DSAparams" ||
				       $1 eq "RSA_PUBKEY") {
					$algorithm{"PEM_write_${1}"} = "DSA";
					$algorithm{"PEM_write_bio_${1}"} = "DSA";
				}
				elsif ($1 eq "DHparams") {
					$algorithm{"PEM_write_${1}"} = "DH";
					$algorithm{"PEM_write_bio_${1}"} = "DH";
437 438 439
				}
			} elsif (/^DECLARE_PEM_read\s*\(\s*(\w*)\s*,/ ||
				     /^DECLARE_PEM_read_cb\s*\(\s*(\w*)\s*,/ ) {
440 441 442 443 444
				# Things not in Win16
				$syms{"PEM_read_${1}"} = 1;
				$platform{"PEM_read_${1}"} .= ",!WIN16";
				# Things that are everywhere
				$syms{"PEM_read_bio_${1}"} = 1;
445
			} elsif (
446 447 448
				($tag{'TRUE'} != -1)
				&& ($tag{'CONST_STRICT'} != 1)
				 )
449
				{
450
					if (/\{|\/\*|\([^\)]*$/) {
451 452 453 454
						$line = $_;
					} else {
						$def .= $_;
					}
455 456 457
				}
			}
		close(IN);
458

459 460 461
		my $algs;
		my $plays;

462
		foreach (split /;/, $def) {
463
			my $s; my $k = "FUNCTION"; my $p; my $a;
464 465
			s/^[\n\s]*//g;
			s/[\n\s]*$//g;
466
			next if(/\#undef/);
467
			next if(/typedef\W/);
468 469 470 471 472 473 474 475 476 477 478
			next if(/\#define/);

			if (/^\#INFO:([^:]*):(.*)$/) {
				$plats = $1;
				$algs = $2;
				next;
			} elsif (/^\s*OPENSSL_EXTERN\s.*?(\w+)(\[[0-9]*\])*\s*$/) {
				$s = $1;
				$k = "VARIABLE";
			} elsif (/\(\*(\w*)\([^\)]+/) {
				$s = $1;
479 480 481 482 483 484 485 486 487 488
			} elsif (/\w+\W+(\w+)\W*\(\s*\)$/s) {
				# K&R C
				next;
			} elsif (/\w+\W+\w+\W*\(.*\)$/s) {
				while (not /\(\)$/s) {
					s/[^\(\)]*\)$/\)/s;
					s/\([^\(\)]*\)\)$/\)/s;
				}
				s/\(void\)//;
				/(\w+)\W*\(\)/s;
489
				$s = $1;
490 491
			} elsif (/\(/ and not (/=/)) {
				print STDERR "File $file: cannot parse: $_;\n";
492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530
				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/);

			$platform{$s} .= ','.$p;
			$algorithm{$s} .= ','.$a;

			if (defined($rename{$s})) {
				(my $r, my $p) = split(/:/,$rename{$s});
				my @ip = map { /^!(.*)$/ ? $1 : "!".$_ } split /,/, $p;
				$syms{$r} = 1;
				$kind{$r} = $kind{$s}."(".$s.")";
				$algorithm{$r} = $algorithm{$s};
				$platform{$r} = $platform{$s}.",".$p;
				$platform{$s} .= ','.join(',', @ip).','.join(',', @ip);
531
			}
532 533 534
		}
	}

535
	# Prune the returned symbols
536

537
	$platform{"crypt"} .= ",!PERL5,!__FreeBSD__,!NeXT";
538

539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594
        delete $syms{"SSL_add_dir_cert_subjects_to_stack"};
        delete $syms{"bn_dump1"};

	$platform{"BIO_s_file_internal"} .= ",WIN16";
	$platform{"BIO_new_file_internal"} .= ",WIN16";
	$platform{"BIO_new_fp_internal"} .= ",WIN16";

	$platform{"BIO_s_file"} .= ",!WIN16";
	$platform{"BIO_new_file"} .= ",!WIN16";
	$platform{"BIO_new_fp"} .= ",!WIN16";

	$platform{"BIO_s_log"} .= ",!WIN32,!WIN16,!macintosh";

	if(exists $syms{"ERR_load_CRYPTO_strings"}) {
		$platform{"ERR_load_CRYPTO_strings"} .= ",!VMS,!WIN16";
		$syms{"ERR_load_CRYPTOlib_strings"} = 1;
		$platform{"ERR_load_CRYPTOlib_strings"} .= ",VMS,WIN16";
	}

	# Info we know about

	$platform{"RSA_PKCS1_RSAref"} = "RSAREF";
	$algorithm{"RSA_PKCS1_RSAref"} = "RSA";

	push @ret, map { $_."\\".&info_string($_,"EXIST",
					      $platform{$_},
					      $kind{$_},
					      $algorithm{$_}) } keys %syms;

	return(@ret);
}

sub info_string {
	(my $symbol, my $exist, my $platforms, my $kind, my $algorithms) = @_;

	my %a = defined($algorithms) ?
	    map { $_ => 1 } split /,/, $algorithms : ();
	my $pl = defined($platforms) ? $platforms : "";
	my %p = map { $_ => 0 } split /,/, $pl;
	my $k = defined($kind) ? $kind : "FUNCTION";
	my $ret;

	# 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}++;
595
		}
596
	}
597 598
	foreach $platform (keys %p) {
		if ($p{$platform} == 0) { delete $p{$platform}; }
599 600
	}

601 602
	delete $p{""};
	delete $a{""};
603

604 605 606 607 608 609 610 611 612 613 614
	$ret = $exist;
	$ret .= ":".join(',',map { $p{$_} < 0 ? "!".$_ : $_ } keys %p);
	$ret .= ":".$k;
	$ret .= ":".join(',',keys %a);
	return $ret;
}

sub maybe_add_info {
	(my $name, *nums, my @symbols) = @_;
	my $sym;
	my $new_info = 0;
615
	my %syms=();
616 617 618 619 620 621 622 623 624 625 626 627 628

	print STDERR "Updating $name info\n";
	foreach $sym (@symbols) {
		(my $s, my $i) = split /\\/, $sym;
		$i =~ s/^(.*?:.*?:\w+)(\(\w+\))?/$1/;
		if (defined($nums{$s})) {
			(my $n, my $dummy) = split /\\/, $nums{$s};
			if (!defined($dummy) || $i ne $dummy) {
				$nums{$s} = $n."\\".$i;
				$new_info++;
				#print STDERR "DEBUG: maybe_add_info for $s: \"$dummy\" => \"$i\"\n";
			}
		}
629 630 631 632 633 634 635 636 637 638
		$syms{sym} = 1;
	}

	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};
		if (!defined($syms{sym})) {
			$new_info++;
			#print STDERR "DEBUG: maybe_add_info for $sym: -> undefined\n";
		}
639 640 641
	}
	if ($new_info) {
		print STDERR "$new_info old symbols got an info update\n";
642 643 644
		if (!$do_rewrite) {
			print STDERR "You should do a rewrite to fix this.\n";
		}
645 646 647
	} else {
		print STDERR "No old symbols needed info update\n";
	}
648
}
649

D
Dr. Stephen Henson 已提交
650 651
sub print_test_file
{
652
	(*OUT,my $name,*nums,my @symbols)=@_;
653
	my $n = 1; my @e; my @r;
654 655 656 657 658 659 660 661 662 663 664 665
	my $sym; my $prev = ""; my $prefSSLeay;

	(@e)=grep(/^SSLeay\\.*?:.*?:FUNCTION/,@symbols);
	(@r)=grep(/^\w+\\.*?:.*?:FUNCTION/ && !/^SSLeay\\.*?:.*?:FUNCTION/,@symbols);
	@symbols=((sort @e),(sort @r));

	foreach $sym (@symbols) {
		(my $s, my $i) = $sym =~ /^(.*?)\\(.*)$/;
		if ($s ne $prev) {
			if (!defined($nums{$sym})) {
				printf STDERR "Warning: $sym does not have a number assigned\n"
						if(!$do_update);
666
			} else {
667 668
				$n=$nums{$s};
				print OUT "\t$s();\n";
669
			}
D
Dr. Stephen Henson 已提交
670
		}
671
		$prev = $s;	# To avoid duplicates...
D
Dr. Stephen Henson 已提交
672 673 674
	}
}

675
sub print_def_file
676
{
677
	(*OUT,my $name,*nums,my @symbols)=@_;
678
	my $n = 1; my @e; my @r;
679

680
	if ($W32)
681 682 683 684 685 686
		{ $name.="32"; }
	else
		{ $name.="16"; }

	print OUT <<"EOF";
;
687
; Definition file for the DLL version of the $name library from OpenSSL
688 689 690 691
;

LIBRARY         $name

692
DESCRIPTION     'OpenSSL $name - http://www.openssl.org/'
693 694 695

EOF

696
	if (!$W32) {
697 698 699 700 701 702 703 704 705 706
		print <<"EOF";
CODE            PRELOAD MOVEABLE
DATA            PRELOAD MOVEABLE SINGLE

EXETYPE		WINDOWS

HEAPSIZE	4096
STACKSIZE	8192

EOF
707
	}
708 709 710

	print "EXPORTS\n";

711 712 713
	(@e)=grep(/^SSLeay\\.*?:.*?:FUNCTION/,@symbols);
	(@r)=grep(/^\w+\\.*?:.*?:FUNCTION/ && !/^SSLeay\\.*?:.*?:FUNCTION/,@symbols);
	@symbols=((sort @e),(sort @r));
714 715


716 717 718 719
	foreach $sym (@symbols) {
		(my $s, my $i) = $sym =~ /^(.*?)\\(.*)$/;
		if (!defined($nums{$s})) {
			printf STDERR "Warning: $s does not have a number assigned\n"
U
Ulf Möller 已提交
720
					if(!$do_update);
721
		} else {
722
			(my $n, my $i) = split /\\/, $nums{$s};
723
			my %pf = ();
724 725
			my @p = split(/,/, ($i =~ /^[^:]*:([^:]*):/,$1));
			my @a = split(/,/, ($i =~ /^[^:]*:[^:]*:[^:]*:([^:]*)/,$1));
726 727 728 729 730 731 732
			# @p_purged must contain hardware platforms only
			my @p_purged = ();
			foreach $ptmp (@p) {
				next if $ptmp =~ /^!?RSAREF$/;
				push @p_purged, $ptmp;
			}
			my $negatives = !!grep(/^!/,@p);
733
			# It is very important to check NT before W32
734 735 736 737 738 739 740 741 742 743 744 745 746
			if ((($NT && (!@p_purged
				      || (!$negatives && grep(/^WINNT$/,@p))
				      || ($negatives && !grep(/^!WINNT$/,@p))))
			     || ($W32 && (!@p_purged
					  || (!$negatives && grep(/^WIN32$/,@p))
					  || ($negatives && !grep(/^!WIN32$/,@p))))
			     || ($W16 && (!@p_purged
					  || (!$negatives && grep(/^WIN16$/,@p))
					  || ($negatives && !grep(/^!WIN16$/,@p)))))
			    && (!@p
				|| (!$negatives
				    && ($rsaref || !grep(/^RSAREF$/,@p)))
				|| ($negatives
747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764
				    && (!$rsaref || !grep(/^!RSAREF$/,@p))))
			    && (!@a || (!$no_rc2 || !grep(/^RC2$/,@a)))
			    && (!@a || (!$no_rc4 || !grep(/^RC4$/,@a)))
			    && (!@a || (!$no_rc5 || !grep(/^RC5$/,@a)))
			    && (!@a || (!$no_idea || !grep(/^IDEA$/,@a)))
			    && (!@a || (!$no_des || !grep(/^DES$/,@a)))
			    && (!@a || (!$no_bf || !grep(/^BF$/,@a)))
			    && (!@a || (!$no_cast || !grep(/^CAST$/,@a)))
			    && (!@a || (!$no_md2 || !grep(/^MD2$/,@a)))
			    && (!@a || (!$no_md4 || !grep(/^MD4$/,@a)))
			    && (!@a || (!$no_md5 || !grep(/^MD5$/,@a)))
			    && (!@a || (!$no_sha || !grep(/^SHA$/,@a)))
			    && (!@a || (!$no_ripemd || !grep(/^RIPEMD$/,@a)))
			    && (!@a || (!$no_mdc2 || !grep(/^MDC2$/,@a)))
			    && (!@a || (!$no_rsa || !grep(/^RSA$/,@a)))
			    && (!@a || (!$no_dsa || !grep(/^DSA$/,@a)))
			    && (!@a || (!$no_dh || !grep(/^DH$/,@a)))
			    && (!@a || (!$no_hmac || !grep(/^HMAC$/,@a)))
765
			    && (!@a || (!$no_rijndael || !grep(/^RIJNDAEL$/,@a)))
766 767
			    && (!@a || (!$no_fp_api || !grep(/^FP_API$/,@a)))
			    ) {
768
				printf OUT "    %s%-40s@%d\n",($W32)?"":"_",$s,$n;
769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785
#			} else {
#				print STDERR "DEBUG: \"$sym\" (@p):",
#				" rsaref:", !!(!@p
#					       || (!$negatives
#						   && ($rsaref || !grep(/^RSAREF$/,@p)))
#					       || ($negatives
#						   && (!$rsaref || !grep(/^!RSAREF$/,@p))))?1:0,
#				" 16:", !!($W16 && (!@p_purged
#						    || (!$negatives && grep(/^WIN16$/,@p))
#						    || ($negatives && !grep(/^!WIN16$/,@p)))),
#				" 32:", !!($W32 && (!@p_purged
#						    || (!$negatives && grep(/^WIN32$/,@p))
#						    || ($negatives && !grep(/^!WIN32$/,@p)))),
#				" NT:", !!($NT && (!@p_purged
#						   || (!$negatives && grep(/^WINNT$/,@p))
#						   || ($negatives && !grep(/^!WINNT$/,@p)))),
#				"\n";
786
			}
787 788
		}
	}
789 790
	printf OUT "\n";
}
791 792

sub load_numbers
793 794 795
{
	my($name)=@_;
	my(@a,%ret);
796

797
	$max_num = 0;
798 799
	$num_noinfo = 0;
	$prev = "";
800

801
	open(IN,"<$name") || die "unable to open $name:$!\n";
802
	while (<IN>) {
803 804 805 806
		chop;
		s/#.*$//;
		next if /^\s*$/;
		@a=split;
807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823
		if (defined $ret{$a[0]}) {
			print STDERR "Warning: Symbol '",$a[0],"' redefined. old=",$ret{$a[0]},", new=",$a[1],"\n";
		}
		if ($max_num > $a[1]) {
			print STDERR "Warning: Number decreased from ",$max_num," to ",$a[1],"\n";
		}
		if ($max_num == $a[1]) {
			# This is actually perfectly OK
			#print STDERR "Warning: Symbol ",$a[0]," has same number as previous ",$prev,": ",$a[1],"\n";
		}
		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
		}
824
		$max_num = $a[1] if $a[1] > $max_num;
825 826 827 828 829 830 831 832 833
		$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";
		}
834
	}
835 836
	close(IN);
	return(%ret);
837
}
838

839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866
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";

	my @r = grep(/^\w+\\.*?:.*?:\w+\(\w+\)/,@symbols);
	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;
	}

867 868 869 870 871 872
	my %syms = ();
	foreach $_ (@symbols) {
		(my $n, my $i) = split /\\/;
		$syms{$n} = 1;
	}

873 874 875 876 877
	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};
		next if defined($i) && $i =~ /^.*?:.*?:\w+\(\w+\)/;
		next if defined($rsyms{$sym});
878 879
		$i="NOEXIST::FUNCTION:"
			if !defined($i) || $i eq "" || !defined($syms{$sym});
880 881 882 883 884 885 886 887
		printf OUT "%s%-40s%d\t%s\n","",$sym,$n,$i;
		if (exists $r{$sym}) {
			(my $s, $i) = split /\\/,$r{$sym};
			printf OUT "%s%-40s%d\t%s\n","",$s,$n,$i;
		}
	}
}

888
sub update_numbers
889
{
890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914
	(*OUT,$name,*nums,my $start_num, my @symbols)=@_;
	my $new_syms = 0;

	print STDERR "Updating $name numbers\n";

	my @r = grep(/^\w+\\.*?:.*?:\w+\(\w+\)/,@symbols);
	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++;
			printf OUT "%s%-40s%d\t%s\n","",$s, ++$start_num,$i;
			if (exists $r{$s}) {
915
				($s, $i) = split /\\/,$r{$s};
916 917
				printf OUT "%s%-40s%d\t%s\n","",$s, $start_num,$i;
			}
918
		}
919
	}
920 921
	if($new_syms) {
		print STDERR "$new_syms New symbols added\n";
922
	} else {
923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945
		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";
		}
946
	}
947
}
948