wbrawner/openssl
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
openssl/util/mkstack.pl

193 lines
7.8 KiB
Perl
Raw Normal View History

This change will cause builds (by default) to not use different STACK structures and functions for each stack type. The previous behaviour can be enabled by configuring with the "-DDEBUG_SAFESTACK" option. This will also cause "make update" (mkdef.pl in particular) to update the libeay.num and ssleay.num symbol tables with the number of extra functions DEBUG_SAFESTACK creates. The way this change works is to accompany each DECLARE_STACK_OF() macro with a set of "#define"d versions of the sk_##type##_*** functions that ensures all the existing "type-safe" stack calls are precompiled into the underlying stack calls. The presence or abscence of the DEBUG_SAFESTACK symbol controls whether this block of "#define"s or the DECLARE_STACK_OF() macro is taking effect. The block of "#define"s is in turn generated and maintained by a perl script (util/mkstack.pl) that encompasses the block with delimiting C comments. This works in a similar way to the auto-generated error codes and, like the other such maintenance utilities, is invoked by the "make update" target. A long (but mundane) commit will follow this with the results of "make update" - this will include all the "#define" blocks for each DECLARE_STACK_OF() statement, along with stripped down libeay.num and ssleay.num files.
2000-06-01 05:13:52 +00:00
#!/usr/local/bin/perl -w
Using speaking "variable" names in macros so that e.g. grepping for sk_whatever_insert and sk_whatever_set immediately reveals the subtle difference in parameter order. Change mkstack.pl so that safestack.h is not rewritten when nothing has changed.
2000-06-17 23:41:44 +00:00
This change will cause builds (by default) to not use different STACK structures and functions for each stack type. The previous behaviour can be enabled by configuring with the "-DDEBUG_SAFESTACK" option. This will also cause "make update" (mkdef.pl in particular) to update the libeay.num and ssleay.num symbol tables with the number of extra functions DEBUG_SAFESTACK creates. The way this change works is to accompany each DECLARE_STACK_OF() macro with a set of "#define"d versions of the sk_##type##_*** functions that ensures all the existing "type-safe" stack calls are precompiled into the underlying stack calls. The presence or abscence of the DEBUG_SAFESTACK symbol controls whether this block of "#define"s or the DECLARE_STACK_OF() macro is taking effect. The block of "#define"s is in turn generated and maintained by a perl script (util/mkstack.pl) that encompasses the block with delimiting C comments. This works in a similar way to the auto-generated error codes and, like the other such maintenance utilities, is invoked by the "make update" target. A long (but mundane) commit will follow this with the results of "make update" - this will include all the "#define" blocks for each DECLARE_STACK_OF() statement, along with stripped down libeay.num and ssleay.num files.
2000-06-01 05:13:52 +00:00
# This is a utility that searches out "DECLARE_STACK_OF()"
Using speaking "variable" names in macros so that e.g. grepping for sk_whatever_insert and sk_whatever_set immediately reveals the subtle difference in parameter order. Change mkstack.pl so that safestack.h is not rewritten when nothing has changed.
2000-06-17 23:41:44 +00:00
# declarations in .h and .c files, and updates/creates/replaces
# the corresponding macro declarations in crypto/stack/safestack.h.
# As it's not generally possible to have macros that generate macros,
# we need to control this from the "outside", here in this script.
This change will cause builds (by default) to not use different STACK structures and functions for each stack type. The previous behaviour can be enabled by configuring with the "-DDEBUG_SAFESTACK" option. This will also cause "make update" (mkdef.pl in particular) to update the libeay.num and ssleay.num symbol tables with the number of extra functions DEBUG_SAFESTACK creates. The way this change works is to accompany each DECLARE_STACK_OF() macro with a set of "#define"d versions of the sk_##type##_*** functions that ensures all the existing "type-safe" stack calls are precompiled into the underlying stack calls. The presence or abscence of the DEBUG_SAFESTACK symbol controls whether this block of "#define"s or the DECLARE_STACK_OF() macro is taking effect. The block of "#define"s is in turn generated and maintained by a perl script (util/mkstack.pl) that encompasses the block with delimiting C comments. This works in a similar way to the auto-generated error codes and, like the other such maintenance utilities, is invoked by the "make update" target. A long (but mundane) commit will follow this with the results of "make update" - this will include all the "#define" blocks for each DECLARE_STACK_OF() statement, along with stripped down libeay.num and ssleay.num files.
2000-06-01 05:13:52 +00:00
#
# Geoff Thorpe, June, 2000 (with massive Perl-hacking
# help from Steve Robb)
Using speaking "variable" names in macros so that e.g. grepping for sk_whatever_insert and sk_whatever_set immediately reveals the subtle difference in parameter order. Change mkstack.pl so that safestack.h is not rewritten when nothing has changed.
2000-06-17 23:41:44 +00:00
my $safestack = "crypto/stack/safestack";
This change will cause builds (by default) to not use different STACK structures and functions for each stack type. The previous behaviour can be enabled by configuring with the "-DDEBUG_SAFESTACK" option. This will also cause "make update" (mkdef.pl in particular) to update the libeay.num and ssleay.num symbol tables with the number of extra functions DEBUG_SAFESTACK creates. The way this change works is to accompany each DECLARE_STACK_OF() macro with a set of "#define"d versions of the sk_##type##_*** functions that ensures all the existing "type-safe" stack calls are precompiled into the underlying stack calls. The presence or abscence of the DEBUG_SAFESTACK symbol controls whether this block of "#define"s or the DECLARE_STACK_OF() macro is taking effect. The block of "#define"s is in turn generated and maintained by a perl script (util/mkstack.pl) that encompasses the block with delimiting C comments. This works in a similar way to the auto-generated error codes and, like the other such maintenance utilities, is invoked by the "make update" target. A long (but mundane) commit will follow this with the results of "make update" - this will include all the "#define" blocks for each DECLARE_STACK_OF() statement, along with stripped down libeay.num and ssleay.num files.
2000-06-01 05:13:52 +00:00
Using speaking "variable" names in macros so that e.g. grepping for sk_whatever_insert and sk_whatever_set immediately reveals the subtle difference in parameter order. Change mkstack.pl so that safestack.h is not rewritten when nothing has changed.
2000-06-17 23:41:44 +00:00
my $do_write;
This change will cause builds (by default) to not use different STACK structures and functions for each stack type. The previous behaviour can be enabled by configuring with the "-DDEBUG_SAFESTACK" option. This will also cause "make update" (mkdef.pl in particular) to update the libeay.num and ssleay.num symbol tables with the number of extra functions DEBUG_SAFESTACK creates. The way this change works is to accompany each DECLARE_STACK_OF() macro with a set of "#define"d versions of the sk_##type##_*** functions that ensures all the existing "type-safe" stack calls are precompiled into the underlying stack calls. The presence or abscence of the DEBUG_SAFESTACK symbol controls whether this block of "#define"s or the DECLARE_STACK_OF() macro is taking effect. The block of "#define"s is in turn generated and maintained by a perl script (util/mkstack.pl) that encompasses the block with delimiting C comments. This works in a similar way to the auto-generated error codes and, like the other such maintenance utilities, is invoked by the "make update" target. A long (but mundane) commit will follow this with the results of "make update" - this will include all the "#define" blocks for each DECLARE_STACK_OF() statement, along with stripped down libeay.num and ssleay.num files.
2000-06-01 05:13:52 +00:00
while (@ARGV) {
my $arg = $ARGV[0];
Using speaking "variable" names in macros so that e.g. grepping for sk_whatever_insert and sk_whatever_set immediately reveals the subtle difference in parameter order. Change mkstack.pl so that safestack.h is not rewritten when nothing has changed.
2000-06-17 23:41:44 +00:00
if($arg eq "-write") {
$do_write = 1;
This change will cause builds (by default) to not use different STACK structures and functions for each stack type. The previous behaviour can be enabled by configuring with the "-DDEBUG_SAFESTACK" option. This will also cause "make update" (mkdef.pl in particular) to update the libeay.num and ssleay.num symbol tables with the number of extra functions DEBUG_SAFESTACK creates. The way this change works is to accompany each DECLARE_STACK_OF() macro with a set of "#define"d versions of the sk_##type##_*** functions that ensures all the existing "type-safe" stack calls are precompiled into the underlying stack calls. The presence or abscence of the DEBUG_SAFESTACK symbol controls whether this block of "#define"s or the DECLARE_STACK_OF() macro is taking effect. The block of "#define"s is in turn generated and maintained by a perl script (util/mkstack.pl) that encompasses the block with delimiting C comments. This works in a similar way to the auto-generated error codes and, like the other such maintenance utilities, is invoked by the "make update" target. A long (but mundane) commit will follow this with the results of "make update" - this will include all the "#define" blocks for each DECLARE_STACK_OF() statement, along with stripped down libeay.num and ssleay.num files.
2000-06-01 05:13:52 +00:00
}
Using speaking "variable" names in macros so that e.g. grepping for sk_whatever_insert and sk_whatever_set immediately reveals the subtle difference in parameter order. Change mkstack.pl so that safestack.h is not rewritten when nothing has changed.
2000-06-17 23:41:44 +00:00
shift @ARGV;
This change will cause builds (by default) to not use different STACK structures and functions for each stack type. The previous behaviour can be enabled by configuring with the "-DDEBUG_SAFESTACK" option. This will also cause "make update" (mkdef.pl in particular) to update the libeay.num and ssleay.num symbol tables with the number of extra functions DEBUG_SAFESTACK creates. The way this change works is to accompany each DECLARE_STACK_OF() macro with a set of "#define"d versions of the sk_##type##_*** functions that ensures all the existing "type-safe" stack calls are precompiled into the underlying stack calls. The presence or abscence of the DEBUG_SAFESTACK symbol controls whether this block of "#define"s or the DECLARE_STACK_OF() macro is taking effect. The block of "#define"s is in turn generated and maintained by a perl script (util/mkstack.pl) that encompasses the block with delimiting C comments. This works in a similar way to the auto-generated error codes and, like the other such maintenance utilities, is invoked by the "make update" target. A long (but mundane) commit will follow this with the results of "make update" - this will include all the "#define" blocks for each DECLARE_STACK_OF() statement, along with stripped down libeay.num and ssleay.num files.
2000-06-01 05:13:52 +00:00
}
LHASH revamp. make depend.
2008-05-26 11:24:29 +00:00
@source = (<crypto/*.[ch]>, <crypto/*/*.[ch]>, <ssl/*.[ch]>, <apps/*.[ch]>);
This change will cause builds (by default) to not use different STACK structures and functions for each stack type. The previous behaviour can be enabled by configuring with the "-DDEBUG_SAFESTACK" option. This will also cause "make update" (mkdef.pl in particular) to update the libeay.num and ssleay.num symbol tables with the number of extra functions DEBUG_SAFESTACK creates. The way this change works is to accompany each DECLARE_STACK_OF() macro with a set of "#define"d versions of the sk_##type##_*** functions that ensures all the existing "type-safe" stack calls are precompiled into the underlying stack calls. The presence or abscence of the DEBUG_SAFESTACK symbol controls whether this block of "#define"s or the DECLARE_STACK_OF() macro is taking effect. The block of "#define"s is in turn generated and maintained by a perl script (util/mkstack.pl) that encompasses the block with delimiting C comments. This works in a similar way to the auto-generated error codes and, like the other such maintenance utilities, is invoked by the "make update" target. A long (but mundane) commit will follow this with the results of "make update" - this will include all the "#define" blocks for each DECLARE_STACK_OF() statement, along with stripped down libeay.num and ssleay.num files.
2000-06-01 05:13:52 +00:00
foreach $file (@source) {
next if -l $file;
# Open the .c/.h file for reading
open(IN, "< $file") || die "Can't open $file for reading: $!";
Safe stack reorganisation in terms of function casts. After some messing around this seems to work but needs a few more tests. Working out the syntax for sk_set_cmp_func() (cast it to a function that itself returns a function pointer) was painful :-( Needs some testing to see what other compilers think of this syntax. Also needs similar stuff for ASN1_SET_OF etc etc.
2000-06-16 23:29:26 +00:00
while(<IN>) {
if (/^DECLARE_STACK_OF\(([^)]+)\)/) {
push @stacklst, $1;
LHASH revamp. make depend.
2008-05-26 11:24:29 +00:00
}
More type-checking.
2008-06-04 11:01:43 +00:00
if (/^DECLARE_SPECIAL_STACK_OF\(([^,\s]+)\s*,\s*([^>\s]+)\)/) {
push @sstacklst, [$1, $2];
}
LHASH revamp. make depend.
2008-05-26 11:24:29 +00:00
if (/^DECLARE_ASN1_SET_OF\(([^)]+)\)/) {
Handle ASN1_SET_OF and PKCS12_STACK_OF using function casts in the same way as STACK_OF.
2000-06-20 18:45:28 +00:00
push @asn1setlst, $1;
LHASH revamp. make depend.
2008-05-26 11:24:29 +00:00
}
if (/^DECLARE_PKCS12_STACK_OF\(([^)]+)\)/) {
Handle ASN1_SET_OF and PKCS12_STACK_OF using function casts in the same way as STACK_OF.
2000-06-20 18:45:28 +00:00
push @p12stklst, $1;
Safe stack reorganisation in terms of function casts. After some messing around this seems to work but needs a few more tests. Working out the syntax for sk_set_cmp_func() (cast it to a function that itself returns a function pointer) was painful :-( Needs some testing to see what other compilers think of this syntax. Also needs similar stuff for ASN1_SET_OF etc etc.
2000-06-16 23:29:26 +00:00
}
LHASH revamp. make depend.
2008-05-26 11:24:29 +00:00
if (/^DECLARE_LHASH_OF\(([^)]+)\)/) {
push @lhashlst, $1;
}
Safe stack reorganisation in terms of function casts. After some messing around this seems to work but needs a few more tests. Working out the syntax for sk_set_cmp_func() (cast it to a function that itself returns a function pointer) was painful :-( Needs some testing to see what other compilers think of this syntax. Also needs similar stuff for ASN1_SET_OF etc etc.
2000-06-16 23:29:26 +00:00
}
This change will cause builds (by default) to not use different STACK structures and functions for each stack type. The previous behaviour can be enabled by configuring with the "-DDEBUG_SAFESTACK" option. This will also cause "make update" (mkdef.pl in particular) to update the libeay.num and ssleay.num symbol tables with the number of extra functions DEBUG_SAFESTACK creates. The way this change works is to accompany each DECLARE_STACK_OF() macro with a set of "#define"d versions of the sk_##type##_*** functions that ensures all the existing "type-safe" stack calls are precompiled into the underlying stack calls. The presence or abscence of the DEBUG_SAFESTACK symbol controls whether this block of "#define"s or the DECLARE_STACK_OF() macro is taking effect. The block of "#define"s is in turn generated and maintained by a perl script (util/mkstack.pl) that encompasses the block with delimiting C comments. This works in a similar way to the auto-generated error codes and, like the other such maintenance utilities, is invoked by the "make update" target. A long (but mundane) commit will follow this with the results of "make update" - this will include all the "#define" blocks for each DECLARE_STACK_OF() statement, along with stripped down libeay.num and ssleay.num files.
2000-06-01 05:13:52 +00:00
close(IN);
}
Handle ASN1_SET_OF and PKCS12_STACK_OF using function casts in the same way as STACK_OF.
2000-06-20 18:45:28 +00:00
Using speaking "variable" names in macros so that e.g. grepping for sk_whatever_insert and sk_whatever_set immediately reveals the subtle difference in parameter order. Change mkstack.pl so that safestack.h is not rewritten when nothing has changed.
2000-06-17 23:41:44 +00:00
my $old_stackfile = "";
my $new_stackfile = "";
my $inside_block = 0;
my $type_thing;
open(IN, "< $safestack.h") || die "Can't open input file: $!";
while(<IN>) {
$old_stackfile .= $_;
if (m|^/\* This block of defines is updated by util/mkstack.pl, please do not touch! \*/|) {
$inside_block = 1;
}
if (m|^/\* End of util/mkstack.pl block, you may now edit :-\) \*/|) {
$inside_block = 0;
} elsif ($inside_block == 0) {
$new_stackfile .= $_;
}
next if($inside_block != 1);
$new_stackfile .= "/* This block of defines is updated by util/mkstack.pl, please do not touch! */";
Change mkstack.pl so it now sorts each group into lexical order. Previously it depended on the order of files in the directory. This should now mean that all systems will agree on the order of safestack.h and will not change it needlessly and avoid massive needless commits to safestack.h in future. It wont however avoid this one :-(
2000-06-22 00:34:27 +00:00
foreach $type_thing (sort @stacklst) {
Using speaking "variable" names in macros so that e.g. grepping for sk_whatever_insert and sk_whatever_set immediately reveals the subtle difference in parameter order. Change mkstack.pl so that safestack.h is not rewritten when nothing has changed.
2000-06-17 23:41:44 +00:00
$new_stackfile .= <<EOF;
Safe stack reorganisation in terms of function casts. After some messing around this seems to work but needs a few more tests. Working out the syntax for sk_set_cmp_func() (cast it to a function that itself returns a function pointer) was painful :-( Needs some testing to see what other compilers think of this syntax. Also needs similar stuff for ASN1_SET_OF etc etc.
2000-06-16 23:29:26 +00:00
More type-checking.
2008-06-04 11:01:43 +00:00
#define sk_${type_thing}_new(cmp) SKM_sk_new($type_thing, (cmp))
Using speaking "variable" names in macros so that e.g. grepping for sk_whatever_insert and sk_whatever_set immediately reveals the subtle difference in parameter order. Change mkstack.pl so that safestack.h is not rewritten when nothing has changed.
2000-06-17 23:41:44 +00:00
#define sk_${type_thing}_new_null() SKM_sk_new_null($type_thing)
#define sk_${type_thing}_free(st) SKM_sk_free($type_thing, (st))
#define sk_${type_thing}_num(st) SKM_sk_num($type_thing, (st))
#define sk_${type_thing}_value(st, i) SKM_sk_value($type_thing, (st), (i))
#define sk_${type_thing}_set(st, i, val) SKM_sk_set($type_thing, (st), (i), (val))
#define sk_${type_thing}_zero(st) SKM_sk_zero($type_thing, (st))
#define sk_${type_thing}_push(st, val) SKM_sk_push($type_thing, (st), (val))
#define sk_${type_thing}_unshift(st, val) SKM_sk_unshift($type_thing, (st), (val))
#define sk_${type_thing}_find(st, val) SKM_sk_find($type_thing, (st), (val))
Add an extended variant of sk_find() which returns a non-NULL pointer even if an exact match wasn't found.
2003-04-29 20:30:55 +00:00
#define sk_${type_thing}_find_ex(st, val) SKM_sk_find_ex($type_thing, (st), (val))
Using speaking "variable" names in macros so that e.g. grepping for sk_whatever_insert and sk_whatever_set immediately reveals the subtle difference in parameter order. Change mkstack.pl so that safestack.h is not rewritten when nothing has changed.
2000-06-17 23:41:44 +00:00
#define sk_${type_thing}_delete(st, i) SKM_sk_delete($type_thing, (st), (i))
#define sk_${type_thing}_delete_ptr(st, ptr) SKM_sk_delete_ptr($type_thing, (st), (ptr))
#define sk_${type_thing}_insert(st, val, i) SKM_sk_insert($type_thing, (st), (val), (i))
#define sk_${type_thing}_set_cmp_func(st, cmp) SKM_sk_set_cmp_func($type_thing, (st), (cmp))
#define sk_${type_thing}_dup(st) SKM_sk_dup($type_thing, st)
#define sk_${type_thing}_pop_free(st, free_func) SKM_sk_pop_free($type_thing, (st), (free_func))
#define sk_${type_thing}_shift(st) SKM_sk_shift($type_thing, (st))
#define sk_${type_thing}_pop(st) SKM_sk_pop($type_thing, (st))
#define sk_${type_thing}_sort(st) SKM_sk_sort($type_thing, (st))
Fix race condition when CRL checking is enabled.
2004-10-04 16:30:12 +00:00
#define sk_${type_thing}_is_sorted(st) SKM_sk_is_sorted($type_thing, (st))
Handle ASN1_SET_OF and PKCS12_STACK_OF using function casts in the same way as STACK_OF.
2000-06-20 18:45:28 +00:00
EOF
}
More type-checking.
2008-06-04 11:01:43 +00:00
Sort @sstacklst correctly. Reviewed-by: Rich Salz <rsalz@openssl.org> (cherry picked from commit 2a7059c56f885a3fa0842e886f5178def8e5481d)
2015-07-09 15:56:45 +00:00
foreach $type_thing (sort { $a->[0] cmp $b->[0]} @sstacklst) {
More type-checking.
2008-06-04 11:01:43 +00:00
my $t1 = $type_thing->[0];
my $t2 = $type_thing->[1];
$new_stackfile .= <<EOF;
#define sk_${t1}_new(cmp) ((STACK_OF($t1) *)sk_new(CHECKED_SK_CMP_FUNC($t2, cmp)))
#define sk_${t1}_new_null() ((STACK_OF($t1) *)sk_new_null())
Assorted bugfixes: - safestack macro changes for C++ were incomplete - RLE decompression boundary case - SSL 2.0 key arg length check Submitted by: Google (Adam Langley, Neel Mehta, Bodo Moeller)
2011-02-03 12:03:57 +00:00
#define sk_${t1}_push(st, val) sk_push(CHECKED_STACK_OF($t1, st), CHECKED_PTR_OF($t2, val))
#define sk_${t1}_find(st, val) sk_find(CHECKED_STACK_OF($t1, st), CHECKED_PTR_OF($t2, val))
#define sk_${t1}_value(st, i) (($t1)sk_value(CHECKED_STACK_OF($t1, st), i))
More type-checking.
2008-06-04 11:01:43 +00:00
#define sk_${t1}_num(st) SKM_sk_num($t1, st)
Assorted bugfixes: - safestack macro changes for C++ were incomplete - RLE decompression boundary case - SSL 2.0 key arg length check Submitted by: Google (Adam Langley, Neel Mehta, Bodo Moeller)
2011-02-03 12:03:57 +00:00
#define sk_${t1}_pop_free(st, free_func) sk_pop_free(CHECKED_STACK_OF($t1, st), CHECKED_SK_FREE_FUNC2($t1, free_func))
#define sk_${t1}_insert(st, val, i) sk_insert(CHECKED_STACK_OF($t1, st), CHECKED_PTR_OF($t2, val), i)
More type-checking.
2008-06-04 11:01:43 +00:00
#define sk_${t1}_free(st) SKM_sk_free(${t1}, st)
Assorted bugfixes: - safestack macro changes for C++ were incomplete - RLE decompression boundary case - SSL 2.0 key arg length check Submitted by: Google (Adam Langley, Neel Mehta, Bodo Moeller)
2011-02-03 12:03:57 +00:00
#define sk_${t1}_set(st, i, val) sk_set(CHECKED_STACK_OF($t1, st), i, CHECKED_PTR_OF($t2, val))
PR: 1896 Submitted by: Ger Hobbelt <ger@hobbelt.com> Approved by: steve@openssl.org Remove double sk_*_free() definition and add missing definition to mkstack.pl
2009-04-13 11:26:31 +00:00
#define sk_${t1}_zero(st) SKM_sk_zero($t1, (st))
Assorted bugfixes: - safestack macro changes for C++ were incomplete - RLE decompression boundary case - SSL 2.0 key arg length check Submitted by: Google (Adam Langley, Neel Mehta, Bodo Moeller)
2011-02-03 12:03:57 +00:00
#define sk_${t1}_unshift(st, val) sk_unshift(CHECKED_STACK_OF($t1, st), CHECKED_PTR_OF($t2, val))
PR: 1896 Submitted by: Ger Hobbelt <ger@hobbelt.com> Approved by: steve@openssl.org Remove double sk_*_free() definition and add missing definition to mkstack.pl
2009-04-13 11:26:31 +00:00
#define sk_${t1}_find_ex(st, val) sk_find_ex((_STACK *)CHECKED_CONST_PTR_OF(STACK_OF($t1), st), CHECKED_CONST_PTR_OF($t2, val))
#define sk_${t1}_delete(st, i) SKM_sk_delete($t1, (st), (i))
Assorted bugfixes: - safestack macro changes for C++ were incomplete - RLE decompression boundary case - SSL 2.0 key arg length check Submitted by: Google (Adam Langley, Neel Mehta, Bodo Moeller)
2011-02-03 12:03:57 +00:00
#define sk_${t1}_delete_ptr(st, ptr) ($t1 *)sk_delete_ptr(CHECKED_STACK_OF($t1, st), CHECKED_PTR_OF($t2, ptr))
PR: 1896 Submitted by: Ger Hobbelt <ger@hobbelt.com> Approved by: steve@openssl.org Remove double sk_*_free() definition and add missing definition to mkstack.pl
2009-04-13 11:26:31 +00:00
#define sk_${t1}_set_cmp_func(st, cmp) \\
((int (*)(const $t2 * const *,const $t2 * const *)) \\
Assorted bugfixes: - safestack macro changes for C++ were incomplete - RLE decompression boundary case - SSL 2.0 key arg length check Submitted by: Google (Adam Langley, Neel Mehta, Bodo Moeller)
2011-02-03 12:03:57 +00:00
sk_set_cmp_func(CHECKED_STACK_OF($t1, st), CHECKED_SK_CMP_FUNC($t2, cmp)))
PR: 1896 Submitted by: Ger Hobbelt <ger@hobbelt.com> Approved by: steve@openssl.org Remove double sk_*_free() definition and add missing definition to mkstack.pl
2009-04-13 11:26:31 +00:00
#define sk_${t1}_dup(st) SKM_sk_dup($t1, st)
#define sk_${t1}_shift(st) SKM_sk_shift($t1, (st))
Assorted bugfixes: - safestack macro changes for C++ were incomplete - RLE decompression boundary case - SSL 2.0 key arg length check Submitted by: Google (Adam Langley, Neel Mehta, Bodo Moeller)
2011-02-03 12:03:57 +00:00
#define sk_${t1}_pop(st) ($t2 *)sk_pop(CHECKED_STACK_OF($t1, st))
PR: 1896 Submitted by: Ger Hobbelt <ger@hobbelt.com> Approved by: steve@openssl.org Remove double sk_*_free() definition and add missing definition to mkstack.pl
2009-04-13 11:26:31 +00:00
#define sk_${t1}_sort(st) SKM_sk_sort($t1, (st))
#define sk_${t1}_is_sorted(st) SKM_sk_is_sorted($t1, (st))
More type-checking.
2008-06-04 11:01:43 +00:00
EOF
}
Change mkstack.pl so it now sorts each group into lexical order. Previously it depended on the order of files in the directory. This should now mean that all systems will agree on the order of safestack.h and will not change it needlessly and avoid massive needless commits to safestack.h in future. It wont however avoid this one :-(
2000-06-22 00:34:27 +00:00
foreach $type_thing (sort @asn1setlst) {
Handle ASN1_SET_OF and PKCS12_STACK_OF using function casts in the same way as STACK_OF.
2000-06-20 18:45:28 +00:00
$new_stackfile .= <<EOF;
#define d2i_ASN1_SET_OF_${type_thing}(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \\
SKM_ASN1_SET_OF_d2i($type_thing, (st), (pp), (length), (d2i_func), (free_func), (ex_tag), (ex_class))
#define i2d_ASN1_SET_OF_${type_thing}(st, pp, i2d_func, ex_tag, ex_class, is_set) \\
SKM_ASN1_SET_OF_i2d($type_thing, (st), (pp), (i2d_func), (ex_tag), (ex_class), (is_set))
#define ASN1_seq_pack_${type_thing}(st, i2d_func, buf, len) \\
SKM_ASN1_seq_pack($type_thing, (st), (i2d_func), (buf), (len))
#define ASN1_seq_unpack_${type_thing}(buf, len, d2i_func, free_func) \\
SKM_ASN1_seq_unpack($type_thing, (buf), (len), (d2i_func), (free_func))
EOF
}
Change mkstack.pl so it now sorts each group into lexical order. Previously it depended on the order of files in the directory. This should now mean that all systems will agree on the order of safestack.h and will not change it needlessly and avoid massive needless commits to safestack.h in future. It wont however avoid this one :-(
2000-06-22 00:34:27 +00:00
foreach $type_thing (sort @p12stklst) {
Handle ASN1_SET_OF and PKCS12_STACK_OF using function casts in the same way as STACK_OF.
2000-06-20 18:45:28 +00:00
$new_stackfile .= <<EOF;
#define PKCS12_decrypt_d2i_${type_thing}(algor, d2i_func, free_func, pass, passlen, oct, seq) \\
SKM_PKCS12_decrypt_d2i($type_thing, (algor), (d2i_func), (free_func), (pass), (passlen), (oct), (seq))
Safe stack reorganisation in terms of function casts. After some messing around this seems to work but needs a few more tests. Working out the syntax for sk_set_cmp_func() (cast it to a function that itself returns a function pointer) was painful :-( Needs some testing to see what other compilers think of this syntax. Also needs similar stuff for ASN1_SET_OF etc etc.
2000-06-16 23:29:26 +00:00
EOF
}
LHASH revamp. make depend.
2008-05-26 11:24:29 +00:00
foreach $type_thing (sort @lhashlst) {
my $lc_tt = lc $type_thing;
$new_stackfile .= <<EOF;
#define lh_${type_thing}_new() LHM_lh_new(${type_thing},${lc_tt})
#define lh_${type_thing}_insert(lh,inst) LHM_lh_insert(${type_thing},lh,inst)
#define lh_${type_thing}_retrieve(lh,inst) LHM_lh_retrieve(${type_thing},lh,inst)
#define lh_${type_thing}_delete(lh,inst) LHM_lh_delete(${type_thing},lh,inst)
#define lh_${type_thing}_doall(lh,fn) LHM_lh_doall(${type_thing},lh,fn)
#define lh_${type_thing}_doall_arg(lh,fn,arg_type,arg) \\
LHM_lh_doall_arg(${type_thing},lh,fn,arg_type,arg)
#define lh_${type_thing}_error(lh) LHM_lh_error(${type_thing},lh)
#define lh_${type_thing}_num_items(lh) LHM_lh_num_items(${type_thing},lh)
#define lh_${type_thing}_down_load(lh) LHM_lh_down_load(${type_thing},lh)
#define lh_${type_thing}_node_stats_bio(lh,out) \\
LHM_lh_node_stats_bio(${type_thing},lh,out)
#define lh_${type_thing}_node_usage_stats_bio(lh,out) \\
LHM_lh_node_usage_stats_bio(${type_thing},lh,out)
#define lh_${type_thing}_stats_bio(lh,out) \\
LHM_lh_stats_bio(${type_thing},lh,out)
#define lh_${type_thing}_free(lh) LHM_lh_free(${type_thing},lh)
EOF
}
Using speaking "variable" names in macros so that e.g. grepping for sk_whatever_insert and sk_whatever_set immediately reveals the subtle difference in parameter order. Change mkstack.pl so that safestack.h is not rewritten when nothing has changed.
2000-06-17 23:41:44 +00:00
$new_stackfile .= "/* End of util/mkstack.pl block, you may now edit :-) */\n";
Safe stack reorganisation in terms of function casts. After some messing around this seems to work but needs a few more tests. Working out the syntax for sk_set_cmp_func() (cast it to a function that itself returns a function pointer) was painful :-( Needs some testing to see what other compilers think of this syntax. Also needs similar stuff for ASN1_SET_OF etc etc.
2000-06-16 23:29:26 +00:00
$inside_block = 2;
Using speaking "variable" names in macros so that e.g. grepping for sk_whatever_insert and sk_whatever_set immediately reveals the subtle difference in parameter order. Change mkstack.pl so that safestack.h is not rewritten when nothing has changed.
2000-06-17 23:41:44 +00:00
}
if ($new_stackfile eq $old_stackfile) {
print "No changes to $safestack.h.\n";
exit 0; # avoid unnecessary rebuild
}
if ($do_write) {
print "Writing new $safestack.h.\n";
open OUT, ">$safestack.h" || die "Can't open output file";
print OUT $new_stackfile;
Safe stack reorganisation in terms of function casts. After some messing around this seems to work but needs a few more tests. Working out the syntax for sk_set_cmp_func() (cast it to a function that itself returns a function pointer) was painful :-( Needs some testing to see what other compilers think of this syntax. Also needs similar stuff for ASN1_SET_OF etc etc.
2000-06-16 23:29:26 +00:00
close OUT;
This change will cause builds (by default) to not use different STACK structures and functions for each stack type. The previous behaviour can be enabled by configuring with the "-DDEBUG_SAFESTACK" option. This will also cause "make update" (mkdef.pl in particular) to update the libeay.num and ssleay.num symbol tables with the number of extra functions DEBUG_SAFESTACK creates. The way this change works is to accompany each DECLARE_STACK_OF() macro with a set of "#define"d versions of the sk_##type##_*** functions that ensures all the existing "type-safe" stack calls are precompiled into the underlying stack calls. The presence or abscence of the DEBUG_SAFESTACK symbol controls whether this block of "#define"s or the DECLARE_STACK_OF() macro is taking effect. The block of "#define"s is in turn generated and maintained by a perl script (util/mkstack.pl) that encompasses the block with delimiting C comments. This works in a similar way to the auto-generated error codes and, like the other such maintenance utilities, is invoked by the "make update" target. A long (but mundane) commit will follow this with the results of "make update" - this will include all the "#define" blocks for each DECLARE_STACK_OF() statement, along with stripped down libeay.num and ssleay.num files.
2000-06-01 05:13:52 +00:00
}
Reference in a new issue Copy permalink