0729692cc8
Finally. We're almost at parity for the template compiler.
Now we have a build option to use templating:
`./configure --enable-asn1-templating`
Tests fail if you build `rfc2459.asn1` with `--template`.
TBD: Figure out what differences remain between the two compilers, and
fix the templating compiler accordingly, adding tests along the
way.
Making IMPLICIT tags work in the templating compiler turned out to be a
simple fix: don't attempt to do anything clever about IMPLICIT tags in
the template generator in the compiler other than denoting them --
instead leave all the smarts about IMPLICIT tags to the interpreter.
This might be a very slight pessimization, but also a great
simplification.
The result is very elegant: when the interpreter finds an IMPLICIT
tag it then recurses to find the template for the body of the type
so-tagged, and evaluates that. Much more elegant than the code
generated by the non-template compiler, not least for not needing
any additional temporary memory allocation.
With this we finally have parity in basic testing of the template
compiler. Indeed, for IMPLICIT tags the template compiler and
interpreter might even be better because they support IMPLICIT tags
with BER lengths, whereas the non-template compiler doesn't (mostly
because `der_replace_tag()` needs to be changed to support it.
And, of course, the template compiler is simply superior in that it
produces smaller code and is *much* easier to work with because the
functions to interpret templates are small and simple. Which means we
can add more functions to deal with other encoding rules fairly
trivially. It should be possible to add all of these with very little
work, almost all of it localized to `lib/asn1/template.c`:
- PER Packed Encoding Rules [X.691]
- XER XML Encoding Rules [X.693]
- OER Octet Encoding Rules [X.696] (intended to replace PER)
- JER JSON Encoding Rules [X.697] (doubles as visual representation)
- GSER Generic String E.R.s [RFC3641] (a visual representation)
- XDR External Data Repr. [STD67][RFC4506]
(XDR is *not* an ASN.1 encoding rules specification, but it's a
*lot* like PER/OER but with 4-octet alignment, and is specified
for the syntax equivalent (XDR) of only a subset of ASN.1 syntax
and semantics.)
All we'd have to do is add variants of `_asn1_{length,encode,decode}()`
for each set of rules, then generate per-type stub functions that call
them (as we already do for DER).
We could then have an encoding rule transliteration program that takes a
`TypeName` and some representation of a value encoded by some encoding
rules, and outputs the same thing encoded by a different set of rules.
This would double as a pretty-printer and parser if we do add support
for JER and/or GSER. It would find the template for the given type
using `dlsym()` against some shared object (possibly `libasn1` itself).
Whereas generating source code for C (or whatever language) for
additional ERs requires much more work. Plus, templates are much
smaller, and the interpreter is tiny, which yields much smaller text and
much smaller CPU icache/dcache footprint, which yields better
performance in many cases.
As well, the template system should be much easier to port to other
languages. Though in the cases of, e.g., Rust, it would require use of
`unsafe` in the interpreter, so in fact the inverse might be true: that
it's easier to generate safe Rust code than to implement a template
interpreter in Rust. Similarly for Haskell, OCAML, etc. But wherever
the template interpreter is easy to implement, it's a huge win.
Note that implementing OER and PER using the templates as they are
currently would be a bit of a challenge, as the interpreter would have
to first do a pass of each SEQUENCE/SET to determine the size and
layout of the OER/PER sequence/set preamble by counting the number of
OPTIONAL/DEFAULT members, BOOLEAN members, and extensibility markers
with extensions present. We could always generate more entries to
encode precomputed preamble metadata. We would also need to add a
template entry type for extensibility markers, which currently we do
not.
128 lines
4.1 KiB
C
128 lines
4.1 KiB
C
/*
|
|
* Copyright (c) 1997 - 2006 Kungliga Tekniska Högskolan
|
|
* (Royal Institute of Technology, Stockholm, Sweden).
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* 3. Neither the name of the Institute nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "gen_locl.h"
|
|
|
|
RCSID("$Id$");
|
|
|
|
static FILE *
|
|
get_code_file(void)
|
|
{
|
|
if (!one_code_file && template_flag && templatefile)
|
|
return templatefile;
|
|
return codefile;
|
|
}
|
|
|
|
void
|
|
generate_type_seq (const Symbol *s)
|
|
{
|
|
char *subname;
|
|
Type *type;
|
|
|
|
if (!seq_type(s->name))
|
|
return;
|
|
type = s->type;
|
|
while(type->type == TTag)
|
|
type = type->subtype;
|
|
|
|
if (type->type != TSequenceOf && type->type != TSetOf) {
|
|
fprintf(stderr, "%s not seq of %d\n", s->name, (int)type->type);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Require the subtype to be a type so we can name it and use
|
|
* copy_/free_
|
|
*/
|
|
|
|
if (type->subtype->type != TType) {
|
|
fprintf(stderr, "%s subtype is not a type, can't generate "
|
|
"sequence code for this case: %d\n",
|
|
s->name, (int)type->subtype->type);
|
|
exit(1);
|
|
}
|
|
|
|
subname = type->subtype->symbol->gen_name;
|
|
|
|
fprintf (headerfile,
|
|
"ASN1EXP int ASN1CALL add_%s (%s *, const %s *);\n"
|
|
"ASN1EXP int ASN1CALL remove_%s (%s *, unsigned int);\n",
|
|
s->gen_name, s->gen_name, subname,
|
|
s->gen_name, s->gen_name);
|
|
|
|
fprintf (get_code_file(), "int ASN1CALL\n"
|
|
"add_%s(%s *data, const %s *element)\n"
|
|
"{\n",
|
|
s->gen_name, s->gen_name, subname);
|
|
|
|
fprintf (get_code_file(),
|
|
"int ret;\n"
|
|
"void *ptr;\n"
|
|
"\n"
|
|
"ptr = realloc(data->val, \n"
|
|
"\t(data->len + 1) * sizeof(data->val[0]));\n"
|
|
"if (ptr == NULL) return ENOMEM;\n"
|
|
"data->val = ptr;\n\n"
|
|
"ret = copy_%s(element, &data->val[data->len]);\n"
|
|
"if (ret) return ret;\n"
|
|
"data->len++;\n"
|
|
"return 0;\n",
|
|
subname);
|
|
|
|
fprintf (get_code_file(), "}\n\n");
|
|
|
|
fprintf (get_code_file(), "int ASN1CALL\n"
|
|
"remove_%s(%s *data, unsigned int element)\n"
|
|
"{\n",
|
|
s->gen_name, s->gen_name);
|
|
|
|
fprintf (get_code_file(),
|
|
"void *ptr;\n"
|
|
"\n"
|
|
"if (data->len == 0 || element >= data->len)\n"
|
|
"\treturn ASN1_OVERRUN;\n"
|
|
"free_%s(&data->val[element]);\n"
|
|
"data->len--;\n"
|
|
/* don't move if its the last element */
|
|
"if (element < data->len)\n"
|
|
"\tmemmove(&data->val[element], &data->val[element + 1], \n"
|
|
"\t\tsizeof(data->val[0]) * (data->len - element));\n"
|
|
/* resize but don't care about failures since it doesn't matter */
|
|
"ptr = realloc(data->val, data->len * sizeof(data->val[0]));\n"
|
|
"if (ptr != NULL || data->len == 0) data->val = ptr;\n"
|
|
"return 0;\n",
|
|
subname);
|
|
|
|
fprintf (get_code_file(), "}\n\n");
|
|
}
|